AI Search Visibility Monitor

Share of voice, trend deltas, and anomaly alerts for your brand across AI answer engines — deterministic, scheduled, and stateless.

AI answers are the new front page. When ChatGPT, Perplexity, Gemini, or Google's AI Overviews answer a buyer's question, either your brand is in the answer or a competitor's is — and that visibility moves week to week with no changelog. This actor turns snapshots of AI answers into a deterministic visibility time series: share of voice per entity, delta since last run, and statistical anomaly alerts when your visibility spikes or collapses.

Part of the Broomwagon family: deterministic tools that watch scraped and AI data change. No LLM judges your numbers — same snapshots in, same metrics out, every time.

The pipeline: collect → measure → alert

You don't need to gather AI answers yourself. Collection is a solved problem on Apify — this actor is the measurement stage that runs after it:

1. Collect (any AI-answer scraper). Schedule a collection actor from the Store (Google AI Mode / AI Overviews scrapers, ChatGPT scrapers, Perplexity scrapers) to ask your buyer-intent queries — "best CRM for small business", "top donut shops in Andersonville" — on a cadence. Its output is a dataset of answers.
2. Measure (this actor). Point datasetId at that run's dataset and list the entities you track: your brand and your competitors. Every text field is scanned; whole-word entity matching, deterministic counts.
3. Alert. Each run emits one row per entity: share of voice, mention counts, delta vs. last run, z-score vs. your rolling baseline, and anomaly: true when a change is statistically real (|z| ≥ 3 against an EWMA baseline) rather than noise. Filter on anomaly in n8n/Make and pipe it to Slack; that's the whole monitoring loop.

The chaining is zero-glue: create one key-value store in your account, put its ID in memoryStoreId, and schedule this actor right after your collection run. Baselines, deltas, and anomaly flags accumulate automatically, run after run.

Why a separate measurement stage

The value isn't in any single week's answers — it's in noticing when they change. That takes memory: which engines mentioned you last month, what your normal share of voice looks like, whether this week's dip is Tuesday noise or a real displacement. Normally that memory means a SaaS subscription and someone else's database. Here it means a compact aggregate you hold (see below), and a per-run price in cents.

Stateless, with memory

Every run returns a compact aggregate (the MEMORY key-value record) holding your per-entity rolling baselines — sufficient statistics, never your data. Pass it back next run (memory), or point the actor at a key-value store in your account (memoryStoreId) and scheduled runs chain automatically. Broomwagon stores nothing; your history is yours.

First run establishes the baseline; deltas begin on run two; anomaly detection engages after five runs of baseline.

Try it in two minutes (no scraper needed)

Run 1. Set Entities to track to ["Your Brand", "Competitor A"], paste a few AI-answer snapshots into Inline snapshots (any records with text fields work — each record is one answer), and start the run. You get one visibility row per entity (share of voice, mention counts) and a MEMORY record in the run's key-value store: your rolling baselines, held by you.

Run 2. Copy the MEMORY object into Previous memory, run again with fresh snapshots — now each row also carries previousShare, delta, and a zScore. After five runs of baseline, statistically significant swings set anomaly: true and bill as anomaly alerts. In real use, replace the pasted snapshots with your scheduled collection run's dataset as described above.

Input

• entities (required): names to track, e.g. ["Broomwagon", "Competitor A"].
• datasetId | items | fileUrl: the snapshot records.
• textFields: which snapshot fields to scan (default: all text).
• memory / memoryStoreId: the memory, as above.

Output

• Dataset: one entity-visibility row per entity per run (share, mentions, delta, zScore, anomaly).
• OUTPUT: run report. MEMORY: your rolling baselines, to send back next run.

Pricing (pay-per-event)

Event	What you pay for	Price
entity-report	Per entity tracked, per run	$0.10
anomaly-alert	Per statistically significant change detected	$0.05
apify-actor-start	Run start, per GB of run memory	$0.005

Worked example: tracking your brand plus four competitors, daily: 5 entities × $0.10 × 30 days ≈ $15.15/month (plus a nickel per anomaly actually detected — a healthy month has few). An agency running ten client rosters: ~$150/month, billed per event, no seats, no contract. Collection costs (the AI-answer snapshots you pipe in) are separate and belong to whichever scraper you choose.

Set a max charge on any run (Maximum cost per run in Console, or ACTOR_MAX_TOTAL_CHARGE_USD via API) and the actor stops cleanly at your budget.

Integrations

• Apify Schedule (zero glue): create a key-value store once, put its ID in memoryStoreId, and schedule this actor right after your snapshot collection run. Baselines, deltas, and anomaly flags accumulate automatically.
• API: POST https://api.apify.com/v2/acts/broomwagon~ai-search-visibility-monitor/runs with {"entities": [...], "datasetId": "<snapshot run's dataset>", "memory": <last MEMORY record>}. Read MEMORY back from the run's key-value store for the next call.
• n8n / Make: collection node → this actor → filter on anomaly: true → Slack or email alert. That's a complete brand-monitoring pipeline in four nodes.
• MCP / AI agents: callable as a tool via the Apify MCP server; agents round-trip the MEMORY object as tool context between calls.

Roadmap

Citation-level analytics (which sources AI engines cite when they mention you — being cited without being named is its own signal), competitor-displacement events, and per-engine breakdowns. Built by an ex-Elastic engineer who spent years on log analytics — this is time-series observability applied to AI search.

The Broomwagon family

This actor is one of nine deterministic post-processing tools from Broomwagon: the layer that follows your scrapers and agents, cleaning and watching what they produce. Same input, same output, every time.

• Scraper Output Monitor — catch the day your scrape silently breaks.
• Only New Items — deliver only records you have never delivered before.
• Dataset Deduper — exact and fuzzy dedupe for any dataset, with an audit trail.
• CSV Doctor — repair broken CSV files, with a report of every fix.
• LLM Output Guard — validate LLM and agent JSON against your schema.
• PII Redactor — strip emails, phones, SSNs, cards, and addresses, deterministically.
• Record Linker — fuzzy join two datasets that share no key.
• Google Maps Scraper Deduper — merge duplicate places across Google Maps scrapes.