AI Visibility Tracking Setup: 30-Minute Workflow

You can set up AI visibility tracking in 30 minutes. Not a polished dashboard. Not a stakeholder-ready program. Just a working measurement loop with real data.

The prototype is simple: pick your prompts, query the engines, log brand mentions and citations, then compare the baseline next week. That is enough to learn whether the program is worth productionizing.

This guide gives you the step-by-step workflow and copy-paste code for an AI visibility tracking setup you can finish before your next standup. For a broader program design, read AI search tracking and the ChatGPT visibility tracker.

What AI visibility tracking actually measures

Before you run the setup, it helps to know what the numbers mean. AI visibility tracking reduces to three metrics, and every dashboard you eventually build is just these three sliced by engine, query, and time. Get the definitions straight now and the CSV you produce in 30 minutes will already answer the questions your stakeholders ask.

Mention rate

Mention rate is the share of tracked queries where an AI engine names your brand anywhere in its answer. It is the closest AI-era analogue to search impressions — did you show up at all? A brand can be named in the prose without being linked, which is exactly why mention rate and citation rate are tracked as separate columns.

Citation rate

Citation rate is the share of answers that link to your domain as a source. This is the metric tied to actual referral traffic, because a citation is a clickable path back to your site. When mention rate is high but citation rate is low, AI engines know who you are but aren’t sending visitors — that is an attribution gap, not an awareness gap, and it changes what you fix next.

Share of voice

Share of voice compares your mention rate against named competitors across the same query set. It answers a blunt question: of all the brands an engine could have surfaced for this prompt, what fraction of the airtime went to you? Share of voice is the number executives ask for first, so capture the competitor columns from the very first run. We go deeper on the metric in AI share of voice.

What you’ll need

• A cloro API key (sign up at cloro.dev). The free trial covers more than enough credits for the prototype.
• Python 3.9+ installed locally (or any HTTP client; we use Python here)
• A Google Sheets or Excel doc to log results
• 30 minutes

No infrastructure, no dashboard tool, no scheduler. The goal here is to validate that AI visibility tracking is worth doing for your brand, not to build the production system.

Minute 0–5: pick your queries

The biggest determinant of whether your tracking program produces useful data is the query set. Open a doc and list 50 queries split roughly:

• 15 branded queries that include your company name. Examples: what does cloro do, cloro vs serpapi, is cloro reliable for SERP scraping.
• 15 category queries about your product space without naming any brand. Examples: best SERP API for AI search, top AI brand monitoring tools, cheapest scraping API for Google.
• 20 use-case queries describing the job your product solves. Examples: how to monitor brand mentions in ChatGPT, how to track AI overview citations, how do I scrape Google AI mode results.

Source the queries from your sales team’s first-call notes (what do prospects actually ask?), your existing Google Search Console data (what queries already drive impressions to your site?), and the autocomplete suggestions for your top 5 head terms. Don’t invent queries from scratch. They need to be queries your buyers actually type.

A whole AI visibility tracking setup lives or dies on this list, so spend the full five minutes here. Favour queries with clear commercial intent over vanity phrases nobody buys on. If you already run rank tracking, your highest-converting keywords are the obvious seeds; if you don’t, your sales inbox holds the exact language buyers use.

Minute 5–10: get a cloro API key

If you already have one, skip ahead. Otherwise, go to cloro.dev, sign up, copy the sk_live_... key from your dashboard, and export it as an environment variable so the script below picks it up:

export CLORO_API_KEY="sk_live_your_key_here"

The free trial gives you enough credits to run the prototype several times without hitting a paywall.

Minute 10–25: run the script

Save the following as track-ai-visibility.py and run it. It hits 4 AI engines (ChatGPT, Perplexity, Gemini, Google AI Overview) with each of your queries and logs the results to a CSV. The script uses the Requests HTTP library, so run pip install requests first if you don’t already have it.

import csv
import os
import requests
from urllib.parse import urlparse

API_KEY = os.environ["CLORO_API_KEY"]
BRAND_DOMAIN = "cloro.dev"  # change to your domain
COMPETITOR_DOMAINS = ["competitor1.com", "competitor2.com"]  # change to yours
ENGINES = ["chatgpt", "perplexity", "gemini", "aioverview"]
COUNTRY = "US"

QUERIES = [
    # Paste your 50 queries here, one per line, as strings.
    "best AI brand visibility tracking tools",
    "how to monitor chatgpt mentions",
    # ... etc
]


def check_query(engine: str, query: str) -> dict:
    """Hit the cloro API for one engine + one query, return parsed mention data."""
    response = requests.post(
        f"https://api.cloro.dev/v1/monitor/{engine}",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={
            "prompt": query,
            "country": COUNTRY,
            "include": {"markdown": True},
        },
        timeout=120,
    )
    response.raise_for_status()
    data = response.json()["result"]

    sources = data.get("sources", [])
    text = (data.get("markdown") or "").lower()

    brand_mentioned = BRAND_DOMAIN in text or any(
        BRAND_DOMAIN in (s.get("url") or "") for s in sources
    )
    competitor_mentions = sum(
        1 for c in COMPETITOR_DOMAINS
        if c in text or any(c in (s.get("url") or "") for s in sources)
    )
    brand_cited = any(BRAND_DOMAIN in (s.get("url") or "") for s in sources)

    return {
        "engine": engine,
        "query": query,
        "brand_mentioned": brand_mentioned,
        "brand_cited": brand_cited,
        "competitor_mentions": competitor_mentions,
        "total_sources": len(sources),
    }


def main():
    rows = []
    for query in QUERIES:
        for engine in ENGINES:
            try:
                rows.append(check_query(engine, query))
                print(f"  {engine}: {query[:60]}")
            except Exception as e:
                print(f"  ! {engine}: {query[:60]} -> {e}")

    with open("ai-visibility-results.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=rows[0].keys())
        writer.writeheader()
        writer.writerows(rows)

    # Summary
    total = len(rows)
    mentioned = sum(1 for r in rows if r["brand_mentioned"])
    cited = sum(1 for r in rows if r["brand_cited"])
    print(f"\nMention rate: {mentioned}/{total} = {100*mentioned/total:.1f}%")
    print(f"Citation rate: {cited}/{total} = {100*cited/total:.1f}%")


if __name__ == "__main__":
    main()

Run it:

python3 track-ai-visibility.py

For a 50-query × 4-engine matrix, the script takes 5–15 minutes depending on engine response times. The output is a CSV with one row per query-engine pair plus a summary printed to stdout.

Minute 25–30: read the baseline

Open ai-visibility-results.csv in Sheets/Excel. The summary numbers at the bottom of the script output are your baseline mention rate and citation rate. Don’t over-interpret a single run — the value of this AI visibility tracking setup is the trend line, and you don’t have one yet. For now, just look for the obvious asymmetries across three cuts:

• Mention rate by engine. A pivot table on engine × brand_mentioned shows whether you’re invisible on Perplexity but present on ChatGPT, or any other per-engine pattern.
• Mention rate by query intent bucket. Tag each query as branded/category/use-case and pivot. Branded mention rate near 100% is expected. Category mention rate at 0% is your biggest opportunity. Use-case mention rate is where buying intent lives.
• Citation rate vs mention rate. The ratio between these two tells you whether AI engines drive traffic to you or just brand awareness without clicks. Low citation rate means you have an attribution problem, not a visibility problem.

One ratio is worth writing down before you close the file: citations divided by mentions. Treat that number as the headline KPI of your AI visibility tracking setup, because it captures both whether engines know you and whether they send traffic. A ratio climbing week over week means your content is getting more cite-worthy; a flat ratio with rising mentions means awareness without clicks.

That’s the baseline. Save the CSV with today’s date in the filename, then run the script again next week and diff the two files. That diff is your AI search tracking program in week 2, and the same pattern scales to a weekly cadence indefinitely.

What to do when the baseline looks weak

Your first AI visibility tracking setup will almost always surface an uncomfortable number or two. That is the point — a baseline you feel good about on day one isn’t measuring anything real. Here is how to read the three most common bad results, and what each one tells you to fix first.

Category mention rate near zero

If you appear for branded queries but vanish on category queries, AI engines recognise your name but don’t treat you as a default answer for the problem you solve. This is the most common pattern for younger brands, and it is a content-and-citation problem, not a tracking bug. Publish the comparison pages, plain-language definitions, and how-to guides that engines pull from, and make sure each one is crawlable and quotable. Re-run the AI visibility tracking setup in two weeks and watch whether category mentions start to move.

High mentions but low citations

When engines name you but rarely link you, your attribution surface is thin. The fix is structural: sharp, quotable claims, a clean information architecture, and pages that answer the exact question a prompt implies. Citations follow quotability, not brand size, so a small brand with extractable pages can out-cite a much larger competitor. Track the mention-to-citation ratio every week and treat a widening gap as a content-formatting task, not a PR one.

One engine lagging the rest

Per-engine gaps are normal — the engines crawl differently and weight sources differently. If you are strong on ChatGPT but weak on Perplexity, that usually reflects which sources each engine trusts rather than a flaw in your setup. Don’t chase parity for its own sake. Prioritise the engine your buyers actually use, which your query-intent buckets already point you toward.

What productionizing looks like (when you’re ready)

The prototype above answers “is this worth doing”. Within a week or two of running it, the answer is usually yes. The path from prototype to production is five well-worn steps:

1. Move the CSV to a warehouse. Pipe results into Postgres, BigQuery, or Snowflake instead of a flat file — BigQuery’s batch load ingests CSV directly, so the transition is mechanical. Store one row per query-engine-week.
2. Schedule the script. A GitHub Actions scheduled workflow runs it on a cron trigger with no server to maintain; plain cron or Airflow work equally well. Weekly is the right default cadence.
3. Build a dashboard. Looker or Metabase if you already run one, otherwise a lightweight Streamlit app. Show mention rate trend, share of voice trend, citation rate trend, and a query-level breakdown.
4. Add competitor tracking. Expand the script to compute share of voice automatically against your top 3–5 competitors.
5. Layer in sentiment. Pipe each response text through a sentiment classifier and store the score per row.

Or skip steps 1–5 entirely and use cloro’s AI visibility tracking as the production layer. Same API, same engine coverage, but you don’t build the warehouse, scheduler, or dashboard yourself. We covered the build-vs-buy trade-off in AI search visibility tools: build vs buy.

Common gotchas

• Personalization. If you’re testing AI engines manually in a browser, your logged-in account skews the results. The API approach above sidesteps this. Every API call is a clean session.
• Rate limits. The upstream APIs behind ChatGPT, Gemini, and Perplexity all cap requests per minute, so a tight loop occasionally rate-limits. cloro’s API handles retries transparently, so the script above doesn’t need its own retry logic.
• Country drift. AI engines personalize by IP geo. The country: "US" parameter ensures consistent country targeting. Change it for international tracking.
• Query set staleness. The 50 queries that mattered three months ago aren’t the same queries that matter today. Refresh quarterly.

Turning the prototype into a weekly habit

The 30-minute AI visibility tracking setup is a prototype, but its value only compounds if you re-run it on a schedule. The cadence below works for most teams without turning tracking into a second job.

Weekly is the right default

Run the same query set once a week and diff the CSVs. AI answers shift as engines update their models and re-crawl the web, so week-over-week movement is signal rather than noise. Daily tracking oversamples that churn; monthly tracking misses fast regressions. Weekly sits in the sweet spot for most B2B brands.

Watch the deltas, not the absolute numbers

A single week’s mention rate is a snapshot. The diff between two weeks is the story. Flag any query where you dropped from mentioned to absent, and any query where a competitor appeared for the first time. Those two events are your early-warning system, and they surface long before a quarterly report would. A single dropped query rarely matters; three dropped queries in the same intent bucket is a trend worth acting on that week.

Keep the query set stable, then version it

Resist the urge to rewrite queries every week — you cannot compare against a moving baseline. Freeze the set for a quarter, then version it deliberately when your positioning or product changes. Note the version in the CSV filename so an old and a new baseline never get diffed against each other by accident.

Next steps

Once you have a baseline, the next decisions are which engines to add (we recommend AI Mode, Copilot, and Grok in that priority), what cadence to settle on (weekly is the right default), and which platform tool to layer in for stakeholder dashboards (see LLM visibility tracking tools). The 30-minute prototype is the smallest end-to-end loop you can build. Everything from here is iteration.