AI Brand Watch — monitor your brand's visibility in ChatGPT, Claude, Perplexity & Gemini

Know the day AI stops recommending you. AI Brand Watch measures the answers, mentions, citations, position and competitors that ChatGPT, Claude, Perplexity and Gemini return for the questions that define your category — on a schedule — and tells you what changed: repeated sampling, share-of-voice diffs and signed webhooks, not dashboards.

One LLM answer is a snapshot, not a measurement. AI engines are non-deterministic — ask the same question twice and you may get a different brand set. So Brand Watch samples each question N times per engine and reports the rate at which your brand appears. 3 samples. One price. Just add your brand name — the category questions, competitors and domain are discovered and frozen for you, so every scheduled run measures the same questions.

by Desvela — your agent sleeps, Desvela doesn't.

Pay per check. No subscription, no minimum. A full first run — 20 questions across 2 engines — costs about $3.22. You get the real report, with the engines' own words.

How it works

1. Tell it your battlefield. A brand name is enough — add your domain, aliases and competitors to sharpen the signal. To see which competitor the AI cites by URL (not just mentions), also pass their domains: competitorDomains: {"Coda": "coda.io"}. If you don't list category questions, the actor discovers a frozen Prompt Set for you (5-10 buyer questions + competitors) or reuses the one from your previous run, so a scheduled watch measures the same questions every time.
2. It samples the engines. AI answers vary between runs, so each question is asked N times per engine. You get the mention rate — the % of samples that mention you — plus your average textual position (avgPosition, first appearance among brand + competitors — not a recommendation rank), recommendationRank (your position in an explicit numbered list, if the engine uses one) and which sources each engine cites.
3. You only hear about changes. A signed webhook (or the dataset) fires when you appear, disappear, shift ≥25 points, or the engine starts citing a new source or competitor. Schedule it weekly with Apify Schedules and forget it.

Every run also emits a visibilityScore (0–100) summary — one comparable number per brand, built from share of voice (55%), mention position (15%), engine coverage (15%) and citations of your own URL (15%). Track it weekly; screenshot it for your boss.

Why sampling matters

AI engines are non-deterministic. Ask the same question to the same engine three times and you get different answers:

1. sample 1 → brand present
2. sample 2 → brand absent
3. sample 3 → brand present

That is mentionRate = 2/3 = 0.67: the brand appears in two of three answers. A single check — what most "AI visibility" tools sell — would have returned 0% or 100%, chosen by luck, not by the market. Track that single number and it moves next week even when nothing about your brand changed.

Repeated sampling is also why diffs mean something. A rate over N samples is stable enough to compare run to run; a single answer is not. When Brand Watch alerts that you disappeared or a competitor entered the answer, it is alerting on the rate, not on one model's mood.

3 samples. One price. The $0.08 per query × engine covers every sample in that cell — you are not paying per snapshot, the price already bought the methodology.

Pricing (pay per check, no subscription)

Event	Price
Actor start	$0.02
Brand query checked (per query × engine, includes all samples)	$0.08
Prompt discovery (zero-config only — when a Prompt Set is actually generated)	$0.04
GEO recommendations (opt-in add-on, per run)	$0.04
Sentiment (opt-in add-on, per cell delivered)	$0.04
Change alerts	free

Typical setup — 20 queries × 2 engines, weekly: ≈ $14/month — SaaS equivalents charge $29–$99+/month for the same signal (Semrush AI Visibility from $99/mo, Otterly from $29/mo). If you're looking for an Otterly, Peec, Profound or Semrush AI Visibility alternative without the subscription, this is it.

Sentiment (opt-in, transparent marginal cost)

Turn on includeSentiment to get a positive/neutral/negative label per measured cell — "and what are they saying about me?" at a bounded, documented price: $0.04 per cell (20 cells → +$0.80). One Claude call per cell, not per sample, fed with the cell's verbatim evidence — sentiment per sample would multiply calls and break the per-check economy. It is a descriptor only: it never triggers change alerts and never appears in the webhook. Default is off, so every existing run costs exactly the same. If the call fails, that cell is sentiment: null and is not charged.

Zero-config: {"brandName": "Notion"} is enough

The first run discovers a Prompt Set for you (one Claude call, $0.04 + the usual start/check events), and from then on the actor reuses that frozen set on every scheduled run — no LLM call, no prompt-discovery charge. Reusing your own list of questions is the point: a watch that changes its questions would be diffing apples against oranges. Entry cost for a zero-config run with 2 engines: ≈ $0.02 (start) + $0.04 (discovery) + $0.16 (1 query × 2 engines) for the first run, then just the per-check cost.

Agents can pay for this themselves (x402)

This Actor accepts agentic payments over x402: an AI agent can run it paying USDC on Base, with no Apify account, no billing setup and no API key. Calling it without credentials returns 402 Payment Required with the payment terms attached, which is exactly what an x402 client expects:

curl -i -X POST https://api.apify.com/v2/acts/desvela~brand-watch/runs \
  -H 'Content-Type: application/json' -d '{}'
# HTTP/2 402 · {"error":{"type":"x402-payment-required", ...}}

Practical note: Apify's agentic flow buys a prepaid, spend-capped token with a $1 minimum, valid 14 days, and unused balance is not refunded. At $0.08 per query·engine that first dollar covers roughly a dozen checks, so it is worth spending it rather than topping up per run.

Not every Actor is eligible (it requires pay-per-event pricing, limited permissions and no Standby mode). This one is, and no opt-in is needed on your side.

Webhook payload

The webhook body is a self-contained, versioned envelope (schema v2): everything a consumer (human or agent) needs to understand a change — the run that produced it, the frozen question set it was measured under, and the verbatim evidence — ships inside the event. No need to reinterpret the dataset.

{
  "schemaVersion": 2,
  "runId": "wAT3x...",
  "brand": "Acme CRM",
  "promptSetId": "ps_a1b2",
  "promptSetVersion": 4,
  "generatedAt": "2026-08-08T10:05:00.000Z",
  "events": [{
    "event": "brand_visibility_changed",
    "schemaVersion": 2,
    "brand": "Acme CRM",
    "engine": "perplexity",
    "query": "best CRM for small business in Spain",
    "promptSetId": "ps_a1b2",
    "promptSetVersion": 4,
    "runId": "wAT3x...",
    "change": {
      "type": "disappeared",
      "reason": "mentionRate 0.67 → 0 (disappeared)",
      "mention_rate": { "before": 0.67, "after": 0, "delta": -0.67 },
      "share_of_voice": { "before": 0.67, "after": 0 },
      "new_cited_source": "reddit.com/r/smallbusiness/..."
    },
    "evidence": ["Acme is absent from the engine's answer for this query"],
    "samples": 3,
    "stableSources": ["hubspot.com/...", "zoho.com/..."],
    "checked_at": "2026-08-08T09:00:00Z",
    "previous_checked_at": "2026-08-01T09:00:00Z"
  }]
}

change.share_of_voice is kept as a legacy alias of mention_rate (same values, same position in the payload): consumers that shipped against the v1 contract keep working unchanged — only add reason, mention_rate, evidence, samples and stableSources if you want them.

Requests are signed with X-Desvela-Signature (HMAC-SHA256) over the entire envelope body. Docs: desvela.dev.

What the numbers mean: mention rate, not (competitive) share of voice

Each dataset cell reports the mention rate (mentionRate, schema v2): the fraction of samples whose answer mentioned the brand. Example — 3 samples of the same question to the same engine (present / absent / present) → mentionRate = 0.67. A single sample would have been 0% or 100% arbitrarily, so we always sample N≥3 and report the rate.

That is not a competitive share of voice. The real comparative metric is competitiveShareOfVoice (per cell): samples where the brand appears ÷ samples where the brand or any watched competitor appears — null when there is no competition in that cell. Each run also reports overallCompetitiveSoV in the summary row. Meanwhile shareOfVoice remains in the dataset as a legacy alias with the same value as mentionRate; new consumers should read mentionRate.

Citations tell a different story than mentions. With your domain you get ownedCitationRate (samples that cite your site) and earnedCitationRate (samples that cite anything else); with competitorDomains you get competitorCitationRate per cell plus competitorCitationRates per competitor — which competitor the AI links to, not just names. All three are null (never 0) when the engine returns no citations (e.g. Gemini without grounding) or the required input is missing. The summary row carries the run-level averages (overallOwnedCitationRate, overallEarnedCitationRate, overallCompetitorCitationRate).

Audit vs Watch: which moment are you in?

The product has two moments. The first run of a brand — or the first run after the questions change or you force promptSetAction: renew — is an audit: it measures the frozen question set and emits no change events, because there is nothing to compare against yet. Every later run that measures the same frozen question set is a watch: it diffs against the baseline and only wakes you up on a meaningful change.

Every run's summary row (and the SUMMARY key-value record) tells you which moment you are in:

Field	Meaning
runRole	audit (this run is establishing the baseline) or watch (there is a baseline to compare against)
baselineEstablished	Whether a baseline from a previous run of the same prompt set existed when this run executed
promptSetChanged	This run measures a new frozen question set (methodology changed) — runRole will be audit again

AUDIT → establish baseline → WATCH → measure the same prompt set → compare → meaningful change? → event. This is metadata and communication, not a new execution mode: an audit run measures exactly what it always measured — it just says so.

From audit to Watch: the next step after any run

Every run's SUMMARY key-value record now ships a nextSteps block (label: "Monitor this brand automatically"). It tells you exactly how to turn this one-shot audit into a recurring Watch, with no code:

1. A Watch is an Apify Schedule that re-runs this Actor. The Actor is already watch-native (promptSetAction: keep reuses the frozen question set and diffs against its baseline); the recurring trigger is a Schedule — there is no separate Watch interface, and nothing runs on our servers.
2. Open Apify Schedules → Create new → Add → Actor → desvela/brand-watch, set the interval, and paste the run's input JSON into Input JSON overrides.
3. The input uses the real schema field names (brandName, samplesPerQuery, domain, queries, engines, competitors, promptSetAction: keep) — never undefined, never invented fields. It reuses the monitoring configuration from this run, including competitors: the frozen prompt-set fingerprint combines questions and competitors, so dropping them would silently start a new baseline on the first scheduled run instead of watching.

Platform limitation (verified): console.apify.com/schedules does not accept deep-links with pre-filled input. Apify won't auto-fill the schedule from a URL — you paste the JSON the run gives you. The nextSteps block says this explicitly rather than promising a one-click handoff.

What we can and cannot measure about this CTA (honest):

• Appeared: yes — nextSteps is present in every SUMMARY record; its presence is deterministic.
• Schedule created / activated: not directly observable. We can only infer it: a later scheduled run of the same brand with runRole: watch and the same promptSetId is strong evidence a recurring schedule exists and fired. We cannot attribute which schedule or user created it, and we cannot observe the moment of activation.
• Link opened: not observable. Apify does not tell us whether console.apify.com/schedules was clicked from the run, and we cannot attribute it. It is intentionally not listed as a metric.

The three levels of use stay separate: audit (one-off, no code) → Watch (recurring via Apify Schedules, no code) → integration (API / MCP / webhook, for systems and agents — see desvela.dev).

Real numbers from our own brands

Before charging anyone we ran Brand Watch on two businesses we own (full disclosure — that's why we can show the raw numbers):

• A digital time-capsule product: 0% share of voice across all four engines — completely invisible. But the run returned the exact sources the engines cite instead (YouTube dominates; Arweave, IPFS and OpenTimestamps own the category). That list is the GEO to-do list — one run, ~$5.
• A photography backdrop store: brand mentions 0%, yet its URL is cited by Perplexity in 4 of 5 queries. Brand mention and source citation are different metrics — we measure both. Each engine cites a different source ecosystem (Gemini favors photo blogs; Perplexity cites the store and Reddit).
• On the purchase-intent query ("where to buy…") the store appeared in 1 of 3 samples. A single check would have called that yes or no at random; sampling turns it into a rate worth tracking — the weekly watch now guards exactly that number.

Honest measurement notes

• We call the engines' APIs with web search enabled. API answers correlate with, but are not pixel-identical to, each consumer product. We always measure the same way, so diffs are valid.
• Mention rate over N samples is the metric — single snapshots of a non-deterministic system are noise, and we refuse to sell you noise.

FAQ

Which engines? OpenAI (ChatGPT), Perplexity, Anthropic (Claude), Gemini. Pick any subset. Why not a single answer? Because a single LLM answer is a snapshot of a non-deterministic system — ask twice and you may get a different brand set. We sample each question N times per engine and report the rate your brand appears, so the number you track is a signal, not luck. A single check can tell you 0% on a good day; the rate over 3 samples can't. Do I need my own API keys? No — checks run on ours; the per-check price includes it. Can my AI agent consume this? Yes — that's the point. Webhook + dataset are structured for machines, and the actor is callable as an MCP tool today via the Apify gateway: https://mcp.apify.com/?tools=desvela/brand-watch (works from Claude, Cursor or any MCP client — docs at desvela.dev).

Published examples (Apify Store)

The Examples tab of the Store listing is filled with published tasks: each one gets its own SEO landing page at https://apify.com/desvela/brand-watch/examples/<slug>, indexed by search engines and readable by AI agents. No two examples duplicate another — each demonstrates one concrete capability.

The ten current examples and the capability each one teaches:

Task (slug)	Capability
zero-config-visibility-audit	Just {"brandName": "Notion"} — the actor discovers and freezes the question set
track-ai-visibility-across-engines	Same queries across all 4 engines, one comparable report
is-chatgpt-recommending-your-brand	One engine, purchase-intent queries, 3 samples per query
detect-competitor-entering-answer	Changes column + webhook when a watched competitor shows up
detect-your-brand-disappearing	Frozen baseline; flags the cells where you vanished
track-stable-citations	sources / stableSources — which citations build the answer
campaign-baseline-before-launch	promptSetAction: renew establishes a fresh baseline (no alerts)
campaign-impact-after-launch	Same questions/engines with keep — before/after diff
webhook-only-on-meaningful-change	webhookUrl + notifyOnlyOnChange: true
compare-visibility-four-ai-engines	One query, all 4 engines, engine-level comparison

Reproducing the examples

The tasks are declared once in scripts/examples/manifest.json (name, SEO title, SEO description, input). scripts/publish-tasks.sh is idempotent — it creates any missing task and updates the existing ones to match the manifest:

APIFY_TOKEN=apify_api_xxx scripts/publish-tasks.sh          # create/update tasks, list landing pages
APIFY_TOKEN=apify_api_xxx scripts/publish-tasks.sh --check  # also curl each landing page for HTTP 200

Publishing a task is a Console-only action (there is no API for it): Console → Actor brand-watch → Tasks → each task → Publication tab → the SEO title is prefilled from the task but the SEO description has no API field — paste it from the script's output (or scripts/examples/manifest.json) → select which input fields to show (keep them all — display-only) and the dataset view (use Brand visibility / overview) → Publish task. The landing page is live as soon as you do.

Development

npm ci                 # install
npm test               # vitest — run the unit tests
npm run typecheck      # tsc --noEmit
npm run lint           # eslint
npm run build          # compile to dist/ (excludes tests)

Tests cover the measurement logic (mention detection, aggregation, diff, score) and the engine adapters (parsing + retry), all against mocked HTTP. CI runs typecheck → lint → test → build on every push/PR (.github/workflows/ci.yml).

---

Find this actor by what it does: AI brand monitoring · AI visibility tracker · share of voice in ChatGPT · brand mentions in AI answers · ChatGPT brand tracker · Perplexity brand monitor · Gemini visibility · Claude brand mentions · LLM brand tracking · AI search monitoring · AI citation tracker · GEO audit · AEO tools · generative engine optimization · answer engine optimization · AI SEO · brand watch · AI brand visibility API · Otterly alternative · Peec alternative · Profound alternative · Semrush AI Visibility alternative · no-subscription AI rank tracker · MCP brand monitoring tool.