SerpKite

npx add-mcp 'https://api.serpkite.com/v1/mcp'

SerpKite runs a remote Model Context Protocol server. Any MCP client that speaks streamable HTTP can connect to it and call Google search, News, Maps, Scholar, a page fetcher and more as tools. There is nothing to install or host.

URL	https://api.serpkite.com/v1/mcp
Transport	Streamable HTTP (stateless)
Auth	OAuth 2.1 sign-in, or Authorization: Bearer skt_live_…
Protocol versions	2025-06-18, 2025-03-26, 2024-11-05
Billing	Same credits as the REST endpoints

Clients that support MCP OAuth (Claude and ChatGPT connectors, Claude Code) only need the URL: they open a SerpKite sign-in page and you approve the connection. Everywhere else, send an API key in the Authorization header.

Claude (custom connector)

In Claude on the web or desktop, open Settings → Connectors → Add custom connector, name it SerpKite and enter https://api.serpkite.com/v1/mcp. Leave the OAuth client fields empty. Claude opens a SerpKite page: sign in, check that the page names Claude and claude.ai, and click Approve. The SerpKite tools then appear in the connector menu of a chat.

On Team and Enterprise plans an owner adds the connector once under Organization settings → Connectors, and each member connects their own SerpKite account.

Get a key

For clients that use an API key, create one in the dashboard under API keys (see API keys). For MCP use, a dedicated key with a monthly credit limit is a good idea: an agent in a loop can make many calls, and the limit caps what that key can spend. The examples below read the key from the SERPKITE_API_KEY environment variable.

Claude Code

One command adds the server to Claude Code:

claude mcp add --transport http serpkite https://api.serpkite.com/v1/mcp

Then run /mcp in Claude Code, pick serpkite and choose Authenticate: your browser opens the SerpKite approval page. To use an API key instead of OAuth, add --header "Authorization: Bearer $SERPKITE_API_KEY" to the command.

Run claude mcp list to check the connection, then ask Claude something that needs fresh results (“what changed in the latest Go release?”). Add --scope project to write the config to .mcp.json so your whole team gets it, but keep any key out of version control.

Claude Desktop with a config file

Claude Desktop launches local (stdio) servers from claude_desktop_config.json. To reach a remote server with a custom header, use the mcp-remote bridge, which runs through npx:

{
  "mcpServers": {
    "serpkite": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.serpkite.com/v1/mcp",
        "--header",
        "Authorization: Bearer ${SERPKITE_API_KEY}"
      ],
      "env": {
        "SERPKITE_API_KEY": "skt_live_..."
      }
    }
  }
}

The file lives at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS and %APPDATA%\Claude\claude_desktop_config.json on Windows. Restart Claude Desktop after editing it. You need Node.js installed for npx.

A custom connector needs no config file, no Node.js and no key, so prefer it where your plan offers one.

Cursor

Add the server to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "serpkite": {
      "url": "https://api.serpkite.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SERPKITE_API_KEY}"
      }
    }
  }
}

Open Cursor Settings → MCP to check that the server is green and its tools are listed. If your Cursor version doesn’t expand ${env:…}, paste the key directly and keep the file out of git.

VS Code

VS Code (Copilot agent mode) reads .vscode/mcp.json. The inputs block prompts for the key once and stores it securely, so it never lands in the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "serpkite-key",
      "description": "SerpKite API key",
      "password": true
    }
  ],
  "servers": {
    "serpkite": {
      "type": "http",
      "url": "https://api.serpkite.com/v1/mcp",
      "headers": {
        "Authorization": "Bearer ${input:serpkite-key}"
      }
    }
  }
}

Start the server from the MCP: List Servers command, then pick the SerpKite tools in the agent tool picker.

ChatGPT

ChatGPT can connect remote MCP servers as connectors when developer mode is enabled for your workspace. Create a connector with the URL https://api.serpkite.com/v1/mcp and OAuth authentication; ChatGPT registers itself and sends you to the SerpKite approval page. For OpenAI models in your own code, use the tool calling guide instead, or the OpenAI Agents SDK, which accepts MCP server headers.

Other clients

Any client that supports streamable HTTP with custom headers works with the same two values: the URL and the Authorization header. Clients that only support stdio can use npx -y mcp-remote https://api.serpkite.com/v1/mcp --header "Authorization: Bearer …" as the command, as in the Claude Desktop example.

Sign in with OAuth

The server implements the MCP authorization spec, so an MCP client can connect with nothing but the URL.

1. A request without a credential gets 401 with WWW-Authenticate: Bearer resource_metadata="https://api.serpkite.com/.well-known/oauth-protected-resource/v1/mcp", scope="mcp".
2. That protected resource metadata names https://app-api.serpkite.com as the authorization server, whose metadata is at /.well-known/oauth-authorization-server.
3. The client registers itself (dynamic client registration, or a Client ID Metadata Document URL as its client_id) and starts an authorization code flow with PKCE (S256 only) and resource=https://api.serpkite.com/v1/mcp.
4. You sign in to the SerpKite dashboard if needed and approve the request. The page shows the app’s name and the address your browser returns to; check both. If that address is on your own computer (localhost), approve only a connection you just started.
5. The client gets an access token (skt_oat_…, valid one hour) and a refresh token (skt_ort_…, 60 days, replaced on every use) and calls /v1/mcp with Authorization: Bearer skt_oat_….

Billing and limits. An approved connection runs as an API key named after the app, such as Claude (OAuth), which appears on your API keys page. Its calls are billed to your credits, count toward your spend cap and show up in the request log like any key’s. Give it a monthly credit limit to cap what the connection can spend, or revoke it to disconnect the app right away. Connecting the same app again reuses the key. A team member’s connection runs on the team account with the member key limit the owner set.

Scope. OAuth tokens work on /v1/mcp only; the REST endpoints need an API key. Tokens are stored as SHA-256 hashes, and a refresh token that is used twice ends the connection, in case it leaked.

Tools

All tools return text formatted for a model. Search and webpage tools use Markdown; map and extract format their results as text; crawl returns a task ID and crawl_result returns its status or pages. Billing matches the corresponding REST operation, and crawl polling is free. Every tool has a title and annotations: all are read-only (readOnlyHint: true) except crawl, which starts a task; none is destructive, and all reach the open web (openWorldHint: true).

Tool	What it does	Inputs	Credits
search	Google web search: organic results, answer box, knowledge graph, People Also Ask, related searches	q, country, language, location, page, time, engine, num (10, 20, 30, 50, 100), include_content (0–5), highlights, include_domains, exclude_domains, boost_domains, start_date, end_date	1 per page, up to 7 for num: 100, +1 per fetched page
news	Google News articles	q, country, language, location, page, time, engine, include_domains, exclude_domains, boost_domains, start_date, end_date	1
maps	Places with address, rating, phone, website, coordinates	q, country, language, location, page	1
scholar	Academic papers with citations and PDF links	q, country, language, page	1
patents	Patent search	q, country, language, page	1
shopping	Products with prices and merchants	q, country, language, location, page	1
images	Image search	q, country, language, location, page, engine, include_domains, exclude_domains, start_date, end_date	1
videos	Video search	q, country, language, location, page, engine, include_domains, exclude_domains, start_date, end_date	1
autocomplete	Query suggestions	q, country, language	0.5
webpage	Fetch a public URL (HTML or PDF) and return its main content as Markdown with metadata	url, country	1
extract	Read up to 20 URLs (HTML or PDF) as Markdown, or only the passages relevant to a query	urls, query, highlights, max_tokens, country, timeout	1 per URL read (failed URLs are free)
crawl	Start an async crawl of a site (or a section of it); returns an ID	url, limit, max_depth, query, include_paths, exclude_paths, max_tokens	1 per page read (limit reserved, the rest refunded)
crawl_result	The status or the pages of a crawl started with crawl	id	Free
map	List a site’s URLs from its sitemaps and start page, optionally ranked by a search phrase	url, search, limit, include_paths, exclude_paths	1 (free when nothing is found)

Query tools require q; webpage, map and crawl require url; extract requires urls; crawl_result requires id. Search highlights is a boolean used with include_content; extract highlights is an integer passage count (0–10). time is one of hour, day, week, month, year. As with the REST API, failed and empty calls are not billed.

The MCP schemas expose a subset of REST options. Use tools/list to inspect the available inputs, or call REST/SDKs for options such as extract links/images, crawl cancellation and monitor management. The site ingestion guide and monitoring guide cover those workflows.

Test it with curl

The server is stateless: every POST carries one JSON-RPC 2.0 message (or a batch of up to 20) and gets a JSON reply. No session setup is needed, which makes it easy to test by hand.

Initialize:

curl https://api.serpkite.com/v1/mcp \
  -H "Authorization: Bearer $SERPKITE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

List the tools:

curl https://api.serpkite.com/v1/mcp \
  -H "Authorization: Bearer $SERPKITE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

Call search:

curl https://api.serpkite.com/v1/mcp \
  -H "Authorization: Bearer $SERPKITE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"search","arguments":{"q":"best espresso machine 2026","country":"us"}}}'

The result’s content array holds a text item with the Markdown. Notifications (messages without an id) get an empty 202 Accepted. A missing or invalid key returns 401 with the usual error body and the OAuth WWW-Authenticate challenge described above.

Costs and safety

• Search and content-reading calls are billed like their REST equivalents; crawl_result polling is free. Failed and empty results are not billed.
• Give the MCP key a monthly credit_limit so a runaway agent loop stops at a known cost. When the limit is hit, calls fail with key_limit_reached and nothing more is charged. See Spend controls.
• The server only fetches public, logged-out pages. The webpage tool refuses private network addresses.

Related

[MCP integration overview

Setup walkthroughs and use cases for Claude, Cursor and ChatGPT.

](https://serpkite.com/integrations/mcp)[Tool calling without MCP

Define a search tool directly for OpenAI and Anthropic models.

](https://serpkite.com/docs/guides/agents-tool-calling)[Output formats

What the Markdown the tools return looks like.

](https://serpkite.com/docs/output-formats)[API keys

Create a dedicated key with a monthly limit.

](https://serpkite.com/docs/api-keys)