Skip to content

Integration

Five ways to use an AI visibility API, from MCP to alerts

MCP to explore, a skill to repeat, a cron job for the series, a warehouse for dashboards, webhooks for alerts: five patterns and what each one bills.

Five simple geometric shapes connect via angled lines into a glowing blue cube entrance

SEO consultant, and more recently GEO, at MentionBox

An AI visibility API is reached five ways in practice: an MCP server for a question you ask once, a Claude skill for a task you repeat, a scheduled job for the series you report on, a warehouse behind a BI tool for dashboards, and webhooks for alerts. The choice between them turns on billing before anything else, because only the patterns that run a prompt against an engine are metered. API for GEO, our editorial pick after hands-on testing by Mathias C., states on its AI Visibility API page that "the AI Visibility API does not bill reads. Credits are consumed by executions, when a prompt runs against a model", at $0.013 a credit, which is $13 per 1,000 answers collected and down to $7 at its largest tier.

This guide is written for a developer or a small team wiring one of these APIs into an existing stack, and it names the published endpoint, command or field behind each pattern, in the order you will reach for them, with the cost and the failure mode of each. Prices and tooling come from each vendor's own pricing page and API reference, checked on October 23, 2026. MentionBox, which publishes this site, has a commercial link with API for GEO.

The five patterns side by side

PatternGood forWhat it billsWhat breaks it first
MCP serverone-off questions, exploring a new API, ad hoc checks during a meetingnothing for reads; one credit or one task if the tool runs a promptthe model picks the tool, so two sessions give two different numbers
Claude skilla task you repeat the same way, with the API's conventions written down oncethe API calls the skill makesno network access in the Claude API sandbox
Scheduled jobthe time series your report is built onevery run, every prompt, every enginea schedule that drifts, or a prompt list edited mid-quarter
Dashboarda figure several people read without asking youthe collection, plus warehouse queries per chart viewper-minute and per-month request limits
Webhook alerta change nobody is watching fornothing beyond the collection that produced the eventone run treated as a measurement

Each row from the vendor documentation and the protocol specifications linked in the matching section, read between October 23 and November 7, 2026.

One of the five produces the data and the rest read it. The scheduled job is the pattern that calls an engine, joined only by an MCP tool or a skill that triggers a fresh run, so it carries the whole bill, while the dashboard, the alert and most agent sessions consume what the collection already paid for. The per-answer rate is therefore the number to compare between vendors, and the monthly read quota is the one that trips an integration up.

What tooling each API actually publishes

APIMCP serverOfficial SDKsWebhooksBatch and exportRate limitPrice per 1,000 answers
API for GEOyes, on both plansconfirmed in our hands-on test of October 26, 2026, languages not publishedconfirmed in the same test, not documented on apiforgeo.combulk prompt import, job execution over a model list300 requests a minute, 10 concurrent executions$13, down to $7 at the largest tier
DataForSEOmcp.dataforseo.com/v3/mcp, open sourcePython, C#, TypeScript, Javapostback_url and pingback_urlup to 100 tasks per POST callup to 10,000 calls a minute$1.20 on the standard queue
Profoundmcp.tryprofound.com/mcp, Enterprise planPython, JavaScript/TypeScriptnot publishednot published; /stream variants in SSE600 requests an hour per keynot published, Enterprise on quote
Trakkrapi.trakkr.ai/mcp, 82 tools, paid plannone published, OpenAPI 3.1 contract insteadyes, HMAC-SHA256 signedbulk prompt create, /export up to 10,000 rows60 requests a minute on most readsnot published, API on the $500 plan
Peec AIapi.peec.ai/mcp, OAuth or access tokennone publishednot publishedup to 1,000 items per write request200 requests a minute per projectnot published
OtterlyAIdata.otterly.ai/mcp, OAuthnone published, official Claude Skill insteadnot publishedprompt creation in bulk2,000 API requests a month on Standard$15.75, Standard plan at $189 a month
cloromcp.cloro.dev/mcp, seven scrape toolsPython, TypeScriptyes, optional HMAC-SHA256up to 500 tasks per batch request1,000 requests a second per endpoint$4, Lite plan at $30 a month
LLM Pulseapi.llmpulse.ai/api/v1/mcp, OAuth 2.112 languages, plus a CLIyes, HMAC signed, Scale plan and above500 prompts per import, CSV output300 requests a minute per token€30.67
Scrunchyes, on any Scrunch plannone published, Agent Skills insteadnot generally available1,000 records per requestnot publishednot published, Agency Core from $500 a month

Endpoints, SDK lists, delivery methods, rate limits and rates from each vendor's documentation and pricing page, checked on October 23, 2026. For API for GEO, six engines are listed on apiforgeo.com; four of the ten we track, 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. Its price per answer is roughly ten times DataForSEO's, which is the honest cost of getting share of voice, position and sentiment back already computed.

Read that table as five separate shopping lists rather than one ranking. An MCP server is now almost universal, published by 48 of the 55 APIs this site rates; a signed webhook is rare, and an SDK in Kotlin exists in exactly one of them. Our ranking of AI visibility APIs for developers weights these same columns, self-serve access, a published price per answer and the tooling around the API.

1. The MCP server, for questions you ask once

The Model Context Protocol puts a vendor's data behind tools an assistant can call mid-conversation. Its architecture overview describes a host application that creates one client per server, three server primitives (tools for actions, resources for context data, prompts for templates), and two transports: stdio "for direct process communication between local processes on the same machine" and Streamable HTTP, which "uses HTTP POST for client-to-server messages with optional Server-Sent Events". Discovery and execution are two JSON-RPC methods, tools/list and tools/call.

In Claude Code, connecting one is a single command, documented on the MCP page:

claude mcp add --transport http geo https://api.example.com/mcp \
  --header "Authorization: Bearer $GEO_API_KEY" \
  --scope project

Four details from that page save time later. Project scope writes the entry to .mcp.json at the repository root, which you commit so the team gets the same tools. ${VAR} and ${VAR:-default} expand at connection time, keeping the key in the environment rather than in the file. Tools arrive named mcp__geo__<tool-name>, which is the string permission rules and a skill's allowed-tools expect. For a short-lived credential, headersHelper runs a script on each connection, with ten seconds to print a JSON object of headers.

The pattern earns its keep in the first hour with an API you have never used, before you know which fields exist. API for GEO describes the shape on its home page, "the same ten families exposed as tools, so Claude or Cursor can query your GEO data directly", while its connection URL and tool list were not published when we checked. DataForSEO's server is the one you can inspect before trusting it, since its TypeScript implementation is on GitHub and the remote endpoint takes Basic auth from the same credentials as the REST API.

Where the pattern fails is reproducibility. The model chooses the tool and the arguments, so the same question asked twice can read two different windows, and nothing in the transcript tells a client why last week's figure moved. Rate limits bite here too, because an exploratory session spends the same quota as a job: 60 requests a minute on most of Trakkr's reads, 600 an hour per key on Profound, 2,000 a month in total on OtterlyAI's Standard plan.

2. A Claude skill, for the task you repeat

A skill suits work with a correct procedure you keep re-explaining: which endpoint to call, which brand list counts, how to normalise a URL before counting it. Anthropic's Agent Skills documentation defines one as a directory holding a SKILL.md file whose YAML frontmatter requires name and description, where the description "is what Claude matches your request against when determining whether to trigger the Skill, so it must say both what the Skill does and when to use it".

Loading happens in levels, which is what makes a skill cheap to keep installed. Metadata costs around 100 tokens per skill and sits in context permanently, the body loads only when the skill triggers and targets under 5,000 tokens, and bundled files cost nothing until read. Scripts are the sharpest tool in the set, since "the script's code never loads into the context window" and only its output consumes tokens. A collection script that pages through 20 result pages belongs in scripts/, where the model never has to read it.

In Claude Code, skills live in ~/.claude/skills/<name>/SKILL.md for personal use or .claude/skills/<name>/SKILL.md in the repository, and the frontmatter carries extra fields worth knowing: allowed-tools pre-approves tools for the current turn only, disable-model-invocation keeps a skill out of automatic triggering so you call it with /name, and the combined description and when_to_use text is truncated at 1,536 characters in the listing. A short skill for a weekly read looks like this:

---
name: geo-weekly-read
description: Read last week's AI visibility figures for a brand from the GEO API and write the three-line summary. Use when asked for a weekly AI visibility update or share of voice change.
allowed-tools: Bash(scripts/pull_week.sh *) Read
---

# Weekly GEO read

1. Run `scripts/pull_week.sh <brand> <iso-week>`; it writes `out/<brand>-<week>.json`.
2. Read the file. Report visibility, share of voice and average position per engine.
3. Compare with the previous file in `out/`. Report the delta only if both weeks hold
   at least 300 answers; below that, say the sample is too small.
4. Never recompute a figure from the answer text. The script owns the arithmetic.

Two vendors ship this pattern themselves. OtterlyAI's Claude Skill is distributed as an otterly.skill file, installed through Claude's Skills panel or with claude skill add /path/to/otterly.skill, and covers workspaces, brand reports, KPIs, citations, prompts, recommendations and GEO audits; it asks you to allow data.otterly.ai in the domain allowlist and to supply an OTTERLY_API_KEY, and notes that read-only keys cover reports and citations while GEO audits need a read/write key. Scrunch's Agent Skills install with npx skills add https://developers.scrunch.com in two families: scrunch-* skills that go through its MCP server with no API key, and api-* skills that read a SCRUNCH_API_TOKEN, among them api-query-metrics, api-responses-export and api-signals-monitoring. DataForSEO publishes a Claude Code template instead, its Detailed AI Visibility Report, last updated August 31, 2026.

The constraint that catches teams out is the runtime. Skills on the Claude API run "in a sandboxed container with no network access and no runtime package installation", so a skill whose whole job is calling a vendor endpoint does nothing there. In Claude Code the same skill works, because skills get "the same network access as any other program on the user's computer", and on claude.ai network access depends on account settings. Anthropic's security section is worth reading before you install a third-party skill: a malicious one "can direct Claude to call tools or run code in ways that don't match the Skill's stated purpose".

3. The scheduled job, which produces the series

Everything a client sees comes from this pattern, and the other four read what it collected. Our guide to building a GEO report with an API and Claude Code walks the four stages of the script itself; what follows is the scheduling layer around it.

Prefer the vendor's async queue to a long-running request. DataForSEO's LLM Scraper task endpoint takes up to 100 tasks per POST call, returns error 40006 above that, accepts a tag of up to 255 characters for matching results back to your rows, and takes priority 1 for normal execution or 2 for high priority at extra cost. API for GEO documents both modes, a synchronous POST /v1/prompts/run that answers with the enriched result, and a POST /v1/jobs/execute that "returns a job to poll", with bulk prompt import and an executionsPerQuery setting on the job. Its published limits, 300 requests a minute and 10 concurrent executions, decide how wide you can fan a nightly job out.

Three scheduling rules come straight from published behaviour:

  • Keep the slot stable. Same day, same hour, same country, same language. A series that moves because collection shifted from Monday to Friday is unreadable.
  • Expect the runner to drift. GitHub's documentation states that the shortest interval for a scheduled workflow is once every five 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, and that scheduled workflows in a public repository are "automatically disabled when no repository activity has occurred in 60 days". Schedule at 17 past the hour, and alert yourself on a missing run.
  • Make the job idempotent. Key each stored answer on prompt, engine, locale and run date, so a retried job overwrites rather than double-counts.

The arithmetic for a mid-size job, 50 prompts on four engines, four runs a month, one country, is 800 collected answers:

RouteMonthly bill for 800 answers
API for GEO$10.40 at $0.013 a credit, metrics and sources included
DataForSEO LLM Scraper, standard queueabout $0.48 for the two engines it scrapes from the interface, after a $50 minimum payment
cloro, Lite plan$30, the plan floor, well under its 37,500 monthly credits
OtterlyAI, Standard plan$189, the first plan with API access, capped at 2,000 requests a month

Our arithmetic on the rates each vendor published, checked on October 23, 2026: 50 prompts × 4 engines × 4 runs = 800 answers.

4. The dashboard, which should not call the API per chart

A dashboard is a read pattern with a multiplication problem. Point a BI tool straight at a vendor endpoint and every viewer who opens the report issues requests, against a quota sized for your jobs. Google's BigQuery connector documentation spells out the same mechanic one layer down: with viewer's credentials, "every report viewer must have required roles and incurs costs", and charts query live.

The shape that survives contact with a reporting team has two steps. The scheduled job lands answers and computed figures in a table you own, one row per prompt, engine, locale and run date, and the BI tool reads that table rather than the API. Query costs then sit with you, the figure holds still while someone presents it, and the history outlives the vendor's retention window, which on API for GEO's pay-as-you-go plan is 24 months.

Exports and connectors shorten the first step when they exist:

  • Writesonic publishes a native Looker Studio connector, announced April 2, 2026 as "Writesonic GEO Presence", with ten data sources covering website performance, prompt performance, individual AI responses, citations and keyword metrics, authorised with a Google account plus a Business API key and the site URL.
  • Trakkr exposes GET /export returning up to 10,000 rows as JSON or CSV, which is a scheduled file drop rather than a live connection.
  • LLM Pulse returns CSV as well as JSON on its table endpoints and publishes an OpenAPI 3.0 spec at api.llmpulse.ai/openapi.json, so a generated client fills a warehouse table.
  • Profound paginates by cursor and offers /stream variants of its v2 reports over Server-Sent Events, with Python and TypeScript SDKs for the nightly extract.

One clause decides whether the dashboard can leave your building. A client-facing or paid dashboard is a resale question, and the terms differ: API for GEO publishes resale and white label as an intended use while forbidding you to sublicense direct API access, Profound's master subscription agreement forbids distributing, selling or sublicensing the services, and DataForSEO publishes no explicit resale clause at all. Our ranking of AI visibility APIs for agencies keeps only the APIs whose published terms allow it, and our guide on tracking ten clients without seat fees covers the per-client arithmetic.

5. Webhook alerts, which beat a poll loop

An alert is worth building once the series exists, and it is the cheapest of the five patterns because the event rides on collection you already paid for.

Trakkr's webhook endpoint is the most explicit published example. You register with POST /webhooks, choose from events including visibility_changed, rank_changed, citation_gained, page_cited, perception_changed and report_completed, and verify an X-Trakkr-Signature: sha256= header computed with HMAC-SHA256. Delivery is retried three times with delays of 1, 2 and 4 seconds on 5xx errors and timeouts, 4xx responses other than 429 are not retried, and the documentation tells you to "use the meta.event_id field for idempotency" and store processed IDs. Each payload carries event.type, event.triggered_at, an event.data object that varies by type, and the brand it concerns.

Three other routes are published:

  • cloro takes a webhook.url on an async task, signs with an optional X-Cloro-Signature using HMAC-SHA256, makes five attempts and keeps results for 24 hours, so a handler that is down for a day loses the payload but not the run.
  • DataForSEO gives two task-level hooks instead of event subscriptions: postback_url, which receives the finished result as a gzip-compressed POST and needs a postback_data value of advanced or html, and pingback_url, a GET notification whose connection "will be aborted by timeout" past 10 seconds. Both substitute $id and $tag.
  • LLM Pulse publishes HMAC-signed webhooks for new mentions, new citations, completed executions, negative sentiment and finished reports, on its Scale plan and above.

Where no webhook is published, an alert becomes a poll loop against a rate limit. Profound's REST introduction documents 600 requests an hour per key with X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset headers and a Retry-After on 429, so a 15-minute poll over one report spends 96 requests a day and scales badly across brands. API for GEO's webhooks were confirmed in our hands-on test of October 26, 2026 and are not documented on apiforgeo.com, so size a poll loop against its published 300 requests a minute until they are.

The threshold is the hard part, and it is a statistics question rather than an engineering one. cloro's published study on sample size, dated August 14, 2026, measured a mean overlap of 0.40 between the cited domains of two runs of the same prompt on the same model minutes apart, and puts about 300 answers in a period at roughly ±5 percentage points. Compare a rolling window of at least 300 answers against the previous one, and set the trigger outside that ±5 point band, or the alert will fire every week.

Which pattern for which job

Most teams end up running three of the five. The scheduled job collects, the dashboard reads the table it fills, and an MCP server answers the questions that arrive between reports. A skill comes next, once a procedure is worth freezing in SKILL.md instead of re-explaining, and an alert comes last, once the series is long enough for a threshold to mean something. The first table in this guide is the one to re-read when choosing, because the deciding column is what each pattern bills rather than what it can show.

Mistakes we would avoid

  • Letting an agent collect the data. A conversation that triggers fresh runs produces numbers nobody can reproduce, on a bill nobody forecast. Keep execution in the scheduled job and give the agent read access.
  • Pointing a dashboard at the vendor API. Several platform APIs cap requests by the month, 2,000 on OtterlyAI's Standard plan among them, and a popular report eats that quota.
  • Skipping signature verification. A webhook endpoint without HMAC verification accepts anything that knows the URL. Trakkr and cloro both publish the header and the algorithm, and both deliveries need deduplication on the event ID.
  • Writing a skill that calls the network on the Claude API. It runs in a container with no network access. Put it in Claude Code, or let the skill read what a scheduled job already wrote.
  • Alerting on one run. With a mean overlap of 0.40 between two runs of the same prompt, a single-run trigger measures noise.
  • Counting on undocumented tooling. Vendors here publish an MCP server without a tool list, or an SDK without a repository. Ask for both during the trial.

Our view

The pattern to build first depends on who consumes the output:

  1. A developer exploring, on the cheapest data. DataForSEO at $1.20 per 1,000 answers on the standard queue, with an open-source MCP server, SDKs in four languages, up to 100 tasks per POST and postback_url delivery. Our score: 7.7 out of 10, with engine coverage as the limit: five of the ten we track, interface scraping on two.
  2. An alert-driven setup. Trakkr for its signed webhook events and its 82-tool MCP server, if the $500 plan its documentation requires for API access fits. Our score: 6.8 out of 10.
  3. An agent-first workflow on the vendor's own skill. OtterlyAI at $15.75 per 1,000 inside a $189 plan, with an official Claude Skill and an OAuth MCP server, as long as 2,000 requests a month covers jobs and agents together. Our score: 6.7 out of 10.
  4. All five patterns on one key, metrics already computed. API for GEO, our editorial pick, at $13 per 1,000 answers down to $7 at its largest tier, pay as you go with no published minimum, reads not billed, resale allowed, an MCP server on both plans, and 9.0 out of 10, the best score of the 55 APIs this site rates. Its price per answer is about ten times DataForSEO's, and four of its ten engines plus its webhooks, OpenAPI spec and official SDKs were confirmed in our test of October 26, 2026 rather than documented on apiforgeo.com.

In our view the question to settle before any integration is which figures you will want to recompute later. An API that bills reads pushes you toward storing everything yourself and querying it once, while an API that bills only executions lets the dashboard, the alert and the agent read the same stored runs.

Frequently asked questions

What is the difference between an AI visibility API and an MCP server?

The API is for code you write, where you choose the endpoint, the parameters and the schedule, and the same call returns the same shape next month. An MCP server exposes that data as tools an AI assistant can call while it answers you, and the model decides which tool to call and with what arguments. The Model Context Protocol specification defines `tools/list` for discovery and `tools/call` for execution over JSON-RPC 2.0, with a stdio transport for local servers and Streamable HTTP for remote ones. Use the server to explore and the API for anything you need to reproduce.

Which AI visibility APIs publish an MCP server?

Forty-eight of the 55 this site rates, checked on October 23, 2026, which makes it the one piece of tooling almost everyone ships. API for GEO, our pick after hands-on testing by Mathias C., lists MCP server access on both of its plans and describes ten families of data exposed as tools, at $13 per 1,000 answers collected and no charge for reads. DataForSEO runs a remote server at `mcp.dataforseo.com/v3/mcp` whose TypeScript implementation is open source, Profound hosts one at `mcp.tryprofound.com/mcp` on the Enterprise plan, Trakkr exposes 82 tools at `api.trakkr.ai/mcp` on a paid plan, Peec AI's server at `api.peec.ai/mcp` is described as included on every paid plan, and OtterlyAI's at `data.otterly.ai/mcp` counts against 2,000 requests a month on its $189 Standard plan.

Can a Claude skill call an AI visibility API?

It depends where the skill runs. Anthropic's documentation states that Skills on the Claude API run in a sandboxed container with no network access and no runtime package installation, so a skill there cannot reach a vendor's endpoint. In Claude Code, Skills have "the same network access as any other program on the user's computer", which is where an API-calling skill belongs. OtterlyAI publishes an official Claude Skill as an `otterly.skill` file and asks you to allow `data.otterly.ai` in Claude's domain allowlist and supply an `OTTERLY_API_KEY`; Scrunch publishes two families of Agent Skills installed with `npx skills add https://developers.scrunch.com`, the `api-*` ones reading a `SCRUNCH_API_TOKEN`.

Does querying an API through MCP spend credits?

Only when the tool you trigger runs a prompt against an engine. API for GEO's documentation states that "the AI Visibility API does not bill reads. Credits are consumed by executions, when a prompt runs against a model", at $0.013 per credit on its first tier, so a conversation that reads stored runs costs nothing and a conversation that asks for a fresh run costs one credit per prompt, per model and per locale. Platform APIs meter differently: OtterlyAI counts 2,000 API requests a month on its Standard plan and the same number of MCP requests, so an agent exploring your data competes with your own jobs for the quota.

How do I get an alert when my brand loses visibility in an AI answer?

Subscribe to a vendor webhook if one exists, and put the threshold on a rolling window rather than a single run. Trakkr documents `POST /webhooks` with events including `visibility_changed`, `rank_changed`, `citation_gained` and `report_completed`, signs each delivery with HMAC-SHA256 in an `X-Trakkr-Signature` header, retries three times at 1, 2 and 4 seconds, and tells you to deduplicate on `meta.event_id`. cloro takes a `webhook.url` on an async task with an optional `X-Cloro-Signature`, five attempts and results kept 24 hours. DataForSEO offers `postback_url`, which POSTs gzip-compressed results, and `pingback_url`, a GET notification that aborts if your server takes more than 10 seconds.

How often should a scheduled AI visibility job run?

Weekly collection with a monthly or quarterly comparison, four runs per prompt per month as a floor. cloro's published study of August 14, 2026 measured a mean overlap of 0.40 between the cited domains of two runs of the same prompt on the same model minutes apart, and puts about 300 answers per period at roughly ±5 percentage points, concluding that weekly reads are sound and daily reads are noise. If GitHub Actions carries the schedule, note that the shortest interval is once every five minutes, that the `schedule` event "can be delayed during periods of high loads", and that scheduled workflows in a public repository are disabled after 60 days without activity.