> ## 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.

# Clasificación de los N principales

> Clasifica todos los activos de una categoría según cualquier métrica de visibilidad.

La clasificación del mosaico de Visibility es la misma llamada agregada que el
valor principal, sin el filtro de activos. La API devuelve una fila por activo,
y tú ordenas del lado del cliente.

## Cómo funciona este ejemplo

1. **Agrega `asset_name` a las dimensiones y elimina el filtro.** Ahora cada activo
   tiene su propia fila.
2. **Ordena del lado del cliente.** La API devuelve las filas en el orden en que
   las calculó (normalmente ordenadas por la primera métrica de forma descendente);
   vuelve a ordenarlas siempre en tu código para que el resultado sea determinista.
   Usa `reverse=True` para las métricas en las que "más alto es mejor", como
   `visibility_score`, y `reverse=False` para `average_position`
   (una posición más baja = mejor).
3. **`pagination.limit`.** El valor predeterminado es 100. Auméntalo (máximo 50,000)
   si tu categoría tiene muchos activos.

<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>"
  START_DATE    = "2026-05-05"
  END_DATE      = "2026-05-12"   # exclusive — returns data through 2026-05-11
  METRIC        = "visibility_score"   # or share_of_voice, average_position, ...
  TOP_N         = 10


  def get_leaderboard(category_id, metric, start_date, end_date):
      """All assets in the category ranked by the chosen metric."""
      res = client.reports.visibility(
          category_id=category_id,
          start_date=start_date,
          end_date=end_date,
          metrics=[metric],
          dimensions=["asset_name"],
          pagination={"limit": 50000, "offset": 0},
      )
      m_order = res.info.query["metrics"]
      d_order = res.info.query["dimensions"]
      i_metric = m_order.index(metric)
      i_asset  = d_order.index("asset_name")

      # Lower-is-better for average_position; higher-is-better for everything else.
      reverse = metric != "average_position"
      return sorted(
          [(row.dimensions[i_asset], row.metrics[i_metric]) for row in res.data],
          key=lambda x: x[1],
          reverse=reverse,
      )


  # Helper — translate the category name to the UUID the report API expects.

  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}")


  # Resolve name → ID, then run.
  category_id = find_category_id(CATEGORY_NAME)
  leaderboard = get_leaderboard(category_id, METRIC, START_DATE, END_DATE)

  for rank, (name, value) in enumerate(leaderboard[:TOP_N], start=1):
      print(f"{rank:>2}. {name:<24} {value:.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": ["asset_name"],
      "pagination": {"limit": 50000, "offset": 0}
    }'
  ```
</RequestExample>

## Cómo destacar tus activos propios

Para marcar tus propios activos en la clasificación (la etiqueta "Owned" en la
interfaz de Profound), combina la respuesta con la receta
[Enumera tus activos propios](/es/cookbook/setup/list-owned-assets): devuelve el
conjunto de nombres de activos marcados con `is_owned` en esta categoría.