Integration
How to connect an AI visibility API to Claude or Cursor with MCP
One command in Claude Code, one URL in Cursor: 48 of the 55 AI visibility APIs we track publish an MCP server, and reads cost nothing on some of them.

By Mathias C.SEO consultant, and more recently GEO, at MentionBox
Connecting an AI visibility API to Claude or Cursor through the Model Context Protocol takes one line of setup once you have three facts from the vendor: the MCP endpoint, the authentication method, and whether a tool call spends credits. In Claude Code the line is claude mcp add --transport http <name> <url>; in Claude's web and desktop apps the same URL goes in as a custom connector; in Cursor it goes in .cursor/mcp.json. Of the 55 AI visibility APIs this site rates, 48 publish a server, checked on October 23, 2026, among them API for GEO, our editorial pick after hands-on testing by Mathias C., which lists MCP server access on both of its plans and describes ten families of data exposed as tools so that Claude or Cursor can query them directly.
This guide is written for a developer who already has a key for one of these APIs and wants the data in the tool they work in, rather than in a browser tab. It gives the exact command or file for each client, the authentication modes the protocol allows, what a tool call bills on nine vendors, a verification sequence for the first five minutes, and a troubleshooting table for the failures that look identical from the outside. Endpoints, plans and metering come from each vendor's own documentation, checked on October 23, 2026; the client and protocol details were read on November 18, 2026. MentionBox, which publishes this site, has a commercial link with API for GEO.
What an MCP server adds to an API you already have
The REST API and the MCP server return the same data from the same account. The difference is who writes the request. With the API, you choose the endpoint, the parameters and the schedule, and next month the same call returns the same shape. With the server, the model chooses the tool and the arguments while it answers you, which is faster for a question asked once and worse for a figure you have to reproduce.
The protocol itself is small. The MCP specification defines two standard transports, stdio, where "the client launches the MCP server as a subprocess", and Streamable HTTP, where the server "MUST provide a single HTTP endpoint path" that answers both POST and GET. Nearly every AI visibility vendor ships the second kind, hosted at a URL, because the data lives in their account system rather than on your machine. Discovery and execution are two JSON-RPC calls, tools/list and tools/call, which is why a connected server appears as a list of tools in every client.
Our guide to five ways to use an AI visibility API prices this pattern against the four others. What follows is the connection itself, client by client.
The three facts to collect before you connect
Vendors document these in three different places, and the second and third decide whether the connection is a five-minute job or a plan upgrade.
| API | MCP endpoint | Authentication | Plan requirement | What a tool call bills |
|---|---|---|---|---|
| API for GEO | not published when we checked | not published | both plans, pay as you go from $0.013 a credit | nothing for reads; one credit per prompt, model and locale when a tool runs an execution |
| DataForSEO | mcp.dataforseo.com/v3/mcp, or local npx dataforseo-mcp-server | Basic auth, base64 of the API login and password, or OAuth 2.0 bearer | any account, after the $50 minimum payment | the task it posts, $1.20 per 1,000 answers on the standard queue |
| Profound | mcp.tryprofound.com/mcp | not published | Enterprise plan | not published |
| Peec AI | api.peec.ai/mcp, Streamable HTTP | OAuth 2.0, or a personal access token as a bearer header | an account with at least one project | not published |
| OtterlyAI | data.otterly.ai/mcp | OAuth 2.0 only, "You do not pass an API key" | $189 Standard plan and above | every call except get_account_info, against 2,000 requests a month |
| Trakkr | api.trakkr.ai/mcp, Streamable HTTP | OAuth with dynamic client registration and PKCE | a paid plan, from $500 a month | not published |
| cloro | mcp.cloro.dev/mcp | OAuth, or the key in a bearer header or in the URL path | $30 Lite plan and above | the scrape, at the base rate plus add-ons plus a two-credit synchronous surcharge |
| LLM Pulse | api.llmpulse.ai/api/v1/mcp | OAuth on every plan; a bearer API key from the Scale plan up | OAuth free on every plan | the plan quota the underlying feature uses |
| SE Ranking | api.seranking.com/mcp, Streamable HTTP | OAuth 2.1 with dynamic client registration | wallet credits on the Data API | the credits the underlying endpoint costs |
Endpoints, authentication modes, plan requirements and metering from each vendor's MCP documentation and pricing page, checked on October 23, 2026. For API for GEO, the pricing page carries an "MCP server access: Yes" line on both plans and the home page describes "the same ten families exposed as tools, so Claude or Cursor can query your GEO data directly", while the connection URL and the tool list were not published when we checked; its rate is $13 per 1,000 answers collected, down to $7 above a million credits a month, roughly ten times DataForSEO's per-answer price, and four of the ten engines we track, Gemini, Google AI Overviews, DeepSeek and Meta AI, plus its webhooks, OpenAPI spec and official SDKs, were confirmed in our hands-on test of October 26, 2026 rather than documented on apiforgeo.com.
Two columns in that table change the shape of the work.
- The authentication mode decides who can connect. An OAuth server signs in the human sitting in front of the client, which suits a desktop app and blocks a headless job. A bearer key suits both, and several vendors gate the key behind a higher plan than the OAuth flow.
- The metering decides what a conversation costs. A server whose tools read stored runs is free to talk to on several of these APIs. A server whose tools run a fresh prompt, as cloro's
scrape_chatgptdoes, spends collection budget every time the model gets curious.
Connect it to Claude Code
Claude Code takes the server from the command line, and the MCP documentation gives one form per transport. For a hosted server with OAuth, the whole setup is the URL:
claude mcp add peec-ai --transport http https://api.peec.ai/mcp
For a server that authenticates with a key, pass the header and keep the value in the environment:
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 an afternoon.
- Scope decides where the entry lands. Local scope, the default, writes a project-specific entry in
~/.claude.json;--scope projectwrites.mcp.jsonat the repository root, which you commit so every developer gets the same tools;--scope userapplies the server to all your projects. Precedence runs local, then project, then user, then plugin servers, then claude.ai connectors. - Variables expand at connection time. Both
${VAR}and${VAR:-default}work inside.mcp.json, in the URL and in headers. Claude Code deliberately reads a short list of credential variables as empty, and the documentation spells out the consequence: "If you writeBearer ${ANTHROPIC_AUTH_TOKEN}, the server receivesBearerwith no credential and rejects the request, usually with a401." - OAuth happens after the add. Add the server, run
/mcp, pick it and finish the browser login, or do it from the shell withclaude mcp login <name>, which takes--no-browseron a machine without one. - Tools arrive under a predictable name. A tool from a server called
georeaches the model asmcp__geo__<tool-name>, which is the string that permission rules and a skill'sallowed-toolsfield expect.
A committed .mcp.json for a keyed server, with a tool timeout long enough for a collection call, looks like this:
{
"mcpServers": {
"geo": {
"type": "http",
"url": "https://api.example.com/mcp",
"headers": { "Authorization": "Bearer ${GEO_API_KEY}" },
"timeout": 600000
}
}
}
For a credential that expires, the same file accepts headersHelper, a command Claude Code runs on each connection and which "must write a JSON object of string key-value pairs to stdout". That is the clean way to connect a server behind SSO without putting a token in version control.
Local servers follow the stdio form, with the -- separating Claude's own options from the command. DataForSEO documents both routes, and its local one needs no OAuth client at all:
claude mcp add dataforseo \
--env DATAFORSEO_USERNAME=your_api_login \
--env DATAFORSEO_PASSWORD=your_api_password \
-- npx -y dataforseo-mcp-server
Its remote endpoint takes the same credentials as a base64 Basic auth header, and the TypeScript implementation behind both is published under Apache 2.0, which makes it the one server in this market you can read before you trust it.
Connect it to Claude Desktop and the web app
Outside the terminal, the same server goes in as a custom connector. Anthropic's documentation on custom connectors states that they are available on Claude, Cowork and Claude Desktop for Free, Pro, Max, Ultra, Team and Enterprise plans, with Free users "limited to one connector". The path is Customize, then Connectors, then Add custom connector, and the instruction that prevents most failed attempts is to enter the URL "exactly as the provider documents it, including any path".
Three settings on that screen deserve a decision rather than a default.
- Authentication. The OAuth choices are Claude's published identity, automatic registration, or your own OAuth client with its ID and secret. Trakkr's documentation, for example, tells you to pick "Register automatically" and then approve access in the Trakkr sign-in window.
- Request headers. For a vendor that issues keys rather than OAuth, the documentation says to "add fixed credentials such as API keys that Claude sends on every request" under Request headers. Treat that field as a secret store: a personal access token on Peec AI is "a long-lived bearer token tied to your Peec user", with expiry options of never, 30, 60 or 90 days, and its documentation asks you to treat it like a password.
- Who owns the connector. Team and Enterprise owners add connectors from organization settings, and Peec AI notes that "Only workspace Admins in Claude can add the connector", so a developer on a company plan may need an admin for a five-minute task.
The network requirement rules out a server on an internal host: it must be "reachable over the public internet" on port 443, and a private network needs Anthropic's IP addresses allowlisted. Several vendors also publish an official connector in Claude's directory, which skips the URL entry: SE Ranking tells you to "Add the official SE Ranking connector and click Connect", and OtterlyAI asks you to search its name under Customize then Connectors.
Connect it to Cursor
Cursor offers a one-click install from its marketplace, which carries the OAuth flow, and a file for everything else. Its MCP documentation puts the file in two places, .cursor/mcp.json in the project root for one repository and ~/.cursor/mcp.json for every project, with the same mcpServers object both Claude clients use. Remote and local servers can sit side by side:
{
"mcpServers": {
"se-ranking": {
"url": "https://api.seranking.com/mcp"
},
"dataforseo": {
"command": "npx",
"args": ["-y", "dataforseo-mcp-server"],
"env": {
"DATAFORSEO_USERNAME": "${env:DATAFORSEO_USERNAME}",
"DATAFORSEO_PASSWORD": "${env:DATAFORSEO_PASSWORD}"
}
}
}
}
Cursor interpolates ${env:VARIABLE_NAME} inside command, args, env, url and headers, along with ${workspaceFolder}, ${userHome} and ${pathSeparator}, so no credential has to be written in the file. For a remote server added through the interface, the route is Settings, then Tools and Integrations, then MCP, then Add Custom MCP, with Streamable HTTP as the transport type, which is how Peec AI documents it. Static OAuth client credentials go in an auth object with a client ID, secret and scopes, and Cursor's fixed redirect URLs are https://www.cursor.com/agents/mcp/oauth/callback on the web and http://localhost:8787/callback on the desktop, the pair to register if the vendor asks for a redirect URI.
When a vendor's server expects an OAuth client Cursor does not provide, the documented workaround is a local bridge. OtterlyAI's own Cursor configuration runs one:
{
"mcpServers": {
"otterly": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://data.otterly.ai/mcp"]
}
}
}
The first five minutes, before you trust a figure
A connected server tells you nothing about whether the account behind it holds the data you want. The sequence below takes a few minutes and catches the three failures that otherwise surface in front of a client.
- Check the connection, not the config.
claude mcp listprints each server with a status, and the documented states include✔ Connected,! Needs authentication,✘ Failed to connectand⏸ Pending approval. In Cursor, the Available Tools list under the server is the equivalent. - Call one read-only tool with an empty input. Trakkr's documentation suggests exactly that as a first read,
list_brandswith{}, to confirm access and collect the brand IDs every later call needs. Most of these servers have an equivalent listing tool. - Find the metering tool. OtterlyAI's
get_account_infois free and "never counts against the MCP limit"; cloro exposesget_creditsand returnscredits.chargedandcredits.remainingin every scrape result. Call it before and after a session until you know what a conversation costs. - Reconcile one number against the REST API. Take a single figure the model reports, pull the same window from the documented endpoint, and compare. An MCP tool that silently defaults to a different date range or a different locale is indistinguishable from a real change in visibility.
- Write down which tool produced the figure. The model picks the tool, so the tool name and its arguments are the only record of what was measured.
What a session bills, and what it does not
Metering is the part of this market with the least standardisation, and the published statements differ enough to change which server you leave connected.
- Reads free, executions metered. API for GEO states that the AI Visibility API does not bill reads and that credits are consumed by executions, when a prompt runs against a model, at $0.013 a credit on its first tier and $0.007 above a million credits a month, with reads unmetered inside a limit of 300 requests a minute. A conversation about runs already collected costs nothing.
- The same meter as the API. Semrush's MCP page states that its server "uses the same unit-based system as the Semrush API to manage and limit API usage", over
mcp.semrush.com/v2/mcpwith "streamable HTTP transport only", OAuth by default or anAuthorization: Apikeyheader, and read-only access to Project API methods. - A separate monthly allowance. OtterlyAI counts MCP calls against the plan allowance, 2,000 requests a month on its $189 Standard plan, and returns "Request limit exceeded for this billing period" when it runs out. An exploratory session there competes with your own jobs.
- A surcharge for the synchronous call. cloro's MCP tools run live scrapes, billed "at the provider's base rate plus any add-ons plus the +2 sync surcharge" on a Lite plan whose published rate is $4 per 1,000 answers.
- Free for now. SISTRIX states that requests made through its MCP server "do not deduct credits from your available quota at this time", a sentence whose last four words are the operative ones.
LLM Pulse sits in between, with OAuth included on every plan, a bearer key from the Scale plan up, a documented ceiling of 300 requests a minute per connection, and tools that still consume the quota of the feature behind them. Its page is also explicit about plan-shaped tool lists: "tool availability follows your plan and, for team members, your permission role. If a feature is locked in the app, its MCP tool is filtered out too."
When the server connects and nothing happens
Most MCP failures present the same way, as an assistant that answers from memory instead of calling a tool. The causes are distinguishable once you know what to look at.
| Symptom | Likely cause | Fix |
|---|---|---|
401 on every call, right after adding | the header never carried a value, often a variable Claude Code blanks on purpose | print the header from a shell, rename the variable away from the reserved credential names |
Status reads ! Needs authentication | the OAuth flow was never completed | run /mcp in the session, or claude mcp login <name>, with --no-browser on a remote box |
| Server connected, its tools never called | the combined tool count exceeds what the client forwards | disable other servers, or select groups: Ahrefs takes ?tools=brand-radar-simple, and an essentials value for "clients with tool limits" |
| A tool that exists in the REST API is missing | the vendor filters its own surface | SE Ranking states that "Not every API endpoint is available through MCP"; LLM Pulse filters by plan and role |
| The call runs for minutes, then aborts | idle and background timeouts, 5 minutes for network servers in Claude Code, with long calls moved to a background task after 2 minutes by default | raise the per-server timeout in .mcp.json, or trigger the job through the REST API and read the result later |
404 mid-session on a working server | the HTTP session expired | the specification tells the client to start a new session with a new InitializeRequest, so reconnect with /mcp reconnect all |
400 Bad Request on every request | an unsupported protocol version header | update the client; the spec requires a MCP-Protocol-Version header and a 400 when the value is unsupported |
| Connector cannot be added at all | plan or role limit | Free accounts get one connector; on Team and Enterprise, only workspace admins add them |
Client behaviour from the Claude Code MCP documentation and Anthropic's custom connector page, protocol behaviour from the Model Context Protocol specification, vendor behaviour from the Ahrefs, SE Ranking and LLM Pulse documentation, all read on November 18, 2026.
One more entry belongs on that list even though it looks like a success: a server added over the deprecated SSE transport. Claude Code still accepts --transport sse and marks it deprecated in favour of HTTP, so new integrations should use the HTTP form.
Treat answer text as untrusted input
An AI visibility tool returns prose written by an engine that read pages you do not control, and it hands that prose to an agent with tools. Claude Code's documentation puts the warning in one line: "Verify you trust each server before connecting it. Servers that fetch external content can expose you to prompt injection risk." Anthropic's connector page adds the other direction, that "malicious MCP servers may include hidden instructions that try to make Claude perform unintended actions".
Four measures cover the practical risk without turning the integration into a project.
- Use read-only credentials. OtterlyAI restricts creation, deletion and updates to accounts with write permission, and Peec AI marks its configuration tools with
readOnlyHint: falseanddestructiveHint: true, which a careful client surfaces before it runs them. A reading session has no business holding a key that can delete a prompt set. - Keep the key out of the URL. cloro accepts its key either in a bearer header or in the URL path. The path variant travels through logs and proxies, so prefer the header.
- Prefer the OAuth flow the specification describes. MCP authorization is built on OAuth 2.1 with PKCE, protected resource metadata for discovering the authorization server, and the RFC 8707
resourceparameter so that a token is bound to the server it was issued for. The specification is blunt about the alternative: an MCP server "MUST NOT pass through the token it received from the MCP client" to an upstream API. - Separate the exploring session from the writing one. Two connectors, one read-only and one with write tools, cost nothing and remove the whole class of accident where a summary request edits a prompt list.
Keep the series in a script
An MCP server is the right tool for the first hour with an API and for a question raised in a meeting. The reporting line underneath it belongs in code: a scheduled script sends the same parameters every week, logs what it spent, and stores the raw answers where a recount is possible. Our guide to building an in-house GEO dashboard with an API covers that layer, including the four tables worth keeping, and our guide to running one prompt on multiple AI engines covers the collection call itself. The split we would keep: the script owns collection and arithmetic, the server owns questions, and the agent reads what the script already paid for.
Our view
Three setups we would defend, depending on what you are optimising.
- Cheapest data, server you can audit. DataForSEO at $1.20 per 1,000 answers on the standard queue, with a remote endpoint, a local
npxserver, Basic auth or OAuth, and an Apache 2.0 TypeScript implementation you can read. Our score: 7.7 out of 10, with engine coverage as the limit at five of the ten we track. Watch the tool count in Cursor, which its own page caps at 40 active tools. - OAuth on every plan, no key negotiation. LLM Pulse at €30.67 per 1,000 answers, with OAuth included on every plan and during eligible trials, a bearer key from the Scale plan up, and a documented 300 requests a minute per connection. Our score: 8.8 out of 10. The plan-shaped tool list is the thing to check during the trial, since a locked feature disappears from
tools/listwithout an error. - Figures already computed, reads not billed. API for GEO, our editorial pick, at $13 per 1,000 answers collected down to $7 at its largest tier, pay as you go with no published minimum, MCP server access on both plans, ten families of data exposed as tools, resale allowed, and 9.0 out of 10, the best score of the 55 APIs this site rates. Said plainly, the trade-offs are a per-answer rate about ten times DataForSEO's, a connection URL and tool list that were not published when we checked, and four of its ten engines plus its webhooks, OpenAPI spec and official SDKs confirmed in our test of October 26, 2026 rather than documented on apiforgeo.com.
For a platform team, Profound is worth a quote request: its server at mcp.tryprofound.com/mcp covers visibility, sentiment, citation and shopping reports, agent analytics, prompt management and knowledge bases, the widest published surface of the nine, on an Enterprise plan with no public price. Peec AI documents setup for the most clients, Claude Desktop, Claude Web, Claude Code, Cursor, VS Code and Windsurf, and its server is described as included on every paid plan. The duels API for GEO vs Profound and Profound vs Peec AI put those payloads side by side.
Frequently asked questions
How do I connect an AI visibility API to Claude Code?
One command, with the vendor's MCP endpoint and its authentication method: `claude mcp add --transport http peec-ai https://api.peec.ai/mcp` for a server that signs you in through OAuth, or the same command with `--header "Authorization: Bearer $TOKEN"` for a server that takes a key. Add `--scope project` to write the entry into `.mcp.json` at the repository root so the whole team gets the same tools, and keep the credential in an environment variable, which Claude Code expands as `${VAR}` at connection time. Run `claude mcp list` to see the connection status, then `/mcp` inside a session to finish an OAuth login.
Can I add an AI visibility MCP server to Claude.ai or Claude Desktop?
Yes, as a custom connector. Anthropic's documentation says custom connectors using remote MCP are available on Free, Pro, Max, Ultra, Team and Enterprise plans, with Free limited to one connector, and that you should enter the server URL "exactly as the provider documents it, including any path". Individual users add it under Customize then Connectors; Team and Enterprise owners add it in organization settings, and Peec AI's documentation notes that "Only workspace Admins in Claude can add the connector". Authentication is OAuth, or fixed request headers for an API key, and the server has to be reachable over the public internet on port 443.
How do I add an MCP server to Cursor?
Through the one-click marketplace install, which carries the OAuth flow, or by writing `mcp.json` yourself: `.cursor/mcp.json` in the project root for one repository, `~/.cursor/mcp.json` for every project. A remote server needs a `url` and optional `headers`, and Cursor interpolates `${env:VARIABLE_NAME}` inside `command`, `args`, `env`, `url` and `headers`, so the key stays out of the file. For a server Cursor cannot reach directly, OtterlyAI's documentation shows the bridge pattern instead, `npx -y mcp-remote https://data.otterly.ai/mcp`.
Does querying an AI visibility API through MCP cost credits?
It depends on whether the tool you trigger reads stored data or runs a fresh prompt against an engine. API for GEO, our pick after hands-on testing, states that the AI Visibility API does not bill reads and that credits are consumed by executions, when a prompt runs against a model, at $0.013 per credit on its first tier and down to $0.007 above a million credits a month, so a conversation about last week's figures costs nothing. cloro bills each MCP scrape "at the provider's base rate plus any add-ons plus the +2 sync surcharge" and returns `credits.charged` in the result, Semrush's MCP server "uses the same unit-based system as the Semrush API", and SISTRIX states that MCP requests "do not deduct credits from your available quota at this time". Checked on October 23, 2026.
Why does my MCP server connect but the model never calls its tools?
The usual cause is the number of tools advertised. These servers are large: 82 tools on Trakkr, 87 on Writesonic and 67 on Keyword.com, counted on October 23, 2026, with over 40 on OtterlyAI, and clients cap what they send to the model. DataForSEO's MCP page tells Cursor users that "Cursor supports up to 40 active MCP tools" and asks them to disable any modules they do not need, and Ahrefs lets you pick groups with a `?tools=` parameter, including an `essentials` value it describes as a curated subset for clients with tool limits. Disable the servers you are not using, then name the tool you want in the prompt.
Is it safe to let an agent read AI answer text through an MCP tool?
Read-only access to answer text is the safe half; write tools on the same connection are the risk. Claude Code's MCP documentation warns that "servers that fetch external content can expose you to prompt injection risk", and an engine's answer is text produced from pages you do not control. Anthropic's connector documentation adds that "malicious MCP servers may include hidden instructions that try to make Claude perform unintended actions". Use a read-only credential where the vendor offers one, as OtterlyAI does by restricting creation and deletion to accounts with write permission, and keep prompt-management tools out of any session that reads collected answers.