MCP server

The AnyAPI Model Context Protocol server lets an agent discover and run every API in the catalog through the same small set of tools.


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 it; discovery is free.
An MCP client that speaks Streamable HTTP, such as Claude Code, Claude Desktop, Cursor, or Codex.

The MCP surface accepts API keys only, not session tokens. Send Authorization: Bearer <your-key>. initialize, tools/list, and the catalog tools (list_apis, search_apis, get_api, quote_api) answer without a key. Running an API and reading account data need the key; without one they return unauthorized. The same catalog is public over REST at GET /catalog and GET /catalog/search.

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" }
    }
  }
}

Run it locally over stdio

For clients that can only launch a local stdio server, AnyAPI publishes one that forwards every listing and call to https://api.getanyapi.com/mcp.


npm	`anyapi-mcp`
Image	`ghcr.io/getanyapi-com/mcp`
Source	`getanyapi-com/mcp`
Transport	stdio
Auth	`ANYAPI_API_KEY` in the environment
Node	20 or newer

It declares no tools of its own, so catalog changes reach you without an upgrade.

npx
Claude Code
Docker

{
  "mcpServers": {
    "anyapi": {
      "command": "npx",
      "args": ["-y", "anyapi-mcp"],
      "env": { "ANYAPI_API_KEY": "YOUR_ANYAPI_KEY" }
    }
  }
}

claude mcp add anyapi -e ANYAPI_API_KEY=YOUR_ANYAPI_KEY -- npx -y anyapi-mcp

{
  "mcpServers": {
    "anyapi": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ANYAPI_API_KEY",
        "ghcr.io/getanyapi-com/mcp"
      ],
      "env": { "ANYAPI_API_KEY": "YOUR_ANYAPI_KEY" }
    }
  }
}

The image is public. It is built for linux/amd64, so on Apple Silicon Docker runs it under emulation and prints a platform warning.

ANYAPI_API_KEY is optional at startup: the catalog tools work without it. run_api and the account tools need it. The server is listed in the official MCP Registry as io.github.getanyapi-com/anyapi, with the hosted endpoint and both packages. If your client speaks remote Streamable HTTP, use the hosted endpoint instead; there is nothing to install.

Tools

Only run_api touches your wallet. The tools run on the same gateway as REST, so validation, routing, failover, pricing, and billing are identical.

list_apis - browse the catalog

Browse API summaries, optionally filtered by category. Summaries omit descriptions and schemas, so listing the whole catalog is cheap in tokens.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. Use search_apis for free-text queries and get_api for schemas.

search_apis - find an API by intent

Search by meaning and keyword across name, slug, and description. Matches include descriptions but not schemas.Input

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

Pass at least one of query, category, or platform. category or platform without query enumerates that scope, ordered by slug.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.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. Build the run_api payload from the input schema.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 observations or metrics could not be read. A p99 is an observation, not a maximum or a recommended timeout. If excludesCallerDelay is true, add any wait your input requests to estimate wall-clock time.

run_api - execute an API

Execute an API by SKU. Requires an AnyAPI key and bills your USD wallet (see Errors for what is free). Check get_api latency before choosing a tool deadline.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 keep a large result out of your context window. costUsd still reflects the full result.Returns the normalized output, provider (always AnyAPI), costUsd, items (the number of results returned), and replayed. Most APIs are priced per result (baseUsd + perUnitUsd × items), so a result cap in the input schema, when it declares one, also caps cost. Simple lookups are flat per request. Invalid input and insufficient funds are not charged. Some failed wallet-funded requests incur processing charges that we pass through at cost, with no markup; the error message shows the amount charged.Duplicate calls are not charged twice. When a client re-issues the same tool call, AnyAPI detects it automatically; you pass nothing.For long-running work, run_api waits briefly, then returns a Request ID with a nextAction. Call get_request instead of repeating run_api.linkedin.ads_search may also return a date_adjusted: hint with the dates used for your search. These dates remain unchanged on replay. See LinkedIn ad date filters.

get_request - resume durable work

Retrieve a durable Request by ID. It 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

Requires an AnyAPI key; free. No input.Returns balanceUsd, the remaining wallet balance in USD.

report_bug - tell us something is broken

Report wrong, empty, or malformed data for valid input, a misleading error, or a price or schema that looks wrong. Free.

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 when you have one so you need not paste the payload, then continue with your best alternative.

send_feedback - tell us what is missing

Send feedback that is not a defect: a missing API or field, confusing docs, or what would have made a task easier. Same fields as report_bug; free.

How an agent uses it

Discover

search_apis with a query such as “instagram” finds a SKU. list_apis browses instead.

Inspect

get_api returns the input schema and observed latency.

Run

run_api with the sku_id and input. AnyAPI routes, normalizes, and falls back on error.

Worked example

Tool results carry 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 fields without description or relevance, wrapped in scrapers. This API’s pricing.from.model is flat, so maxUsd is what one request is billed. A linear offer instead carries unit (for example "result"), baseUsd, perUnitUsd, maxUsd, and maxPer1kUsd; the charge is the base plus the per-unit amount, capped at maxUsd. failover is authoritative; do not infer it from lanes. Show people maxPer1kUsd as $0.90/1k req and read it rather than multiplying maxUsd; see every static price in two denominations.

// 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
`idempotency_in_progress`	An identical call is still running; wait a few seconds and repeat the same call to get its result	No
`idempotency_needs_review`	An identical earlier call is being reconciled; retrying will not clear it	No
`idempotency_conflict`	An earlier call holds this call’s duplicate-protection slot	No
`idempotency_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	See below
`provider_rate_limited`	The upstream rate-limited the request; resend the same call a second later, with the same `cursor` if you sent one, rather than starting again from page 1. REST sends `Retry-After: 1`	See below
`provider_timeout`	Every available route ended in an upstream timeout	See below
`site_not_supported`	Web scraping is not available for this site; the message names AnyAPI APIs built for that site, if there are any	No (released)
`site_unreachable`	No route could reach this site within the last 24 hours (every route timed out, or the only answer after the timeouts was “not found”), so the call was refused before it ran; the message says when AnyAPI will try the site again. Only `web.*` calls can return it, because only there the site is the URL you gave	No
`provider_transport_error`	Every available route ended in a network failure	See below
`provider_failure`	Every available route ended in an upstream service failure	See below
`malformed_upstream_response`	The upstream response could not be safely normalized	See below
`unclassified_upstream_response`	The upstream response is not recognized yet	See below
`all_providers_failed`	Every provider for this API failed	See below
`no_providers`	The API has no enabled providers	No
`async_unavailable`	This API runs as a durable request, and durable requests are not available right now, so nothing ran	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

Some failed wallet-funded requests incur processing charges that we pass through at cost, with no markup; the error message shows the amount charged. A normalized empty result such as found: false is a successful answer, not a tool error: the thing does not exist, was removed or suspended, or the search matched nothing. output.reason says which (not_found; suspended for a suspended account; too_long for a video longer than a transcript API’s source can transcribe). A miss no source billed is free. When AnyAPI asks more than one source, each source that charged is billed at its price for that request, capped at the API’s published maximum. costUsd is the actual charge, 0 when nothing was charged.

The agent skill teaches your agent the workflow and cost discipline; MCP provides the live tools. Help: support@getanyapi.com.

Getting Started

API Reference

Prerequisites

Connect

Run it locally over stdio

Tools

How an agent uses it

Worked example

Errors

​Prerequisites

​Connect

​Run it locally over stdio

​Tools

​How an agent uses it

​Worked example

​Errors

Prerequisites

Connect

Run it locally over stdio

Tools

How an agent uses it

Worked example

Errors