> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tryprofound.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Segmentar la visibilidad por modelo, región o persona

> Desglosa el Visibility Score de un solo activo según el modelo de IA, la región o la persona que generó la respuesta.

La vista "Compare across models" de la aplicación de Profound muestra la misma métrica dividida
según la superficie de IA que sirvió la respuesta. El mismo patrón funciona para la región y la
persona. Añade el campo de segmentación a `dimensions` (o úsalo como
`filter` para acotar a un solo valor).

## Cómo funciona este ejemplo

1. **Añade el campo de segmentación a `dimensions`** junto con `asset_name`.
   Obtienes una fila por cada (segmento, activo).
2. **Filtra por tu activo** para que la respuesta tenga una fila por segmento.
3. **Ordena por puntuación** para clasificar los segmentos.

<RequestExample>
  ```python Python theme={null}
  import os
  from profound import Profound

  client = Profound(api_key=os.environ["PROFOUND_API_KEY"])

  # What to fetch — replace with your own values.
  CATEGORY_NAME = "<your-category-name>"
  ASSET_NAME    = "<your-asset-name>"
  START_DATE    = "2026-05-05"
  END_DATE      = "2026-05-12"
  SEGMENT       = "model"   # or "region", "persona"


  def get_visibility_by_segment(category_id, asset_name, segment, start_date, end_date):
      """Visibility Score for one asset, broken down by `segment` (model/region/persona)."""
      res = client.reports.visibility(
          category_id=category_id,
          start_date=start_date,
          end_date=end_date,
          metrics=["visibility_score"],
          dimensions=[segment],
          filters=[{"field": "asset_name", "operator": "is", "value": asset_name}],
      )
      m_order = res.info.query["metrics"]
      d_order = res.info.query["dimensions"]
      i_score   = m_order.index("visibility_score")
      i_segment = d_order.index(segment)
      return sorted(
          [(row.dimensions[i_segment], row.metrics[i_score]) for row in res.data],
          key=lambda x: x[1],
          reverse=True,
      )


  # Helpers — translate human-readable names into the IDs the report API needs.

  def find_category_id(name):
      """Return the UUID of the category whose name matches (case-insensitive)."""
      for c in client.organizations.categories.list():
          if c.name.lower() == name.lower():
              return c.id
      raise ValueError(f"No category named {name!r}")


  def find_asset_name(category_id, name):
      """Return the canonical asset name (case-insensitive) inside the category."""
      for a in client.organizations.categories.assets(category_id):
          if a.name.lower() == name.lower():
              return a.name
      raise ValueError(f"No asset named {name!r} in this category")


  # Resolve names → IDs, then run.
  category_id = find_category_id(CATEGORY_NAME)
  asset_name  = find_asset_name(category_id, ASSET_NAME)

  rows = get_visibility_by_segment(category_id, asset_name, SEGMENT, START_DATE, END_DATE)
  print(f"{asset_name} Visibility Score by {SEGMENT}:")
  for segment, score in rows:
      print(f"  {segment:<24} {score:.1%}")
  ```

  ```bash curl theme={null}
  export PROFOUND_API_KEY=your_api_key_here

  curl -X POST "https://api.tryprofound.com/v1/reports/visibility" \
    -H "X-API-Key: $PROFOUND_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "category_id": "your-category-uuid",
      "start_date": "2026-05-05",
      "end_date": "2026-05-12",
      "metrics": ["visibility_score"],
      "dimensions": ["model"],
      "filters": [{"field": "asset_name", "operator": "is", "value": "<your-asset-name>"}]
    }'
  ```
</RequestExample>

## Acotar a un solo segmento

Si solo quieres la puntuación de un modelo (por ejemplo, "¿cuál es mi posición
específicamente en ChatGPT?"), quita `model` de `dimensions` y úsalo como
filtro:

```python theme={null}
filters=[
    {"field": "asset_name", "operator": "is", "value": "<your-asset-name>"},
    {"field": "model",      "operator": "is", "value": "gpt-4o"},
]
```

Ahora la respuesta es una sola fila: la misma forma que la [receta de la
puntuación principal](/es/cookbook/visibility/asset-visibility-score), acotada a ChatGPT.