> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the EveryInfra MCP server

The EveryInfra MCP connector routes your AI agent's tool calls to EveryInfra's own MCP server through Scalekit. Each user connects their own EveryInfra access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 12 tools.

**Authentication:** Bearer Token
**Categories:** Search, Analytics
**Tools:** 12: 7 read, 1 write, 4 destructive
**Users sign in with:** Access token
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=EVERYINFRAMCP)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the EveryInfra MCP connection

   In **AgentKit > Connections**, create an EveryInfra MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

   **Console steps with screenshots:**

   Register your EveryInfra API key with Scalekit so it can authenticate requests to the EveryInfra MCP server on behalf of your users. EveryInfra MCP uses API key authentication.

   1. ### Get an EveryInfra API key

      - Sign in to the EveryInfra console. The first time you sign in, EveryInfra creates a key for you and shows it in a **Full API Key** dialog.
      - Copy the key. It starts with `ei_`.
      - Click **Copy key**, then **Close and clear**.

        > Image: EveryInfra Full API Key dialog showing the new key, the balance notice, and the Copy key button

      > tip: Need the key again?
      >
      > You can reveal and copy the key again later from **API Key management** in the EveryInfra console. To create another key, add one there.

      > caution: Add balance before your first call
      >
      > A new account starts with a $0 balance, and EveryInfra rejects calls until you add funds. In the same dialog, claim the $1 trial by starring EveryInfra on GitHub, or click **Top up $10**.

   2. ### Create a connection in Scalekit

      - In the [Scalekit dashboard](https://app.scalekit.com), go to **AgentKit** → **Connections** → **Create Connection**.
      - Search for **EveryInfra MCP** and click **Create**.
      - Note the **Connection name** — use this as `connection_name` in your code (e.g., `everyinframcp`).

   3. ### Add a connected account

      Connected accounts link a specific user identifier in your system to an EveryInfra API key. Add one in the dashboard to test. In production, each user adds their own through the authorization link: they enter their credentials on the page it opens.

      **In the dashboard, to test**

      - Open the connection and click the **Connected Accounts** tab → **Add account**.
      - Fill in **Your User's ID** and **API Key**, then click **Save**.

      **From your backend, if your app already has the credentials**

      For example, when users enter them on a settings page in your app:

        **Node.js**

        ```typescript
        import { ConnectorStatus } from '@scalekit-sdk/node'

        const authorizationDetails = {
          details: {
            case: 'staticAuth',
            value: { details: { token: 'ei_...' } },
          },
        };

        let { connectedAccount } = await scalekit.actions.upsertConnectedAccount({
          connectionName: 'everyinframcp',
          identifier: 'user_123',
          authorizationDetails,
        });

        // Make sure the account is ACTIVE before the first tool call.
        if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
          ({ connectedAccount } = await scalekit.actions.upsertConnectedAccount({
            connectionName: 'everyinframcp',
            identifier: 'user_123',
            authorizationDetails,
          }));
        }
        ```

        **Python**

        ```python
        authorization_details = {"static_auth": {"token": "ei_..."}}

        response = scalekit_client.actions.upsert_connected_account(
            connection_name="everyinframcp",
            identifier="user_123",
            authorization_details=authorization_details,
        )

        # Make sure the account is ACTIVE before the first tool call.
        if response.connected_account.status != "ACTIVE":
            response = scalekit_client.actions.upsert_connected_account(
                connection_name="everyinframcp",
                identifier="user_123",
                authorization_details=authorization_details,
            )
        ```

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'everyinframcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize EveryInfra MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'everyinframcp_everyinfra_get_account',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "everyinframcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize EveryInfra MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="everyinframcp_everyinfra_get_account",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their EveryInfra MCP server credentials there. If your app already has a user's credentials, add the account from your backend instead, as the console steps above show. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'everyinframcp_everyinfra_get_account',
  toolInput: {},
  connector: 'everyinframcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="everyinframcp_everyinfra_get_account",
    tool_input={},
    connection_name="everyinframcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `everyinframcp_everyinfra_get_account`

Check account balance and limits · Read-only

Read the account behind this API key. Free, read-only, any key works. Returns:
- balance: total_usd, paid_usd, bonus_usd and bonus_expiring (amount_usd, expires_at)
- discount: this month's top-ups (month_topup_usd), the rate in effect and next (rate, threshold_usd, gap_usd = how much more to top up this month for it)
- rate_limit: requests_per_minute for all keys combined, key_requests_per_minute, and any rate package with its expires_at
- key: this key's id, name, prefix, created_at and expires_at
- usage_24h: calls, succeeded, failed and spent_usd in the last 24 hours (this_key: the same for this key)
Check the balance before a batch of paid calls; every paid call's billing also carries balance_after_usd.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `everyinframcp_everyinfra_get_job`

Get an async job · Read-only

Read a job submitted with everyinfra_call_api(mode=async). Free; it does not count against the per-minute limit. While status is submitting / running / finalizing, check again later; succeeded: the rows are in results (paged actions also return next_page_token); failed: see error.reason and error.charged; submit_unknown: the submission is still being confirmed — do not resubmit, follow next_action. Only jobs submitted with the same API key are visible.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `job_id` (`string`, required): The job_id returned by an async everyinfra_call_api

Example input: `{"job_id":"<job_id>"}`

### `everyinframcp_everyinfra_get_ticket`

Check a support ticket · Read-only

Read one support ticket: its status, what happens next, and its latest 100 messages, including support's replies. Use it after everyinfra_create_ticket to check progress, or when the user asks whether support has answered. Pass ticket_id as a plain integer (the number shown as #N, without the #). The key that opened a ticket can always read it; reading the account's other tickets (opened in the console or with other keys) needs the account read permission "support:read" on this key. Any other number returns ticket_not_found. Free; the same result as GET /api/v1/support/tickets/{ticket_id}.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `ticket_id` (`integer`, required): The ticket_id everyinfra_create_ticket returned (#N in the console and emails)

Example input: `{"ticket_id":1}`

### `everyinframcp_everyinfra_get_topup_link`

Top-up link · Read-only

Returns the console top-up page link (url) and the current balance (balance_usd). Use it when a call fails with quota_exhausted or ai_topup_required, or when the user asks how to add funds. The account owner pays in the console; this tool creates no order and charges nothing. Any key can use it; accounts whose service provider handles top-ups get topup_unavailable. Free.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `everyinframcp_everyinfra_list_capabilities`

List data capabilities · Read-only

List EveryInfra's data platforms and capabilities (106 platforms / 573 capabilities: search, detail, comments, profiles and more). Use it before everyinfra_call_api to get the platform/action, required and optional params, the per-call row limit (max_limit, or page_size for page-based actions) and the price. Pass a platform to also get allowed values, returned fields and what they mean. Free. Data collection only — for AI chat use everyinfra_chat.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `platform` (`string`, optional): Optional; only this platform's capabilities, e.g. xiaohongshu / twitter / tiktok

Example input: `{}`

### `everyinframcp_everyinfra_list_captcha_types`

List CAPTCHA types · Read-only

List the 52 CAPTCHA and bot-challenge types EveryInfra solves. **Call it before everyinfra_solve_captcha** to get three things: the type name, the required/optional params, and **the shape of the solution** (token / cookie / text / number / fields / points / boxes / tokens / indices — a string to submit, coordinates to click yourself, or grid cells to click: each is used differently). Free.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `type` (`string`, optional): Optional; only this type, e.g. turnstile / recaptcha_v2 / cloudflare_challenge

Example input: `{}`

### `everyinframcp_everyinfra_list_requests`

Calls and refunds · Read-only

The account's call records, newest first: request_id, capability, status code, latency, rows returned, whether it was charged, and the amount. Pass request_id (the request_id / X-Request-Id of any call) to look up one call, including its charge's final state (charged, refunded or partly refunded) and any async job it started. failed_only=true lists failures only. Needs the account read permission "requests:read" on this key: keys not limited to product lines have the three read permissions by default; for a key limited to product lines, the account owner turns it on in the console (API Keys → permissions). Free.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `failed_only` (`boolean`, optional): List failed calls only, default false
- `limit` (`integer`, optional): Rows, default 20
- `offset` (`integer`, optional): Rows to skip, default 0
- `request_id` (`string`, optional): Look up one call; the other params are ignored when given

Example input: `{}`

### `everyinframcp_everyinfra_create_ticket`

Contact human support · Write

Open a ticket with EveryInfra's human support team and get back the ticket number and a link the account owner can open. Use it when calls keep failing or return wrong or missing data, for top-up, charge or refund questions, or to ask for a new platform, capability or field. Put one line in subject; in description say what you called (platform/action or endpoint), when (UTC), the error code and message and what you expected, and pass that call's request_id (and job_id for an async job); write other IDs with a label such as job_id: job_..., because a bare long ID reads as a secret. Never include API keys or passwords. Ask the user first and open it only if they agree. Errors whose fault is request or account need a fixed request or the user, not a ticket; an error's support field carries a ready draft. Any key on the account works and nothing is charged. Retrying the same request returns the same ticket, and the same capability and error code within 24 hours goes into that ticket. Human support is online 24/7, with a first reply within 10 minutes on average. Replies arrive in the ticket and the account owner also gets an email. Check progress and read support's replies with everyinfra_get_ticket (REST: GET /api/v1/support/tickets/{ticket_id}) using the same key, or at the returned link.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `description` (`string`, required): What you called, when (UTC), the error code and message, what you expected; no API keys or passwords
- `subject` (`string`, required): One line, e.g. "douyin/comments returns 503 since 10:20 UTC"
- `category` (`string`, optional): Optional: incident (looks like an outage), integration (a call returns an error; parameters, auth, SDK or MCP setup), product (questions about data, platforms and fields, or asking for new ones), billing (top-ups, charges, refunds), order (resources such as proxies or numbers), general. One of: `general`, `product`, `integration`, `billing`, `order`, `incident`.
- `contact_email` (`string`, optional): Optional extra address for support to reach you; reply emails still go to the account's verified email
- `idempotency_key` (`string`, optional): Optional; keep it when retrying. Without it, the same subject and description sent again within 24 hours return the same ticket
- `job_id` (`string`, optional): The job_id of the async job this ticket is about
- `request_id` (`string`, optional): The request_id (X-Request-Id) of the call this ticket is about

Example input: `{"description":"<description>","subject":"douyin/comments returns 503 since 10:20 UTC"}`

### `everyinframcp_everyinfra_call_api`

Call a data capability · Destructive

Call any EveryInfra data capability and get structured JSON. Priced per platform tier USD 0.56/1K–USD 5.56/1K; failed calls and empty results leave no final charge (anything reserved is restored). Most actions return up to `limit` rows in one call, billed once; multi-target arrays (urls, targets, usernames, tickers) are billed per element, and actions with rows_per_unit per block of rows asked for. Page-based actions (page_size in the catalog) return one page per call, of a fixed size unless page_size_varies (then a short page is not the end); for more, pass the response's top-level next_page_token (some actions repeat it on each row) as page_token — each page is one call. Check platform/action, required params and max_limit or page_size with everyinfra_list_capabilities first. For slow tasks or large limits pass mode=async: you get a job_id at once; read the result with everyinfra_get_job (free).

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `action` (`string`, required): e.g. search / profile / user_posts / post
- `platform` (`string`, required): e.g. xiaohongshu / twitter / tiktok / web
- `mode` (`string`, optional): sync (default) waits for the result; async returns a job_id at once for slow tasks or large limits — read it with everyinfra_get_job. One of: `sync`, `async`. Default: `sync`.
- `params` (`object`, optional): The capability's params, e.g. {"keyword":"AI tools","limit":20}

Example input: `{"action":"<action>","platform":"<platform>"}`

### `everyinframcp_everyinfra_chat`

Generate or analyze text · Destructive

EveryInfra's OpenAI-compatible text completions with multi-turn history and any input content or format. Free for accounts that have topped up (nothing is deducted); accounts that have not get ai_topup_required. Rate-limited per account by cumulative top-ups (under $100: 50 requests/minute, $100 or more: 500, $500 or more: 5,000, all keys combined); current models: GET /api/v1/models. Good for cleaning collected data: summaries, translation, sentiment labels, topic classification and structured extraction. messages may total up to 45,000 characters; beyond that you get input_too_large — split long documents into several calls.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `messages` (`array`, required): OpenAI-format conversation, e.g. [{"role":"user","content":"Hello"}] (role is system / user / assistant).
- `model` (`string`, optional): Optional, default gemini-3.6-flash. Allowed: gemini-3.6-flash / gemini-flash-lite

Example input: `{"messages":[]}`

### `everyinframcp_everyinfra_search`

Search and retrieve sources · Destructive

Search and retrieve sources. 17 tools, chosen with `tool`:
  crawl: Crawl several pages of a site and return their text; say in plain language which pages you want.
  crosscheck: Run one question through several retrieval chains with different mechanisms, rank sources by how many mechanisms found them, and fetch the original text of the top tier. It answers how far a claim can be trusted, not just what was found.
  deep: Deep search with text excerpts; full=true also returns the full text.
  forum: Real people's discussions — an evidence source independent of official docs (when docs say 'supported' and forums describe where it breaks, trust the specific scenario).
  harvest: Structured site extraction (long-running: tens of seconds to minutes); use it only when crawl cannot get the data.
  lens: Reverse image search: give an image URL, find pages that use it (the opposite direction of media).
  map: List a site's page structure — URLs only, no text, fast.
  media: Find images and videos by keyword.
  news: News search.
  places: Places and businesses search.
  read: Fetch the text of a given URL; it retries other fetch paths automatically when one fails.
  scholar: Academic literature search; kind=patents switches to patents (publication number, applicant, inventor, filing and publication dates).
  semantic: Semantic search: describe what you want in one sentence instead of stacking keywords; it finds deep sources whose titles do not contain your words. mode=deep searches deeper (slower, costs more).
  shopping: Product search and price comparison.
  similar: Give a URL, find semantically similar pages — something keyword search cannot do.
  suggest: Search suggestions (autocomplete).
  web: General web search with site restriction, region, time window and paging.
⚠ To **assert a specific fact** (a version, a price, whether an API exists), use crosscheck: it returns verifiable sources and their agreement tier. Failed or empty searches leave no final charge (anything reserved is restored).

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `tool` (`string`, required): Retrieval tool. One of: `crawl`, `crosscheck`, `deep`, `forum`, `harvest`, `lens`, `map`, `media`, `news`, `places`, `read`, `scholar`, `semantic`, `shopping`, `similar`, `suggest`, `web`.
- `params` (`object`, optional): The tool's params, e.g. {"q":"EU AI Act","num":10}

Example input: `{"tool":"crawl"}`

### `everyinframcp_everyinfra_solve_captcha`

Solve a CAPTCHA · Destructive

Solve a CAPTCHA or bot challenge and get a ready-to-use solution. USD 0.000139/call–0.004583/call, **charged per successful solve (castle: per token, × count); failed or empty attempts leave no final charge (anything reserved is restored)**. Use it when a target site is blocked by Turnstile / reCAPTCHA / hCaptcha / a Cloudflare challenge page / GeeTest and the like. Params differ per type — check them with everyinfra_list_captcha_types first.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `type` (`string`, required): CAPTCHA type, e.g. turnstile / recaptcha_v2 / image. One of: `akamai_bmp`, `akamai_sec_cpt`, `akamai_web`, `alibaba`, `altcha`, `anubis`, `atb_captcha`, `audio`, `aws_waf`, `aws_waf_classify`, `basilisk`, `binance`, `botdeflector`, `bounding_box`, `captchafox`, `capy`, `castle`, `cloudflare_challenge`, `coordinates`, `cutcaptcha`, `cybersiara`, `datadome`, `datadome_interstitial`, `f5_shape`, `f5_tspd`, `friendly_captcha`, `funcaptcha`, `geetest`, `hcaptcha`, `hunt`, `image`, `imperva`, `kasada`, `kasada_cd`, `lemin`, `mtcaptcha`, `perimeterx`, `prosopo`, `recaptcha_grid`, `recaptcha_v2`, `recaptcha_v2_enterprise`, `recaptcha_v3`, `recaptcha_v3_enterprise`, `rotate`, `shein`, `slider`, `temu`, `tencent_tendi`, `text_captcha`, `turnstile`, `yandex_smartcaptcha`, `yidun`.
- `params` (`object`, optional): Params for that type, e.g. {"website_url":"https://…","website_key":"0x…"}. ⚠ A few types need your own proxy: they deliver a cookie bound to the IP the challenge was solved from, so a solution from our exit IP would not work for you

Example input: `{"type":"akamai_bmp"}`

## Related

Other Search connectors ([all 89](/agentkit/connectors/?category=search)):

- [Supadata](/agentkit/connectors/supadata/): Scalekit connector, API key, 21 tools
- [Exa](/agentkit/connectors/exa/): Scalekit connector, API key, 21 tools
- [Brave Search](/agentkit/connectors/brave/): Scalekit connector, API key, 18 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
