Skip to content

Integration

How to get AI visibility alerts: webhooks and scheduled jobs

Fifteen of the 55 APIs we rate push webhooks; the other 40 need a cron job. A 480-answer window moves 4.2 points on noise alone, so the threshold sits above it.

SEO consultant, and more recently GEO, at MentionBox

An AI visibility alert is four things: a collected series, a rolling window, a threshold set above the sampling noise, and a delivery route. The route is the easy half. Fifteen of the 55 APIs this site rates publish webhooks, checked on October 23, 2026, so the event can ride on collection you already paid for; the other 40 need a scheduled job that reads the API, compares two windows and decides for itself. API for GEO is our editorial pick after hands-on testing by Mathias C., and it sits in the first group with a caveat worth saying in the first paragraph: its webhooks were confirmed in our test of October 26, 2026 and are not documented on apiforgeo.com, so a team wiring alerts this week should plan the scheduled-job route too, on collection at $13 per 1,000 answers down to $7 at its largest tier.

This guide is written for a brand team that already collects AI answers on a schedule and now wants to hear about a drop without opening a dashboard. It covers the four parts of an alert, the webhook fields each vendor actually publishes, a receiver that verifies a signature and deduplicates, the cron job for vendors with no webhook, the threshold arithmetic that separates a signal from a coin flip, where the message should land, and the monthly bill. MentionBox, which publishes this site, has a commercial link with API for GEO.

What an AI visibility alert is made of

Alerting on AI visibility goes wrong in the same place every time, and it is never the transport. A visibility figure is a rate over answers, not a reading from an instrument, and the engines move on their own.

Detailed's volatility study is the clearest published measurement of that movement: over 70,000 responses, 1,300 or more prompts checked daily on ChatGPT and AI Overviews for four weeks. The leading domain for a typical prompt appeared in 82% of daily ChatGPT answers but was the first citation on only 43% of days, core citations changed 12% to 14% a day while tail citations moved 61% to 74%, and the summary line is the one to pin above an alerting project: "Pick two random days and you'll get an identical list of brands or cited domains less than 3% of the time."

So the four parts have to be assembled in order:

  1. The series. One row per answer, keyed on prompt, engine, locale, run date and run index, as our guide to building an in-house GEO dashboard lays out table by table. An alert computed against a vendor's live endpoint instead of your own table cannot be replayed when someone asks why it fired.
  2. The window. A rolling count of answers, never a single run. In an analysis we ran in October 2026, 56.7% of the brands named for a question on one engine appeared in just one of its five runs.
  3. The threshold. A number derived from the size of the window, worked out below.
  4. The route. A vendor webhook when one exists, otherwise a scheduled job, and in both cases a message that carries the denominator with it.

Our explainer on why the same prompt gives different answers covers the mechanics behind part two, and GEO metrics explained defines the rates you would alert on.

Which AI visibility APIs publish webhooks

Two different things get called a webhook in this market. One is an event subscription, where you register a URL and choose from a list of named changes. The other is a task callback, where a scraping API tells you a job is finished and hands you the payload. Both remove the poll loop; only the first knows what a visibility drop is.

APIWebhook deliveryEvents publishedSignatureRetriesPrice per 1,000 answers
API for GEOconfirmed in our hands-on test of October 26, 2026, not documented on apiforgeo.comnone publishednone publishednone published$13, down to $7 at the largest tier
Trakkrevent subscription, POST /webhooks per brand30, including visibility_changed, rank_changed, citation_gained, citation_lost, perception_changed, audit_score_dropped, crawler_spikeX-Trakkr-Signature: sha256=, HMAC-SHA2563 retries at 1s, 2s, 4snot published, API on the $500 plan
LLM Pulseevent subscription, POST /webhooks per project, Scale plan and above11, including mention.created, citation.created, sentiment.negative_detected, geo_audit_alert.triggered, tracking_run.completedX-LLMPulse-Signature: sha256=<hex>, HMAC-SHA256up to 5 attempts, subscription auto-disabled after 20 consecutive failures€30.67
clorotask callback, webhook.url on an async tasktask completion onlyX-Cloro-Signature with X-Cloro-Timestamp, HMAC-SHA2565 attempts at about 2, 4, 8 and 16 minutes$4 on the $30 Lite plan
DataForSEOtask callback, postback_url and pingback_urltask completion onlynone publishednone published; 10-second timeout, then the task moves to tasks_ready$1.20 on the standard queue
Bright Datatask callback, an endpoint URL for data and a notify URL for statusjob completion onlynone publishednone published$1.50
Apifyrun events on the platformACTOR.RUN.SUCCEEDED, FAILED, ABORTED, TIMED_OUT, CREATED, RESURRECTEDnone publishednone published$1
Profoundnone publishednonenonenonenot published, Enterprise on quote
Peec AInone publishednonenonenonenot published
Scrunchnot generally availablenonenonenonenot published, Agency Core from $500 a month
AthenaHQnone publishednonenonenone$81.94
OtterlyAInone publishednonenonenone$15.75, Standard plan at $189 a month

Delivery methods, event lists, signature headers and retry policies from each vendor's API reference, read on November 19, 2026; prices and the count of 15 webhook-capable APIs from our price survey of the 55 APIs this site rates, checked on October 23, 2026. For API for GEO, ChatGPT, Perplexity, Google AI Mode, Claude, Copilot and Grok are listed on apiforgeo.com, while Gemini, Google AI Overviews, DeepSeek and Meta AI were confirmed in our hands-on test of October 26, 2026, along with its webhooks, its OpenAPI spec and its official SDKs, whose languages are not published. Its rate per answer is roughly eleven times DataForSEO's, which is the price of getting visibility, share of voice, position and sentiment back already computed instead of writing them yourself.

Three readings come out of that table for a brand team choosing a route.

  • An event subscription saves you the comparison, and hands you its definition. Trakkr's visibility_changed fires on Trakkr's idea of a change, over Trakkr's window. That is a feature when nobody on the team wants to own a threshold, and a problem when a client asks what the trigger was.
  • A task callback saves you the poll loop, and stops there. With cloro, DataForSEO, Bright Data or Apify, the webhook tells you the answers landed; the drop is still yours to detect in the next step of the pipeline.
  • No webhook means a scheduled read, sized against the rate limit. Profound documents 600 requests an hour per key, so a 15-minute poll over one report spends 96 requests a day before you add a second brand. API for GEO publishes 300 requests a minute and 10 concurrent executions on its pay-as-you-go plan, and states that reads over stored runs are not billed, which makes a twice-daily comparison job free beyond the collection.

Our ranking of AI visibility APIs for enterprise brand teams weights engine coverage and ready-to-present metrics above the rate card, which is the right order for this job: an alert is only as wide as the engines behind it.

How to receive a webhook without trusting it

A URL that accepts any POST that knows the address opens a write path into your reporting. Every vendor above that signs its deliveries publishes the algorithm, and the verification is a dozen lines.

The Standard Webhooks specification, which Anthropic and Twilio support, is worth reading once even if your vendor uses its own header names, because it names the three jobs a receiver has to do. It requires webhook-id, webhook-timestamp and webhook-signature, signs the concatenation msg_id.timestamp.payload with HMAC-SHA256 for symmetric keys, tells you to "verify the webhook-timestamp header has a timestamp that is within some allowable tolerance of the current timestamp to prevent replay attacks", and tells you to "use the webhook-id header as an idempotency key to prevent accidentally processing the same webhook more than once". For zero-downtime secret rotation it sends several signatures in one header, space-delimited.

A receiver that satisfies all three, written against Trakkr's header because it publishes the fullest contract:

import crypto from "node:crypto";
import express from "express";

const app = express();

app.post("/geo-alerts", express.raw({ type: "*/*" }), async (req, res) => {
  // 1. Verify over the raw bytes. A parsed-then-restringified body
  //    changes key order and whitespace, and the HMAC stops matching.
  const sent = Buffer.from(req.get("X-Trakkr-Signature") ?? "");
  const want = Buffer.from(
    "sha256=" +
      crypto
        .createHmac("sha256", process.env.WEBHOOK_SECRET)
        .update(req.body)
        .digest("hex")
  );
  if (sent.length !== want.length || !crypto.timingSafeEqual(sent, want)) {
    return res.status(401).end();
  }

  const payload = JSON.parse(req.body.toString("utf8"));

  // 2. Deduplicate. Trakkr retries at 1s, 2s and 4s on a 5xx or a timeout,
  //    so a slow handler will see the same event three times.
  const eventId = payload.meta?.event_id;
  if (!eventId || (await alreadyProcessed(eventId))) return res.status(200).end();
  await markProcessed(eventId);

  // 3. Acknowledge inside the delivery timeout, then do the work elsewhere.
  res.status(200).end();
  await queue.push(payload);
});

Four details decide whether that handler survives a month in production.

  • Verify before parsing. Keep the raw body. express.json() gives you an object, and re-serialising it produces different bytes from the ones that were signed.
  • Compare in constant time. crypto.timingSafeEqual throws on mismatched lengths, which is why the length check comes first.
  • Store the event ID. Trakkr names meta.event_id, LLM Pulse sends X-LLMPulse-Delivery, cloro sends X-Cloro-Webhook-Id. A set in memory survives one deploy; a table or a Redis key with a few days of TTL survives the quarter.
  • Return 2xx fast. cloro states that anything other than a 2xx, including TLS errors and timeouts, "counts as a failed delivery and triggers a retry", with results kept for 24 hours. LLM Pulse disables a subscription after 20 consecutive failures, so a handler that crashes on a Friday can leave you unsubscribed by Monday with no alert at all.

Two vendors also publish a test delivery, which is the fastest way to confirm the secret and the parser before you wait for a real event: Trakkr's POST /webhooks/{webhook_id}/test returns the status_code and response_time_ms of the attempt, and LLM Pulse's GET /webhooks/sample/{event_type} returns up to three sample payloads per event type.

The scheduled job, for the 40 APIs with no webhook

With no event subscription, the alert becomes a small job that reads the series, compares two windows and posts a message only when the comparison clears the threshold. Published behaviour of the schedulers themselves shapes the design.

GitHub Actions states that "the shortest interval you can run scheduled workflows is once every 5 minutes", that the schedule event "can be delayed during periods of high loads of GitHub Actions workflow runs" with the start of every hour named as a high load time, that scheduled workflows in a public repository are "automatically disabled when no repository activity has occurred in 60 days", and that a timezone can now be set with an IANA string. Vercel Schedules is more explicit about the failure modes than most: runs start inside a jitter window of 1 to 15 minutes, every occurrence has an expiry after which it is skipped, a delayed schedule delivers every unexpired occurrence at once when delivery resumes, and a failed run is not retried at all unless the target is a queue topic. Its warning applies to any scheduler: "Vercel delivers each run once in normal operation, but it can't rule out a duplicate delivery. Make your handler safe to run more than once."

A twice-weekly alert job on GitHub Actions is short enough to read in full:

name: geo-alert
on:
  schedule:
    - cron: "17 6 * * 1,4"   # Monday and Thursday, 06:17 UTC, off the hour
  workflow_dispatch:          # so you can prove it works without waiting

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - run: python scripts/collect.py        # one job per engine, idempotent key
        env:
          GEO_API_KEY: ${{ secrets.GEO_API_KEY }}
      - run: python scripts/compare.py        # writes alerts.json, exits 0 either way
      - run: python scripts/notify.py         # posts only if alerts.json is non-empty
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
      - run: python scripts/heartbeat.py      # always runs, even when nothing fired

The comparison itself is one query over the table the collector fills. Two 14-day windows, per engine, with the minimum window size in the having clause so a thin engine never produces an alert:

with w as (
  select
    a.engine,
    case when a.run_date > current_date - interval '14 days'
         then 'now' else 'before' end            as bucket,
    a.answer_id,
    (m.answer_id is not null)::int               as named
  from answers a
  left join mentions m
    on m.answer_id = a.answer_id and m.entity = 'acme'
  where a.run_date > current_date - interval '28 days'
    and a.locale   = 'US-en'
)
select
  engine,
  count(*)         filter (where bucket = 'before')       as n_before,
  count(*)         filter (where bucket = 'now')          as n_now,
  100.0 * avg(named) filter (where bucket = 'before')     as rate_before,
  100.0 * avg(named) filter (where bucket = 'now')        as rate_now
from w
group by engine
having count(*) filter (where bucket = 'before') >= 300
   and count(*) filter (where bucket = 'now')    >= 300;

The job then applies the threshold from the next section to each row and writes the ones that clear it. Our guide to building a GEO report with an API and Claude Code covers the collection script in the first step, and running one prompt on multiple AI engines covers the fan-out across engines that fills the window.

Setting a threshold that fires on a real drop

This is the part no vendor can do for you, and it is arithmetic rather than judgement. A visibility rate is a proportion over the answers in the window, so its standard error is the square root of p(1 - p) / n. Comparing two windows doubles the variance, so the gap you can defend at 95% confidence is 1.96 × √(2p(1 - p) / n).

At a 30% visibility rate, which is a normal figure for a tracked brand in its own category, that works out as follows.

Answers in each windowNoise band on one window, two sigmaSmallest window-on-window drop at 95% confidenceReading
1208.4 points11.6 pointsnot alertable
2405.9 points8.2 pointsdirection only
4804.2 points5.8 pointsusable with a 6-point trigger
9603.0 points4.1 pointsusable with a 4-point trigger
1,9202.1 points2.9 pointsusable with a 3-point trigger

Our arithmetic on the standard error of a proportion at p = 0.30, two-sided, with the window-on-window column using the pooled two-sample form. The bands widen as p approaches 50% and narrow below 20%: at 480 answers the 95% figure is 4.9 points at a 20% rate and 6.1 points at a 50% rate.

Two published studies agree on where the floor sits. cloro's sample-size study puts roughly 72 answers at about plus or minus 10 points and about 300 answers at about plus or minus 5 points, says you need "about 294 answers in each period" to claim a move from 20% to 30%, and concludes of its own 180-prompt daily programme that "at that volume a week-over-week comparison is statistically sound, and a day-over-day one still is not: one day is 50 answers per engine, about ±12 points". Its paired-run test of November 15, 2026 found about a third of the first answer's cited sites came back on the second run, 32% on average, with none at all in 7 of the 18 pairs.

Then there is the frequency of the check itself, which is the trap specific to alerting rather than reporting. A drop-only trigger set at two sigma fires on chance alone about 2.3% of the time. Checked weekly on one blended figure, that is about one false alarm a year; checked weekly on four engines separately, it is closer to five. Raising the same four checks to three sigma brings the expectation under one false alarm every three years, at the price of missing a genuine 3-point slide.

Three rules we would write into the job:

  • Alert per engine, on a window of at least 480 answers. One blended number hides the engine where the brand went missing, and a thin engine produces nothing but false alarms.
  • Require two consecutive windows, or three sigma, for anything that pages a human. One of the two. Both together is a rule that never fires.
  • Carry the denominator in the message. "31.2% to 24.6% over 960 answers each side, trigger 4.1 points" survives a question. "Visibility down 6.6%" does not, and it is also ambiguous between points and percent.

What to alert on, and what belongs on the dashboard

Most of what a GEO platform can show should never page anyone. Five signals earn an alert, and the fifth is the one teams skip.

SignalTrigger worth firingWindowWho should see it
Visibility drop, per enginebelow the previous window by more than the 95% band for that window sizerolling 14 days, at least 480 answersbrand team channel
Own page loses its citationsa page that was cited in 20% or more of answers for a prompt group falls out entirelyrolling 14 dayscontent owner
Sentiment turns negativethe negative share of mentions clears its own band, or a vendor event such as LLM Pulse's sentiment.negative_detected fires repeatedly on one prompt grouprolling 14 days, plus every single event read by a humancommunications, same day
A competitor overtakes youshare of voice crosses, on a fixed roster, for two consecutive windowsrolling 28 daysbrand team, weekly digest
Collection healthanswers stored below answers expected for any engine, or no run at all in one cadenceevery runwhoever owns the job, immediately

Our own alerting rules, with the vendor event name from LLM Pulse's webhook reference, read on November 19, 2026. The window sizes come from the threshold table above.

The asymmetry in that table is deliberate. Rates need windows, and individual events do not. A single answer that names your brand in a damaging sentence is worth a human reading it the same day, which is the case for subscribing to a per-mention event where a vendor publishes one. A visibility number computed on a single day is worth nothing, which is why the same subscription should not be allowed to move a chart. Our guide to measuring brand sentiment in AI answers covers the scoring behind row three, and tracking AI citations of your pages covers the URL normalisation that keeps row two from firing on a trailing slash.

Everything else belongs on a weekly digest or a dashboard: position changes inside the band, new prompts entering the set, fan-out questions, the long tail of cited domains. An alert that arrives more than about twice a month stops being read, and from that point the channel is decoration.

Where the alert should land

Two routes cover almost every brand team, and both have published constraints worth knowing before you build.

Slack incoming webhooks are a POST of JSON to a URL of the form https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXX, with text for the message and blocks for layout. The constraint is that the destination is fixed: Slack states you "cannot override the default channel (chosen by the user who installed your app), username, or icon when you're using incoming webhooks to post messages". One URL per channel, so a per-client or per-brand routing plan means one secret per destination.

curl -X POST -H 'Content-type: application/json' \
  --data '{"text":"ChatGPT US-en: visibility 31.2% to 24.6% over the last 14 days (960 answers each side, trigger 4.1 points). Two of eight cited pages dropped out."}' \
  "$SLACK_WEBHOOK_URL"

On Microsoft Teams, the old route is gone. Microsoft's retirement notice states that Office 365 connectors, the mechanism behind connector-based incoming webhooks, stopped functioning in a rollout completed on May 22, 2026, and that "all connector-based webhooks must be migrated to Power Automate-based workflows before the rollout begins". A Teams alert built on an old connector URL is silently dead, which is worth checking if an existing GEO alert went quiet this year.

Three routing rules keep the channel readable:

  • One destination per audience. Collection health goes to the team that owns the job; visibility goes to the brand channel. Mixing them trains everyone to ignore both.
  • A cooldown per signal and per engine. Once an alert fires for ChatGPT, suppress the same signal for one full window. Without it, a real drop produces an alert on every run until it recovers.
  • A link to the evidence beside the number. The prompt group, the engine, the two windows and the answers behind them. If the recipient cannot see which prompts moved, the first question comes back to you anyway.

What alerting twice a week costs

The alert is free. The collection that makes it possible is the whole bill, and alerting pushes the cadence up, which is the only reason it costs anything at all. The workload below is one brand team: 120 prompts, four engines, one country, English.

CadenceAnswers a monthAnswers per engine in a 14-day windowCost at $0.013 an answer
once a month480120$6.24
once a week2,080480$27.04
twice a week4,160960$54.08
once a day14,4003,360$187.20

Our arithmetic on API for GEO's published rate of $0.013 per credit at its first tier, checked on October 23, 2026, counting 52 weeks across 12 months for weekly cadences and 30 days for daily ones. One credit is one prompt, on one model, in one locale.

Read that table against the threshold table and the choice makes itself. Monthly collection gives each engine 120 answers in a window, which cannot support an alert at all. Weekly collection gives 480 and a usable 6-point trigger. Twice weekly gives 960 and a 4-point trigger for twice the money, which is the cadence we would pick for a brand with real competitive pressure. Daily collection costs three and a half times as much as twice weekly and buys a 3-point trigger, and the marginal point is rarely worth $133 a month.

The same 4,160 answers on the other routes, for comparison:

RouteMonthly bill for 4,160 answersWhat you still have to write
API for GEO$54.08 at $0.013, metrics and sources computedthe threshold and the message
DataForSEOabout $4.99 on the standard queue, after a $50 minimum paymentalias matching, position, share of voice, sentiment, plus the threshold
cloro$30, the Lite plan floor, using about 18,720 of its 37,500 monthly creditsthe same metrics layer, plus the threshold
Trakkr$500, the plan its documentation requires for API accessnothing but the receiver; the events are computed for you
Scheduler and delivery$0 on GitHub Actions, inside the $12 of compute included on the Free plan, and $0 for a Slack incoming webhookthe heartbeat

Rates from each vendor's pricing page, checked on October 23, 2026; GitHub's included compute allowance from its Actions billing documentation. The DataForSEO figure covers the engines it collects, not all four legs of this workload.

One line in that table is the real decision. Trakkr at $500 a month hands you visibility_changed as a signed event and you write a receiver; API for GEO at $54.08 hands you the computed metrics and you write the threshold once; DataForSEO at $4.99 hands you answers and you write the whole metrics layer, as our duel API for GEO against DataForSEO sets out field by field. For a single brand team, in our view the threshold is a half-day of work and the metrics layer is a quarter-long project, which is why the middle row is where we would start.

Mistakes that make an alert worse than no alert

  • Alerting on one run. With 56.7% of brands appearing in just one of five runs of the same question in our October 2026 analysis, and Detailed measuring an identical list of cited domains on two random days less than 3% of the time, a single-run trigger measures the engine's own variance.
  • A threshold in percent of the previous value. "Down 20%" means one thing at a 5% visibility rate and another at 50%. Set it in percentage points, against the band for the window size.
  • No signature verification. An unsigned endpoint accepts any POST that knows the URL, and the URL ends up in a CI log sooner or later.
  • No deduplication. Trakkr retries three times, cloro five, LLM Pulse five. A slow handler turns one drop into three pages at 03:00.
  • No heartbeat. A silent job and a healthy market look identical from the receiving end.
  • Relying on an undocumented webhook. API for GEO's webhooks were confirmed in our own test and are not on its site; Scrunch's are not generally available. Ask for the event list, the signature header and the retry policy in writing during the trial, and build the scheduled-job fallback regardless.
  • Letting an alert channel double as a dashboard. Position shifts inside the noise band, new fan-out questions and the tail of cited domains belong in a weekly digest. Anything that fires weekly gets muted within a month.

Our view

Three setups we would defend for a brand team, depending on who maintains the job:

  1. Metrics bought, threshold owned. API for GEO, our editorial pick, at $54.08 a month for 120 prompts on four engines twice a week, $13 per 1,000 answers down to $7 at its largest tier, pay as you go with no published minimum, reads over stored runs not billed, 300 requests a minute, resale allowed, and 9.0 out of 10, the best score in our ranking of 55 APIs. It returns visibility, share of voice, average position, sentiment, categorised sources, themes, per-brand perception, fan-out questions, shopping products and YouTube citations in one response, and covers the ten engines we track: ChatGPT, Perplexity, Google AI Mode, Claude, Copilot and Grok are listed on apiforgeo.com, while Gemini, Google AI Overviews, DeepSeek and Meta AI were confirmed in our hands-on test of October 26, 2026. Said plainly, the limits for this particular job are real: its rate per answer is about eleven times DataForSEO's, its webhooks, OpenAPI spec and official SDKs come from that same test rather than from its documentation, so the event list and the signature header are unknown until you ask, and the key arrives through a form. To price it against your own prompt list, request a key on apiforgeo.com: it comes with a sandbox project.
  2. Events bought outright. Trakkr at the $500 plan its documentation requires for API access, for the only published 30-event subscription in this market, HMAC-SHA256 signatures, a documented retry schedule and a test-delivery endpoint, across the eight engines it covers. Our score: 6.8 out of 10. You inherit its definition of a change, which is the trade.
  3. Alerts on the cheapest possible collection. DataForSEO at $1.20 per 1,000 answers on the standard queue, with postback_url delivering gzip-compressed results, SDKs in four languages and up to 100 tasks per POST call, for a team that already has a data engineer. Our score: 7.7 out of 10, with engine coverage as the limit at five of the ten we track, and the entire metrics and threshold layer written in house. LLM Pulse is the other defensible pick here, at €30.67 per 1,000 answers with 11 signed event types on its Scale plan and above, SDKs in twelve languages and the widest engine list in our survey; our score: 8.8 out of 10.

The figure that decides the whole exercise is not on any pricing page. It is how many answers a week your cadence puts in each engine's window, because that number sets the smallest drop you can honestly call a drop. Pick the trigger from the window, then pick the cadence from the trigger, and the vendor choice becomes the easy part.

Frequently asked questions

How do I get an alert when my brand's AI visibility drops?

Compare a rolling window against the window before it, and fire only when the gap clears the sampling noise. For a 120-prompt list on four engines collected twice a week, each engine holds about 960 answers in a 14-day window, where a drop has to reach roughly 4.1 percentage points before it can be told apart from chance at 95% confidence. Subscribe to the vendor's webhook if one exists, so the event arrives on collection you already paid for; otherwise run the comparison in a scheduled job and post the result to a Slack incoming webhook.

Which AI visibility APIs support webhooks?

Fifteen of the 55 this site rates, checked on October 23, 2026. Trakkr publishes the widest event list, 30 of them including `visibility_changed`, `rank_changed`, `citation_lost` and `audit_score_dropped`, signed with HMAC-SHA256 in an `X-Trakkr-Signature` header and retried three times at 1, 2 and 4 seconds. LLM Pulse publishes 11 event types on its Scale plan and above, retries up to five times and auto-disables a subscription after 20 consecutive failures. cloro, DataForSEO, Bright Data and Apify deliver task completion rather than metric events, while Profound, Peec AI, AthenaHQ and OtterlyAI publish no webhook at all.

Can you get real-time AI visibility data?

Delivery can be near real time, but the measurement cannot. A webhook fires within seconds of a run finishing, and cloro and Trakkr both publish retry schedules in seconds or minutes, so the transport is not the constraint. The figure is a rate over many answers: Detailed's four-week study of over 70,000 responses found only about a quarter of the pages ChatGPT cited for a prompt were cited again the next day, and cloro's sample-size study puts one day of its own 180-prompt programme at about plus or minus 12 points per engine. Treat a single fresh answer as an event to read, and a rate as something you only publish on a window of 300 answers or more.

How do I verify that an AI visibility webhook is genuine?

Recompute the HMAC over the raw request bytes with your signing secret and compare it in constant time, then reject anything that does not match with a 401. Trakkr sends `X-Trakkr-Signature: sha256=...` and tells you to deduplicate on `meta.event_id`; LLM Pulse sends `X-LLMPulse-Event`, `X-LLMPulse-Delivery` and `X-LLMPulse-Signature` as `sha256=<hex>`; cloro sends `X-Cloro-Signature`, `X-Cloro-Timestamp` and `X-Cloro-Webhook-Id`. The Standard Webhooks specification, which Anthropic and Twilio support, formalises the same three headers as `webhook-id`, `webhook-timestamp` and `webhook-signature`, signs the string `msg_id.timestamp.payload`, and asks you to check the timestamp against a tolerance window to block replays.

How big does the drop have to be before the alert fires?

Big enough to beat the noise in the window you are watching. At a 30% visibility rate, the two-sigma band on a single window is 8.4 percentage points at 120 answers, 4.2 points at 480 answers and 3.0 points at 960 answers, and a window-on-window comparison needs about 11.6, 5.8 and 4.1 points respectively to reach 95% confidence. A drop-only trigger at two sigma fires on chance alone about 2.3% of the time, which is close to five false alarms a year once four engines are checked weekly, so widen the window, raise the rule to three sigma, or require two consecutive windows before anyone is paged.

What does it cost to run AI visibility alerts twice a week?

The alert itself costs nothing; the collection behind it does. A 120-prompt list on four engines collected twice a week is 4,160 answers a month, which is $54.08 at API for GEO's $0.013 a credit, about $4.99 of DataForSEO usage on its standard queue for the engines it covers, or $30 on cloro's Lite plan where the workload uses about 18,720 of its 37,500 monthly credits. Reading the same runs back to compute the comparison is not metered on API for GEO, and GitHub Actions carries the schedule inside the $12 of compute included on its Free plan. Prices checked on October 23, 2026.