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

# Segment Visibility by model, region, or persona

> Break a single asset's Visibility Score down by which AI model, region, or persona generated the answer.

The Profound app's "Compare across models" view shows the same metric split
by which AI surface served the answer. Same pattern works for region and
persona. Add the segmentation field to `dimensions` (or use it as a
`filter` to slice to one value).

## How this example works

1. **Add the segmentation field to `dimensions`** along with `asset_name`.
   You get one row per (segment, asset).
2. **Filter to your asset** so the response is one row per segment.
3. **Sort by score** to rank the segments.

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

## Slicing to a single segment instead

If you only want the score for one model (say, "where do I stand on
ChatGPT specifically?"), drop `model` from `dimensions` and use it as a
filter:

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

Now the response is one row — same shape as the [headline
recipe](/cookbook/visibility/asset-visibility-score), scoped to ChatGPT.