EveryInfra

Remote MCP server for structured public data from 106 platforms (social, e-commerce, maps, reviews), plus web search and CAPTCHA solving. One API key, pay per call from $0.56 per 1,000 requests; failed and empty results are not charged.

View on everyinfra.com

Hosted MCP Server

npx add-mcp 'https://api.everyinfra.com/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

EveryInfra API and MCP documentation

Choose a task from the public catalog. Create an API key. Then make your first call. This guide covers request examples, MCP setup, authentication, billing, and error handling.

Quickstart

One account for data, search, CAPTCHA solving, and a free AI API

EveryInfra provides 573 data collection capabilities across 106 platforms, 17 search tools, 52 CAPTCHA types, and an OpenAI-compatible AI API that is free after a top-up. Each product has its own endpoint, permissions, and request format.

  • Public catalogs can be read without an API key.
  • Authenticated endpoints use a Bearer API key.
  • MCP and REST use the same capabilities, parameters and responses.

Send a real request

Create an API key in the console, read the relevant catalog, and send the platform or capability identifier exactly as listed. The response includes structured output and request-level billing data.

  • Set Authorization: Bearer YOUR_API_KEY.
  • Set Content-Type: application/json for JSON request bodies.
  • Use catalog identifiers and parameter names exactly as returned.
  • For slow tasks, large limits or batches, send "mode":"async" in the request body: you receive a job_id immediately and poll GET /api/v1/jobs/{job_id} for the result. A synchronous request must finish within 85 seconds; an async job is not bound by that limit.
curl -X POST https://api.everyinfra.com/api/v1/social \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"platform":"tiktok","action":"search","params":{"keyword":"AI infrastructure","limit":10}}'

{
  "id": "…",
  "platform": "tiktok",
  "action": "search",
  "results": [
    {
      "id": "…",
      "text": "…",
      "author_username": "…"
    }
  ],
  "count": 10,
  "billing": {
    "charged": true,
    "charged_usd": 0.000556,
    "balance_after_usd": 12.340122
  }
}

Find supported tasks in the public catalogs

Use the catalogs to check supported tasks, inputs, prices, and availability. The compact EveryData catalog lists the essentials for each action; use the full catalog for optional parameters, limits, and response fields. Refresh prices and availability as needed rather than hard-coding them.

ProductCatalog endpointWhat it describes
EveryDataGET /api/v1/social/catalog?compact=1Platforms, actions, required parameters, delivery modes, availability, and prices
EverySearchGET /api/v1/search/toolsSearch tools, request parameters, tiers, and prices
EverySolveGET /api/v1/captcha/typesCAPTCHA types, parameters, solution shapes, availability, and prices
AI APIGET /api/v1/modelsModels the AI API currently accepts; no API key needed

Authentication

Send the API key as a Bearer token. Authentication runs before parameter validation, so a request without a valid key receives 401 rather than parameter feedback. Keep keys out of browser code, logs, and public repositories.

  • Create separate keys for separate environments or workloads.
  • Rotate a key from the console when its scope or exposure changes.
  • Use the console's restrictions when a key should be limited to specific products, capabilities, or IP ranges.
  • Use the same key with GET /api/v1/account to check your balance (paid, bonus, and total), this month's top-up discount, the per-minute request limit, and the last 24 hours of usage. Amounts are in USD. The call is read-only, free, and does not count toward the per-minute limit.
  • In that response, balance.total_usd is paid plus bonus balance, and calls draw on the bonus balance first. bonus_expiring lists time-limited bonus amounts that have not expired yet. rate_limit.requests_per_minute is shared by every key on the account, and usage_24h can lag by about a minute.
  • For account-wide history (daily usage, recent calls, billing, the wallet ledger), the same key can read the console API, for example GET /portal/api/requests/{request_id}, or GET /portal/api/quality for the success rate and latency of each capability. The key needs account read access; these reads are free and limited to 60 per minute per account. The full list is in the Account section of the OpenAPI spec.
  • To let an AI change the account too, grant write scopes under API Keys → Restrict access: manage keys, change settings, and open or reply to tickets. All three are off by default and only you can turn them on, signed in to the console. Through a key, at most 20 keys a day can be created, and tickets have no daily limit; viewing or rotating full keys, changing permissions or IP allowlists, re-enabling keys, and payments always stay in the console. The Account section of the OpenAPI spec lists the endpoints, for example POST /portal/api/keys/{key_id}/disable.
  • To avoid polling, add an HTTPS endpoint under Settings → Webhooks in the console. We send a signed POST when the balance falls to your threshold or an async job finishes. Verify X-EveryInfra-Signature, an HMAC-SHA256 of the timestamp, a period and the raw body made with your signing secret; reject timestamps more than 5 minutes off and de-duplicate on the event ID, since failed deliveries are retried with backoff, up to 7 attempts.

This key reaches all four products, sharing one wallet

One API key works like the key switch on a distribution board: turn it on and all four products are live, sharing one wallet. In the console (API Keys → Restrict access) you can switch a product off for a key; calls to a product that is off return 403 capability_denied. Disable the key and everything goes dark: calls return 401.

curl https://api.everyinfra.com/api/v1/account \
  -H "Authorization: Bearer YOUR_API_KEY"

POST /api/v1/social

EveryData

Collect data from 106 platforms with 573 supported actions. Choose a platform and action, then supply the inputs listed for that action.

GET /api/v1/social/catalog?compact=1

POST /api/v1/search

EverySearch

Choose from 17 tools to search the web and retrieve source text. Specify the tool identifier and pass its required inputs.

GET /api/v1/search/tools

POST /api/v1/captcha

EverySolve

Solve 52 CAPTCHA types through one endpoint. Set the type field and pass the required inputs. You are charged for successful solutions.

GET /api/v1/captcha/types

POST /api/v1/chat/completions

AI API

OpenAI-compatible chat/completions, free for accounts that have topped up. Use it to clean, classify, extract, and summarize the data you collect.

GET /api/v1/models

Validate request parameters

Unknown parameters return 422 with the supported parameter list and, when available, a nearest-name suggestion. Invalid enum values return the allowed values. Parameters are not silently ignored or replaced with defaults.

  • Use snake_case parameter names from the catalog.
  • Treat did_you_mean as a repair hint, not a successful fallback.
  • For multi-target inputs, review the catalog's billing and limit rules before sending an array.

API reference

All 106 platforms and 573 APIs, grouped by category. Open a platform for its overview. Open an API for its parameters, response fields and code samples.

E-commerce15 platforms · 58 APIs

AI API (free after a top-up)

The AI API is OpenAI-compatible chat/completions. Any account that has topped up calls it at no charge, without using its balance, to clean, deduplicate, classify, extract, and summarize the data it collects; the prompt sets the output format.

  • With the OpenAI SDK, set base_url to https://api.everyinfra.com/api/v1 and send your EveryInfra API key in the Authorization: Bearer header; a ?key= in the URL is rejected.
  • The chat endpoint is POST /api/v1/chat/completions, with OpenAI's request and response format.
  • There are two models: gemini-3.6-flash, the default, and the lighter gemini-flash-lite. GET /api/v1/models returns the same list and needs no key. A misspelled model returns 422 with the likely correct name.
  • Streaming is supported: send stream: true to receive SSE that ends with data: [DONE], and add stream_options.include_usage for token usage.
  • messages may total up to 45,000 characters; larger inputs return 422 input_too_large, so split them into smaller requests.
from openai import OpenAI
import os

client = OpenAI(base_url="https://api.everyinfra.com/api/v1",
                api_key=os.environ["EVERYINFRA_API_KEY"])
reply = client.chat.completions.create(
    model="gemini-3.6-flash",
    messages=[{"role": "user", "content": "Return JSON only: label this review's sentiment, topic and intent."}],
)
print(reply.choices[0].message.content)

Limits by total top-ups, across all keys on the account

Total top-upsRequests per minuteIn flight
Topped up, under $100505
$100 or more50050
$500 or more5,000500

Credit codes and bonus credit over $1 each count like top-ups; trial credit and amounts of $1 or less do not. An account that has never topped up or had a credit code or bonus credit over $1 gets 403 ai_topup_required. Tiers are upper limits.

StatusMeaning
403 ai_topup_requiredThe account has never topped up; any top-up enables the AI API.
429 rate_limitedThe per-minute limit was reached (per_minute_limit) or too many requests are in flight (concurrency_limit); wait for Retry-After, then retry.
503 ai_busyThe service is busy; retry after Retry-After.
403 ai_disabledThe AI API is paused for this account.
422 unknown_modelThe model does not exist; the message suggests the likely correct name.

The AI API is for organizing the data you collect with EveryInfra. If it is used for something else, or the calls look clearly abnormal, we may pause the AI API for that account; the account itself, its other APIs, and its balance are not affected.

MCP for AI agents

Use MCP when a compatible client should discover and call EveryInfra tools directly. The tools cover data, search, CAPTCHA, and AI chat through everyinfra_chat (free after a top-up, not streamed), and follow the same authentication, billing, limits, validation, and balance rules as the REST API.

  • Configure the remote server URL and an EveryInfra API key in the client.
  • Two endpoints take the same key: https://api.everyinfra.com/mcp lists 12 common tools (data, search, CAPTCHA, and AI chat, plus the balance, call records, the top-up link, and support tickets), and https://api.everyinfra.com/mcp/all lists all 24; the account-record and management tools below are listed only there.
  • The account tools now have verb-first names (for example, everyinfra_account is now everyinfra_get_account). The old names still work on both endpoints but are no longer listed, so scripts that call them need no change; to use these tools from an AI client, point the connector at /mcp/all.
  • Use capability discovery before a data, search, or CAPTCHA call.
  • Keep the API key in the client's secret or environment configuration.
  • Call the free everyinfra_get_account tool (no arguments) to check the balance, discount, per-minute limit, and recent usage; it returns the same summary as GET /api/v1/account.
  • After a data call with mode: "async", read the result with the free everyinfra_get_job tool and the returned job_id; it returns the same view as GET /api/v1/jobs/{job_id}.
  • For account records, the free tools everyinfra_get_usage, everyinfra_list_requests, everyinfra_get_billing, everyinfra_list_keys, and everyinfra_list_tickets return daily usage, recent calls (look one up by request_id to see how its charge settled), spend and the wallet ledger, the key list, and the support ticket list. They need account read access on the key: keys without product-line limits can read usage, calls, and billing by default; product-limited keys and ticket access are enabled under API Keys → Restrict access in the console.
  • When the account needs funds, everyinfra_get_topup_link returns the console top-up page; the account owner pays there, and the tool never creates a payment or charges anything.
  • When calls keep failing, data looks wrong, a top-up or charge needs checking, or you need a new platform or field, any key can open a ticket with human support through everyinfra_create_ticket; it is free and needs no extra permission. The tool returns the ticket number and a console link, and everyinfra_get_ticket then shows the ticket's progress and support's replies. Over REST, the same calls are POST /api/v1/support/tickets and GET /api/v1/support/tickets/{ticket_id}. The older everyinfra_ticket_create (needs a write scope) still works; new integrations should use everyinfra_create_ticket.
  • Once the account owner grants write scopes to the key in the console, an AI can also use everyinfra_create_key, everyinfra_update_key, everyinfra_disable_key, everyinfra_delete_key, everyinfra_update_settings, everyinfra_set_webhook, everyinfra_test_webhook, and everyinfra_reply_ticket. A key created this way is never broader than the calling key and never gets write scopes, console-created keys can only be disabled, and every change shows up in the console's notifications.

Endpoint

POST /mcp

Transport

Streamable HTTP, stateless

Tools

Tool names start with everyinfra_. Renamed tools still answer to their old names, so prompts and workflows keep working.

Use with IPFoxy proxies

A call to the EveryInfra API does not need a proxy. The request goes direct to api.everyinfra.com and returns JSON with named fields. Your own programs are different: when your crawler or browser automation must open a page as a user in a given country, it needs an exit IP in that country.

So the split is simple. IPFoxy gives your own requests a different exit IP. EveryInfra gives you structured data for the platforms in its catalog.

TaskUse
Open pages that change by country (local price, delivery, ad placements), or sign in to your own store and accountsAn IPFoxy proxy + your crawler or browser
Collect sites or fields that are not in the data API catalogAn IPFoxy proxy + your crawler
Get catalog platform data in bulk for a sheet or a databaseThe EveryInfra data API, direct, with no proxy

This Python example does both steps in one script. Step 1 calls ipinfo.io through the IPFoxy exit IP and prints the exit country. Step 2 calls EveryInfra direct for one Amazon product. Before you run it, set two environment variables: EVERYINFRA_API_KEY is your API key, and IPFOXY_PROXY is the connection string from the IPFoxy dashboard, in the form http://username:password@host:port. Install requests with pip install requests.

import os

import requests

EVERYINFRA_API_KEY = os.environ["EVERYINFRA_API_KEY"]
IPFOXY_PROXY = os.environ["IPFOXY_PROXY"]  # http://username:password@host:port
PROXIES = {"http": IPFOXY_PROXY, "https": IPFOXY_PROXY}

# 1. Your own request goes out through the IPFoxy exit IP.
exit_ip = requests.get("https://ipinfo.io/json", proxies=PROXIES, timeout=30).json()
print("Exit IP country:", exit_ip.get("country"))

# 2. The EveryInfra call goes direct. It does not need a proxy.
direct = requests.Session()
direct.trust_env = False  # ignore HTTP(S)_PROXY, so this call uses no proxy traffic
resp = direct.post(
    "https://api.everyinfra.com/api/v1/social",
    headers={"Authorization": f"Bearer {EVERYINFRA_API_KEY}"},
    json={
        "platform": "amazon",
        "action": "profile",
        "params": {"url": "https://www.amazon.com/dp/B0CYJDVT31"},
    },
    timeout=120,
)
resp.raise_for_status()
body = resp.json()
item = body["results"]
print(item["title"][:60], item["currency"], item["price"], item["rating"])
print("Charged USD:", body["billing"]["charged_usd"])
  • direct.trust_env = False makes the EveryInfra call ignore the HTTP_PROXY and HTTPS_PROXY environment variables. Without it, a system-wide proxy also carries this call, and you pay proxy traffic for it.
  • A 407 from the proxy means the username or password is wrong. The example stops before it calls EveryInfra, so nothing is charged. The IPFoxy help center says the proxy works only when you run the code from a network outside mainland China.
  • We ran this code on October 24, 2026. The EveryInfra call returned the product title, price and rating, and it was charged $0.001389. We do not have an IPFoxy account, so we tested the proxy step with a local mock proxy: the address format, the CONNECT tunnel and the 407 case.
  • How much proxy traffic one page uses: about 0.44 MB for HTML only and about 7.96 MB for a full browser load. For the cost per 1,000 pages at each IPFoxy plan and the success rate you need, read How Much Proxy Traffic Does an Amazon Page Use?.
  • The full example, the local mock proxy and the byte-measurement script are on GitHub: everyinfra-agent-plugins / examples / proxy-plus-data-api.

Referral disclosure: the "Visit IPFoxy" link below is a referral link that IPFoxy gave us, with our referral code. If you sign up or buy through it, IPFoxy may pay us a commission. IPFoxy is our partner.

Visit IPFoxy IPFoxy products and prices are on our partner page.

Use with Exa search

Exa searches the web by meaning. Your query does not need the words that are on the page: Exa still finds the right companies, articles and papers, and returns their text with the results. EveryInfra gives you structured platform data, such as G2 and Trustpilot ratings and reviews or YouTube comments, as JSON with named fields.

A common pattern: use Exa to list a set of things, then use EveryInfra to add platform data to each one.

TaskUse
Find a set of companies, articles or papers by meaning, with their textExa
Ratings, review counts and review text for a known product on G2 or TrustpilotThe EveryInfra g2 and trustpilot APIs
Comments and like counts under a YouTube videoThe EveryInfra youtube API (Exa returns a video's transcript text, but no comments)

This Python example builds a competitor review table. Step 1 asks Exa for "note-taking apps similar to Obsidian"; category: "company" makes it return company home pages only. Step 2 calls the EveryInfra g2/search API for each company and reads its G2 rating and review count. Before you run it, set two environment variables: EXA_API_KEY is your key from the Exa dashboard, and EVERYINFRA_API_KEY is your EveryInfra API key. You need pip install requests.

import os
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import urlsplit

import requests

EXA_API_KEY = os.environ["EXA_API_KEY"]
EVERYINFRA_API_KEY = os.environ["EVERYINFRA_API_KEY"]
QUESTION = "note-taking apps similar to Obsidian"

# 1. Exa: find companies by meaning, not by keyword
companies = requests.post(
    "https://api.exa.ai/search",
    headers={"x-api-key": EXA_API_KEY},
    json={"query": QUESTION, "category": "company", "type": "auto", "numResults": 10},
    timeout=60,
).json()["results"]

# 2. EveryInfra: each company's G2 rating and review count
def g2_rating(company):
    name = company["title"].split(" - ")[0].split(" | ")[0].strip()
    resp = requests.post(
        "https://api.everyinfra.com/api/v1/social",
        headers={"Authorization": f"Bearer {EVERYINFRA_API_KEY}"},
        json={"platform": "g2", "action": "search", "params": {"keyword": name}},
        timeout=180,
    )
    resp.raise_for_status()
    body = resp.json()
    match = next((p for p in body["results"] if p["product_name"].lower() == name.lower()), None)
    return name, match, body["billing"]["charged_usd"]

with ThreadPoolExecutor(max_workers=4) as pool:
    rows = list(pool.map(g2_rating, companies))

spent = 0.0
for company, (name, g2, charged) in zip(companies, rows):
    spent += charged
    domain = urlsplit(company["url"]).hostname.removeprefix("www.")
    if g2 and g2["review_count"]:
        print(f"{name:12} {domain:16} G2 {g2['rating']} / 5 · {g2['review_count']} reviews")
    else:
        print(f"{name:12} {domain:16} no G2 reviews yet")
print("EveryInfra charged (USD):", round(spent, 6))
  • We ran this code as written on October 25, 2026. Exa returned 10 company home pages, and the same 10 again when we searched a few minutes later. 7 of the 10 have G2 ratings and reviews, for example Goodnotes at 4.7 with 123 reviews and Milanote at 4.5 with 42. We ran the English, Chinese and Spanish versions once each; each run took 44–51 seconds. EveryInfra charged $0.01389 (10 g2/search calls); the Exa search cost $0.007.
  • A company counts as a match only when its name is identical to the G2 product name. The example takes the Exa result title and drops everything after " - ". In our run, G2 had no product named Brainio, and Yaranga and Brainfo have G2 pages but no reviews yet.
  • Each g2/search call is billed once ($0.001389), also when no product has the same name, because the API still returns search results. One call takes about 30–70 seconds, so the example runs 4 calls at a time.
  • For Trustpilot, change step 2 to trustpilot/profile and put the company domain in company. For the same companies, 4 of 7 had a Trustpilot profile. A company with no profile returns an empty result and is not billed.
  • Exa's results contain no Reddit threads: with includeDomains set to reddit.com it returned 0 results, at no cost.
  • For coverage across 3 categories and 30 companies, the big names that exact-name matching misses, and the full data, read Exa Finds the Competitors, EveryInfra Checks Their Reviews.

EveryInfra and Exa are partners. The "Visit Exa" link below is a plain link with no referral code.

Visit Exa Exa products and prices are on our partner page.

Use with Monid

Monid is a tool router for AI agents. The agent describes what it needs in one sentence: discover returns fitting endpoints and their prices for free, inspect returns the input schema and the current price for free, and only run is billed, at that price, from one prepaid balance. EveryInfra gives you fixed platform data APIs: one request shape, and fixed field names and a fixed price for each capability.

A common split is by how often a call repeats. Platforms in the EveryInfra catalog (106 on November 3, 2026; GET /api/v1/social/catalog has the current list) go to EveryInfra. Platforms that are not in the catalog, and tools that are not data at all (weather, geocoding, company logos, image generation), go to Monid.

TaskUse
Platform data that you collect every day, for example Xiaohongshu search, Amazon products or YouTube commentsThe EveryInfra API or the MCP tool everyinfra_call_api; the catalog lists the platforms
A platform that is not in the EveryInfra catalog, or a tool that you need only now and thenMonid: discover to find an endpoint, inspect to read the price, then run
You do not know yet which tool to useMonid discover (free; returns ranked candidates with their prices)

This Python example puts both kinds of call in one script. Step 1 is the daily job: it calls EveryInfra xiaohongshu/search for "matcha latte", sorted by most likes, and prints the top 3 notes and the charge. Step 2 is a one-off job: Monid finds a tool that returns a company logo from a domain, and the script runs it only if the price from inspect is not more than MAX_PRICE_USD. Before you run it, set two environment variables: EVERYINFRA_API_KEY is your EveryInfra API key, and MONID_API_KEY is an API key that you create in the Monid dashboard (app.monid.ai). You need pip install requests.

import os

import requests

EVERYINFRA_API_KEY = os.environ["EVERYINFRA_API_KEY"]
MONID_API_KEY = os.environ["MONID_API_KEY"]
MONID = "https://api.monid.ai/v1"
MONID_HEADERS = {"Authorization": f"Bearer {MONID_API_KEY}"}
MAX_PRICE_USD = 0.01  # do not run a Monid tool that costs more than this per call

# 1. The daily job: EveryInfra xiaohongshu/search, one fixed request shape
resp = requests.post(
    "https://api.everyinfra.com/api/v1/social",
    headers={"Authorization": f"Bearer {EVERYINFRA_API_KEY}"},
    json={"platform": "xiaohongshu", "action": "search",
          "params": {"keyword": "matcha latte", "sort": "most_liked"}},
    timeout=120,
)
resp.raise_for_status()
body = resp.json()
for note in body["results"][:3]:
    print(note["like_count"], note["collect_count"], note["posted_at"][:10], note["url"])
print("EveryInfra:", len(body["results"]), "notes, charged (USD):", body["billing"]["charged_usd"])

# 2. A one-off lookup that is not a daily platform: discover, inspect, run on Monid
found = requests.post(f"{MONID}/discover", headers=MONID_HEADERS, timeout=60,
                      json={"query": "company logo image URL from a domain", "limit": 3}).json()["results"]
# discover adds ranking and price fields to each result; inspect and run take only the fields that name the tool
SHOWN_ONLY = ("providerName", "description", "price", "score", "scoreBreakdown", "tags", "metrics", "hints")
tool = {key: value for key, value in found[0].items() if key not in SHOWN_ONLY}
detail = requests.post(f"{MONID}/inspect", headers=MONID_HEADERS, timeout=60, json=tool).json()
price = detail["price"]["amount"]["value"]
print("Monid tool:", detail["endpoint"], "price (USD):", price)
if price <= MAX_PRICE_USD:
    run = requests.post(f"{MONID}/run", headers=MONID_HEADERS, timeout=120,
                        json={**tool, "input": {"pathParams": {"company": "starbucks.com"}}}).json()
    print("Monid run:", run.get("runId"), run.get("status"), run.get("output"))
  • We ran this code as written on November 3, 2026 at 16:45 (Singapore time). EveryInfra returned 20 notes and charged $0.005556. Monid discover ranked a company-logo endpoint first, inspect showed $0 per call, and run returned the status COMPLETED and the logo image URL. The script took 6–7 seconds. We ran the Chinese, English and Spanish versions once each (the Chinese version searches the Chinese name of the drink).
  • Each xiaohongshu/search call returns one page of up to 20 notes and is billed $0.005556. A page with no notes is not billed. For the next page, send back the next_page_token from the results.
  • Monid does not charge for discover and inspect; only run is billed, at the price that inspect shows. While a run is in progress, Monid holds the estimated cost on the balance and settles the actual amount when the run ends (Monid llms.txt, read 2026-11-03). The example uses MAX_PRICE_USD to skip tools that cost more than your budget.
  • You can give the agent a routing rule like this: "Platforms in GET https://api.everyinfra.com/api/v1/social/catalog go to everyinfra_call_api. All other platforms and tools go through Monid: discover, then inspect, and run only if the price is within budget. Log the charge of every call."
  • Monid's MCP server (https://mcp.monid.ai/v1) needs an OAuth sign-in in the browser, and we did not test it. The setup steps for Claude, Claude Code, Codex, OpenCode and ChatGPT are in the [Monid MCP quickstart](https://monid.ai/docs/guide/quickstart-mcp). For the EveryInfra side, see the MCP section above.

EveryInfra and Monid are partners. The "Visit Monid" link below is a plain link with no referral code.

Visit Monid Monid products and billing are on our partner page.

Understand charges and balance adjustments

Check the public catalog for the price and billing unit of the capability you need. Each response records the amount charged. For products billed on successful delivery, failed or empty results are not charged.

  • Do not convert internal wallet units into currency in your client.
  • Display the currency and amounts returned by the API, and use them to reconcile charges.
  • When a delivery-based operation does not complete, no final charge remains and any reserved amount returns to the account balance automatically.
  • Each paid response's billing object includes charged_usd, the amount charged for that call in USD (0 when nothing was charged, null while the outcome is still unknown), and balance_after_usd, the wallet balance once the call settles (null if it cannot be read). Watch balance_after_usd during a batch instead of polling the account.
  • When a failed call's reserved amount has been returned, the error body's billing also carries balance_after_usd.

Error handling

Read the HTTP status and error body together. Every error also says whose problem it is and what to do next: fault (request, account or service), retryable and next_steps. When the problem is on EveryInfra's side and the retries are used up, support carries a ticket draft; ask the user before opening it. Before retrying, check what failed and whether repeating the request could duplicate an action.

StatusMeaningAction
400Unknown platform or actionUse did_you_mean and allowed from the response, or the capability catalog.
401Missing, invalid, or disabled API keyCheck the Bearer token and key status.
402Insufficient wallet balanceCheck the current balance with GET /api/v1/account, then fund the account or reduce the request scope.
404Unknown route or resourceCheck the endpoint and resource identifier.
422Invalid parameter, value, or typeRead supported values and did_you_mean from the response.
429Rate limit reachedWait for Retry-After before retrying. The limit is per account, with all API keys counted together; a key can also have its own lower limit.
5xxThe request could not be deliveredRecord the request ID and follow next_steps. For timeout (timeout), retry the same request with "mode":"async" to receive a job_id instead of waiting.

Do catalog endpoints require an API key?

No. Public capability catalogs can be read before registration. Authenticated calls still require a valid Bearer API key.

Where does the data come from, and do you have the platforms' permission?

EveryInfra returns content that is publicly visible on each platform, such as public posts, comments, product pages and profiles. You do not register a developer app with the platform or sign in with a platform account. We are not a partner of these platforms, we do not represent them, and we do not get their permission on your behalf. How you use the data is up to you: make sure your use complies with applicable law and the platform's terms (see sections 1 and 4 of the [Terms of Service](/en/terms)). Publicly visible does not mean free to copy, republish or use commercially.

Are MCP and REST separate products?

No. MCP is another way to access the currently discovered EveryInfra tools. Data, search, CAPTCHA, and AI chat reuse the corresponding REST authentication, billing, validation, rate-limit, and balance-adjustment rules.

Is the AI API free?

Yes. Any account that has topped up can call it without using its balance. Limits follow total top-ups: 50 requests per minute and up to 5 at once below $100; 500 and 50 from $100; 5,000 and 500 from $500; credit codes and bonus credit over $1 each count like top-ups, but trial credit and amounts of $1 or less do not.

How do I check my balance from code?

Call GET /api/v1/account with the same Bearer API key. It returns your paid, bonus, and total balance in USD, this month's top-up discount, the per-minute request limit, and the last 24 hours of usage, without charging or counting toward the limit. Every paid response also includes billing.balance_after_usd.

Can an unsupported parameter be ignored?

No. Unknown parameters return 422 with supported values and a nearest-name suggestion when one can be determined.

How should I send a large batch of requests?

Use async mode: add "mode": "async" to the request body. Each call returns a job_id at once, and you poll GET /api/v1/jobs/{job_id} for the result. A synchronous call must finish within 85 seconds or it fails with a timeout (not charged); an async job is not bound by that limit.