Introduction - AnyAPI

AnyAPI is a marketplace for scraping and data APIs. You call hundreds of APIs with one key, pay per request in US dollars from one wallet, and get a normalized response. When a source errors, AnyAPI fails over to the next one automatically.

Build from the API contract

To pick a SKU by eye, browse the catalog. Each platform page lists its endpoints, normalized schemas, and USD prices. Before you write a request, fetch the selected SKU’s contract:

GET https://api.getanyapi.com/v1/apis/{sku}

With MCP, call get_api instead. Use only the fields declared in inputSchema. Input fields are SKU-specific, so do not add names such as limit, cursor, page, or sort unless that schema declares them. If the API returns invalid_input, compare the request with the schema. Do not retry with guessed field names. If you use a coding agent, give it the maintained AnyAPI instructions:

Set up https://getanyapi.com/SKILL.md

How it works

Every API is a single POST to /v1/run/{sku}.

Send a request

Call /v1/run/{sku} with the SKU’s normalized input and your API key.

AnyAPI routes it

AnyAPI validates your input and runs it against the best source. On error it fails over to the next source, all under one price reservation.

Get a normalized result

You receive { output, provider, costUsd, items }. costUsd is what this call cost you.

Pricing

Prices are in USD, and every response reports its charge as costUsd. There are no subscriptions.

A failed call is free. If every source errors, you pay nothing.
A miss that the source did not bill is free.
When AnyAPI asks more than one source for one request, each source that charged is billed at its own price. The total is capped at the API’s published maximum.

Most APIs are priced per result: a per-item rate for each result returned, plus a small base fee on a few. A call that returns 5 results costs less than one that returns 50. Some input schemas declare a result cap such as limit; use it only when the selected SKU’s inputSchema declares it. The response reports items, the count you were charged for. Simple lookups are flat per request. Catalog and get_api results carry nested pricing. pricing.from is the cheapest complete flat or linear offer, and pricing.failoverMaxUsd is the greatest fallback ceiling. Linear offers name their billable unit and include baseUsd, perUnitUsd, and maxUsd, so you can budget before a call.

Every static price in two denominations

Every static discovery offer publishes its maximum twice:

Field	What it means
`pricing.from.maxUsd`	The most one request can be billed
`pricing.from.maxPer1kUsd`	That same maximum per 1,000 requests
`pricing.failoverMaxUsd`	The greatest fallback ceiling for one request
`pricing.failoverMaxPer1kUsd`	That same fallback ceiling per 1,000 requests

Lane-level pricing objects carry maxPer1kUsd too. AnyAPI quotes customers per 1,000 requests, because most of the catalog costs a fraction of a cent per call. When you show a catalog price to a person, read maxPer1kUsd and label it /1k req: $96.60/1k req, not $0.0966 per request. Read the published per-1k field instead of multiplying maxUsd yourself. Floating-point multiplication drifts: in most languages 0.0966 * 1000 is 96.60000000000001, and live catalog prices hit that case. baseUsd and perUnitUsd have no per-1k twin, because they are charged per billable item inside one call. Amounts for one specific call stay per request and are never scaled to 1,000: a price quote’s maxCostUsd and minCostUsd, the costUsd on a completed run, and your wallet balance. Report those exactly as returned.

For AI agents

The whole catalog is available through one MCP server:

Endpoint: https://api.getanyapi.com/mcp (Streamable HTTP)
Auth: Authorization: Bearer <ANYAPI_KEY>, required for run_api and get_balance. Discovery (list_apis, search_apis, get_api) works without a key.
Tools: search_apis (or list_apis to browse), then get_api to read the input JSON Schema, then run_api to execute. Runs bill the wallet in USD (costUsd) under the pricing rules. get_balance returns the wallet’s remaining USD.

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

The MCP server page covers per-client setup (Claude Code, Claude Desktop, Cursor, Codex) and the full tool reference. The official agent skill (npx skills add getanyapi-com/skills) teaches your agent this workflow, including pricing and error semantics. Agents can also use REST: GET /v1/apis?category=... to browse, GET /catalog/search?q=... to search, and POST /v1/run/{sku} to execute. See the API Reference and the public /openapi.json.

Get started

Quickstart

Make your first call.

Connect over MCP

Connect your AI agent to the catalog.

n8n community node

Run any AnyAPI endpoint inside an n8n workflow.

API Reference

Typed request and response schemas for every API.

Dashboard

Create keys, top up your wallet, and track usage.

​Build from the API contract

​How it works

​Pricing

​Every static price in two denominations

​For AI agents

​Get started