LLM Citation & Share-of-Answer Tracking Dashboard

For founders: what this changes

Only 16% of brands track AI search performance systematically (source), even though ChatGPT alone now sends 92.4% of all trackable AI referral traffic, up 12.8x in 19 months (source). If you don’t know whether you’re mentioned, you can’t know whether your content work is helping.

One engine isn’t enough anymore

Q2 2026 data across the top 1,000 online retailers found the number with ChatGPT as their largest AI referral source fell from 844 to 722 in a single quarter, while Gemini grew from 16 to 32, Perplexity from 8 to 21, and Claude from 1 to 15 (source). ChatGPT isn’t shrinking in absolute terms, but the field is fragmenting fast enough that a single-engine check goes stale within a quarter.

More mentions doesn’t mean more revenue

ChatGPT drives roughly 97% of LLM-referred ecommerce sessions by volume, but Perplexity-referred visits convert at a 57% higher average order value despite being a sliver of that volume (source). And 68% of AI citations pull from third-party sources rather than a brand’s own site — so the number worth watching isn’t just “are we mentioned,” it’s “who gets cited instead, when we’re not.”

Why this matters more for smaller companies

A large, well-known brand gets mentioned by AI tools regardless of whether anyone is watching. A smaller company is exactly the one that gets left out of the answer entirely if nobody is tracking it — and the fix is usually a specific, findable content gap, not a mystery.

What a healthy first quarter looks like

Signal	What to watch for
Mention rate across engines	Trending up, not flat
Queries newly won	At least a few per month, tied to specific content shipped
Gap list size	Shrinking as content fills it, not growing
Competitor-only queries	Identified and prioritized, not ignored

For engineers: how it is built

The parsing problem this is really solving

Querying four engines is the easy part. The hard part is reliably turning an unstructured text answer into a structured mention/citation record — which is why this uses an LLM call rather than keyword matching:

// Claude response-parsing call (pseudocode)
const prompt = `
Read this AI-generated answer to the query "${query}". Extract:
1. Is "${brandName}" mentioned anywhere? (true/false)
2. Is it cited as a source with a link? (true/false)
3. Which competitor names appear in the same answer? (array)
4. If the brand is absent, what source IS cited for this topic?

Answer text: ${rawResponseText}

Return strict JSON: { mentioned, cited, competitors, absentCitedSource }
`;

const parsed = JSON.parse(await claude.complete(prompt));

A naive keyword match would miss paraphrased brand names and catch false positives from competitor mentions in the same paragraph — both of which quietly corrupt a score over time.

What a week of scored data looks like

Aggregation happens per query, per engine, per week — a query you win on ChatGPT but lose on Perplexity is a different signal than losing everywhere, and collapsing that into one number hides the thing you actually need to act on:

{
  "query": "best waterfall enrichment tool for outbound",
  "week": "2026-W39",
  "results": [
    { "engine": "chatgpt", "mentioned": true, "cited": true, "competitors": ["Clearbit"] },
    { "engine": "perplexity", "mentioned": false, "cited": false, "competitors": ["Clay", "Apollo"] },
    { "engine": "gemini", "mentioned": true, "cited": false, "competitors": [] }
  ]
}

That Perplexity row is exactly what feeds the gap list — it names the competitors winning a query you’re not even showing up on.

Non-determinism is a real engineering problem here

The same query can return meaningfully different answers on repeat runs. Treating one sample as ground truth will make the scorecard noisy and untrustworthy:

// Run each query 3x and take the majority result, not a single sample
async function scoreQuery(query, engine, runs = 3) {
  const results = await Promise.all(
    Array.from({ length: runs }, () => queryAndParse(query, engine))
  );
  const mentionedCount = results.filter(r => r.mentioned).length;
  return { mentioned: mentionedCount >= Math.ceil(runs / 2), sampleSize: runs };
}

Where it breaks, and how the build handles it

Failure	What you would see	How the build handles it
Engine changes response format	Parser silently returns garbage	A fallback prompt (“list every source mentioned”) instead of brittle regex against one response shape
Paraphrased brand name	False negative, score looks worse than reality	Parser matches near-matches and common variants, not just exact strings
Non-deterministic answers	Score swings week to week for no real reason	Run each query 2–3x per engine per week and take a rolling result, not one sample
Query list goes stale	Tracking questions nobody actually asks	Review and refresh the query list quarterly against real search/support queries

Tuning it after launch

• Start with 15–20 queries. Cover core category questions, a few comparisons, and 2–3 “best X for Y” formats. Expand once the pipeline is stable.
• Weight by engine. If Perplexity converts at a meaningfully higher AOV for your business, treat a Perplexity loss as more urgent than a ChatGPT one, even if ChatGPT has more raw volume.
• Close the loop. Every query on the gap list should map to either a new piece of content or a schema fix — /workflows/schema-structured-data-ai-citations is the natural next step for anything schema-shaped.

Stack and running cost

n8n for scheduling and orchestration, Claude for response parsing, engine APIs where available plus controlled browser automation as fallback, and GA4 to correlate tracked queries against actual referral traffic. Cost scales with query count × engines × runs-per-query, so start small and expand deliberately.

Related

• The founder-friendly walkthrough of why this matters more for smaller companies: Share of answer
• This workflow pairs directly with: Schema & structured data automation
• For AI search visibility measured and acted on, not guessed at: Answer engine optimization