MCP server

AnyAPI ships a Model Context Protocol server so agents can discover and run any API in the catalog without bespoke integrations. Point your MCP client at one endpoint, authenticate with your AnyAPI key, and your agent gets a registry-driven tool surface that covers the entire catalog — no tool-per-API sprawl.


Endpoint	`https://api.getanyapi.com/mcp`
Transport	Streamable HTTP
Auth	AnyAPI key as a Bearer token
Tools	`list_apis`, `search_apis`, `get_api`, `run_api`, `get_request`, `get_balance`, `report_bug`, `send_feedback`

Prerequisites

An AnyAPI key. Create one in the dashboard under API keys.
A funded USD wallet. run_api bills your wallet per successful request; discovery is free.
An MCP-capable client (Claude Code, Claude Desktop, Cursor, Codex, or any client that speaks Streamable HTTP).

The MCP surface is API-key only — session tokens are not accepted. Send your key as Authorization: Bearer <your-key>. Discovery (list_apis, search_apis, get_api) works without a key, so an agent can browse the catalog and read schemas before credentials are set up; run_api and get_balance require authentication.

Connect

Claude Code
Claude Desktop
Cursor
Codex
Any MCP client

Add the server with the CLI:

claude mcp add anyapi \
  --transport http \
  https://api.getanyapi.com/mcp \
  --header "Authorization: Bearer YOUR_ANYAPI_KEY"

Confirm it registered:

claude mcp list

Open Settings → Developer → Edit Config and add AnyAPI to mcpServers:

{
  "mcpServers": {
    "anyapi": {
      "type": "http",
      "url": "https://api.getanyapi.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ANYAPI_KEY"
      }
    }
  }
}

Restart Claude Desktop. The AnyAPI tools appear in the tools menu.

Add AnyAPI to ~/.cursor/mcp.json (or your project’s .cursor/mcp.json):

{
  "mcpServers": {
    "anyapi": {
      "url": "https://api.getanyapi.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_ANYAPI_KEY"
      }
    }
  }
}

Enable the server in Settings → MCP.

Add the server with the Codex CLI:

codex mcp add anyapi \
  --url https://api.getanyapi.com/mcp \
  --header "Authorization: Bearer YOUR_ANYAPI_KEY"

Or add it to ~/.codex/config.toml:

[mcp_servers.anyapi]
url = "https://api.getanyapi.com/mcp"
http_headers = { "Authorization" = "Bearer YOUR_ANYAPI_KEY" }

Configure a remote Streamable HTTP server with these values:

URL: https://api.getanyapi.com/mcp
Header: Authorization: Bearer YOUR_ANYAPI_KEY

Most clients accept the same JSON shape:

{
  "mcpServers": {
    "anyapi": {
      "url": "https://api.getanyapi.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_ANYAPI_KEY" }
    }
  }
}

Tools

Discovery (list_apis, search_apis, get_api) is free; only run_api touches your wallet. get_balance reports what’s left in it, and report_bug and send_feedback let an agent tell us when something is wrong without leaving the session. The MCP tools are a lightweight transport and projection over the same AnyAPI gateway used by REST. The gateway owns input validation, provider selection, routing, failover, pricing, health semantics, response normalization, and billing. Discovery tools return those gateway-published facts and tolerate safe additions to the underlying catalog; they do not recalculate relationships between prices, lanes, or failover.

list_apis — browse the catalog

Browse APIs as lightweight summaries, optionally filtered by category. Summaries carry the SKU, name, category, provider, nested USD pricing, and failover status, but no descriptions or schemas, so listing the whole catalog stays token-cheap. To find an API by keyword (with descriptions), use search_apis; for one API’s schemas, use get_api.Input

Field	Type	Required	Description
`category`	string	no	Category slug to filter by

Returns scrapers, an array containing id, slug, name, category, provider, nested pricing, failover, and optional heavy and excludesCallerDelay. failover reports whether AnyAPI currently has an alternate route. Descriptions, lanes, health, schemas, latency, eligibility, and relevance are omitted. Use search_apis for every ranked free-text query.

search_apis — find an API by intent

Search APIs by meaning and keyword across name, slug, and description, returning matches with their descriptions (schemas omitted). This is the targeted lookup: use it to find the right SKU before reading its schema with get_api.Input

Field	Type	Required	Description
`query`	string	yes	Free-text search over name, slug, and description
`category`	string	no	Category slug to narrow the search
`platform`	string	no	Platform slug to narrow the search
`limit`	integer	no	Cap on matches returned (default 25)

Returns results with the list fields, including failover, plus description and response-relative relevance, total before the limit, and ranking (semantic or keyword). Lanes, health, schemas, latency, and eligibility are omitted.

get_api — inspect input and output schemas

Get the full definition of one API by SKU, including its normalized input and output JSON schemas.Input

Field	Type	Required	Description
`sku_id`	string	yes	The API SKU slug to describe

Returns the list fields, including failover, plus description, anonymous lane pricing, input/output JSON schemas, nullable latency, and optional tryEligible. Lane health is omitted. Use the input schema to build a valid payload for run_api.latency describes successful end-to-end requests after AnyAPI failover over the trailing 30 days:

Field	Meaning
`window`	Observation window, currently `30d`
`p50Ms`, `p95Ms`, `p99Ms`	Observed latency percentiles in milliseconds
`sample`	Successful requests included in the percentiles
`basis`	`service_time_excludes_caller_requested_delay`

The value is null when there are no successful observations or metrics could not be read. A p99 is an observation, not a maximum or a recommended timeout. If excludesCallerDelay is true, add the waiting requested in your input when reasoning about wall-clock time.

run_api — execute an API

Execute an API by SKU with a normalized input payload. Requires a valid AnyAPI key. Billed to your USD wallet on success only. Before choosing an MCP tool deadline, call get_api and inspect its observed latency.Input

Field	Type	Required	Description
`sku_id`	string	yes	The API SKU slug to execute
`input`	object	yes	Normalized payload matching the API’s input schema
`fields`	string	no	Comma-separated keys (dotted paths like `author.name`) to keep on each result item. Trims the response, not the charge.
`max_items`	integer	no	Cap the number of result rows returned; a `_truncated` note reports how many were withheld. Trims the response, not the charge.
`summary`	boolean	no	Return only a structural outline (top-level keys and item counts) instead of the full data. Trims the response, not the charge.

The last three are opt-in response-budget controls — they keep a large result from flooding your context window. They change only what is returned to you, never what you are billed (costUsd reflects the full result the API produced).Returns the normalized output, the serving provider (always AnyAPI), costUsd, items (the number of results charged for), and replayed. Most APIs are priced per result — baseUsd + perUnitUsd × items — so cap results (and cost) with limit in your input; simple lookups are flat per request. Invalid input, insufficient funds, and total upstream failure are not charged.Duplicate calls are not charged twice. MCP clients re-issue a tool call on their own judgment: the model reads a result as truncated, the user re-runs the turn, a conversation branch is replayed. AnyAPI derives a duplicate-protection key automatically, with no argument for you to pass.For long-running work, run_api waits briefly and then returns a Request ID with a machine-actionable nextAction. Call get_request instead of repeating run_api.

get_request — resume durable work

Retrieve a durable Request by ID. This reads AnyAPI’s stored state and never repeats the paid operation.Input

Field	Type	Required	Description
`request_id`	string	yes	The Request ID returned by `run_api`

Returns the Request status and either its terminal result or a nextAction telling the agent when to call get_request again.

get_balance — check your wallet

Get the remaining wallet balance for the API key you authenticate with. Requires a valid AnyAPI key; never charges.Input — none.Returns balanceUsd, the remaining wallet balance in USD. Use it to confirm there are funds before a run_api call, or to surface the balance to a user.

report_bug - tell us something is broken

Report a defect: a run_api call that returned wrong, empty, or malformed data for input you believe is valid, an error message that was misleading or unactionable, or a price or schema that looks wrong. Free; nothing is charged.

Field	Type	Required	Description
`summary`	string	yes	One line saying what went wrong
`details`	string	no	What you expected, what you got, what you already tried
`sku`	string	no	The SKU this is about
`request_id`	string	no	The `requestId` or `resultId` from the failing run
`contact`	string	no	An email to reply to

Returns the stored report id. Pass request_id whenever you have one: it reaches the stored run and its upstream error body, so you never need to paste the payload. File the report and continue with the best alternative you have.

send_feedback - tell us what is missing

Send feedback that is not a defect: an API you wanted and could not find in the catalog, a field missing from a result you needed, a confusing part of the docs, or what would have made a task easier. Same fields as report_bug, and also free.

How an agent uses it

A typical flow chains the tools - discover, inspect, run:

Discover

The agent calls search_apis with a query (for example, “instagram”) to find a matching SKU and read its description. (Use list_apis instead to browse the whole catalog as lightweight summaries.)

Inspect

It calls get_api with that sku_id to read the input schema, inspect observed latency before choosing a tool deadline, and build a valid payload.

Run

It calls run_api with the sku_id and input. AnyAPI routes to a provider, normalizes the response, falls back automatically on error, and returns the result.

Because every API shares the same tools and one normalized schema convention, an agent that learns this flow once can use the entire catalog.

Worked example

Discover Reddit APIs, inspect one, and run it. Tool results carry both a JSON text block and structuredContent with these shapes:

// search_apis {"query": "reddit"} → structuredContent
{
  "results": [
    {
      "id": "reddit.search",
      "slug": "reddit.search",
      "category": "social",
      "name": "Reddit Search",
      "description": "Search Reddit posts across all subreddits by query, normalized across providers with transparent failover.",
      "provider": "AnyAPI",
      "pricing": {
        "from": {
          "model": "flat",
          "unit": "request",
          "maxUsd": 0.0009,
          "maxPer1kUsd": 0.9
        },
        "failoverMaxUsd": 0.0036,
        "failoverMaxPer1kUsd": 3.6
      },
      "failover": true,
      "relevance": 1
    }
  ],
  "total": 1,
  "ranking": "semantic"
}

list_apis returns the same identity and pricing fields without description or relevance (and wrapped in scrapers). Neither tool returns lanes, health, or schemas, so browsing and searching stay token-cheap. Reach for list_apis when you want to enumerate rather than search. This API’s pricing.from.model is flat, so maxUsd is what one request is billed. failover is the gateway’s authoritative routing fact; do not infer it from lanes. A linear offer instead carries unit, baseUsd, perUnitUsd, maxUsd, and maxPer1kUsd. For example, an API billed per result reports unit: "result"; the actual successful charge is the base plus the per-unit amount, capped at maxUsd. Every static offer publishes its maximum twice: maxUsd for one request and maxPer1kUsd for 1,000 of them, with failoverMaxPer1kUsd as the twin of failoverMaxUsd. Lane-level pricing objects carry maxPer1kUsd too. Per 1,000 requests is the denomination AnyAPI quotes customers in, because most of the catalog costs a fraction of a cent per call and per-request figures cannot be compared by eye. Surface $0.90/1k req rather than $0.0009 per request, and read the published field instead of multiplying maxUsd, which drifts in floating point (0.0966 * 1000 is 96.60000000000001 in most languages). baseUsd and perUnitUsd have no per-1k twin, because they are charged per billable item inside one call. Amounts that state what a specific call costs stay per request and are never scaled to 1,000: a price quote’s maxCostUsd and minCostUsd, the costUsd run_api returns, and the balanceUsd from get_balance.

// get_api {"sku_id": "reddit.search"} → structuredContent (schemas abridged)
{
  "scraper": {
    "id": "reddit.search",
    "slug": "reddit.search",
    "category": "social",
    "name": "Reddit Search",
    "provider": "AnyAPI",
    "pricing": {
      "from": {
        "model": "flat",
        "unit": "request",
        "maxUsd": 0.0009,
        "maxPer1kUsd": 0.9
      },
      "failoverMaxUsd": 0.0036,
      "failoverMaxPer1kUsd": 3.6
    },
    "failover": true,
    "description": "Search Reddit posts across all subreddits by query.",
    "lanes": [
      {
        "pricing": {
          "model": "flat",
          "unit": "request",
          "maxUsd": 0.0009,
          "maxPer1kUsd": 0.9
        }
      }
    ],
    "inputSchema": {
      "type": "object",
      "required": ["query"],
      "properties": {
        "query":     { "type": "string" },
        "sort":      { "type": "string" },
        "timeframe": { "type": "string" },
        "after":     { "type": "string" }
      }
    },
    "outputSchema": { "type": "object" }
  }
}

// run_api {"sku_id": "reddit.search", "input": {"query": "golang"}} → structuredContent
{
  "output":   { "posts": [ { "title": "…", "url": "…", "score": 123 } ] },
  "provider": "AnyAPI",
  "costUsd":  0.0009,
  "items":    25,
  "replayed": false
}

Errors

Tool failures come back as MCP tool errors with a short machine-readable prefix:

Prefix	Meaning	Billed
`unauthorized`	Missing or invalid AnyAPI key	No
`sku_not_found`	The requested SKU does not exist	No
`invalid_input`	Payload did not match the API’s input schema	No
`insufficient_balance`	Wallet balance too low — top up to run	No
`key_cap_exceeded`	The API key reached its configured spend cap	No
`grant_cap_exceeded`	The authorization reached the spending limit its owner approved	No
`trial_cap_reached`	The autonomous trial reached its cap	No
`duplicate_call_in_progress`	An identical call is still running; wait a few seconds and repeat the same call to get its result	No
`duplicate_needs_review`	An identical earlier call is being reconciled; retrying will not clear it	No
`duplicate_call_conflict`	An earlier call holds this call’s duplicate-protection slot	No
`duplicate_protection_unavailable`	AnyAPI could not check for a duplicate, so nothing ran; safe to retry	No
`provider_rejected_request`	The upstream rejected this request; adjust it before retrying	No
`provider_rate_limited`	The upstream rate-limited the request; retry later	No
`provider_timeout`	Every available route ended in an upstream timeout	No (released)
`provider_transport_error`	Every available route ended in a network failure	No (released)
`provider_failure`	Every available route ended in an upstream service failure	No (released)
`malformed_upstream_response`	The upstream response could not be safely normalized	No (released)
`unclassified_upstream_response`	The upstream response is not recognized yet	No (released)
`all_providers_failed`	Every provider for this API failed	No (released)
`no_providers`	The API has no enabled providers	No
`scrape_failed`	The run ended without a confirmed outcome	Unknown - check `get_balance`; repeating the same call within a few minutes cannot double charge

A completed lookup that returns a normalized empty result such as found: false is not a tool error. It is a successful, billable answer: the lookup ran and no matching entity was found.

Pair the MCP server with the official agent skill — the skill teaches your agent the discover → inspect → run workflow and cost discipline; MCP provides the live tools. Need help? Reach out at support@getanyapi.com.

Getting Started

Sell on AnyAPI

API Reference

Prerequisites

Connect

Tools

How an agent uses it

Worked example

Errors

​Prerequisites

​Connect

​Tools

​How an agent uses it

​Worked example

​Errors

Prerequisites

Connect

Tools

How an agent uses it

Worked example

Errors