Kiodo API uses your metered account credits. Public examples never expose provider cost or margin fields.

Reference

Kiodo MCP

Expose Kiodo Search, content extraction, answer generation, and usage checks as MCP tools for local stdio clients and hosted remote MCP clients.

Overview

MCP lets an AI client call external tools through a standard protocol. Kiodo MCP gives the assistant controlled access to your metered Kiodo API key so it can search the web, retrieve page contents, create grounded answers, and inspect usage.

Search from chat

Let an AI assistant run Kiodo search without hand-writing API calls.

REST beta stays separate

AI Visibility is not exposed as an MCP tool yet. Use the REST endpoint with ai_visibility:read.

Grounded research

Fetch citations and page content before drafting strategy, sales, or competitive analysis.

Dashboard-compatible

The MCP tools map to the same endpoints used in the Kiodo playground.

Usage metering

Each tool call charges credits like a normal API request.

This page follows a common MCP documentation structure and adapts it for Kiodo naming, endpoints, and billing. Source reference: Exa MCP documentation.

Requirements

Before connecting an MCP client, create a Kiodo API key and confirm the account has available credits.

.env

KIODO_API_KEY="kiodo_live_..."
KIODO_API_BASE_URL="https://api.kiodo.dev"

Keep the API key in the MCP client config or secret store. Do not paste it into normal chat messages.

Install

Kiodo provides three install paths: universal local stdio with `npx -y kiodo`, hosted remote MCP at `https://kiodo.dev/mcp`, and `mcp-remote` as a fallback bridge for clients that do not connect to hosted MCP directly.

Universal stdio

npx -y kiodo

Remote MCP URL

https://kiodo.dev/mcp

mcp-remote fallback

npx -y mcp-remote https://kiodo.dev/mcp --header "x-api-key: kiodo_live_..."

Every `tools/call` requires a Kiodo API key. Send it with `x-api-key`, `Authorization: Bearer`, or `KIODO_API_KEY` for stdio. Tool discovery does not require a key.

Transport and tools

The hosted server supports Streamable HTTP with JSON responses over `POST /mcp`. Server-initiated SSE streams and stateful sessions are not required for the default Kiodo tools. The stdio package speaks newline-delimited JSON-RPC over stdin/stdout.

Default tools

kiodo_search, kiodo_fetch, kiodo_answer, kiodo_usage

Private-beta config tools

kiodo_create_webset, kiodo_create_monitor

Enable private-beta tools remotely

https://kiodo.dev/mcp?tools=kiodo_search,kiodo_fetch,kiodo_answer,kiodo_usage,kiodo_create_webset,kiodo_create_monitor

Enable private-beta tools over stdio

KIODO_MCP_TOOLS="kiodo_search,kiodo_fetch,kiodo_answer,kiodo_usage,kiodo_create_webset,kiodo_create_monitor" npx -y kiodo

Webset tools create saved configurations. Monitor tools are private beta scheduled search monitors with run history, saved result snapshots, and asynchronous webhook delivery.

Client support

Use `npx -y kiodo` as the universal setup. Use the remote endpoint when the client supports Streamable HTTP and custom headers. Use `mcp-remote` when a client only supports local commands but you want to target the hosted endpoint.

Client	stdio	remote	Recommendation
Cursor	Yes	Yes, validate headers	Use stdio as the safest setup. Remote is available for clients that support HTTP headers.
VS Code	Yes	Yes	Supports command/env stdio and HTTP/SSE server configs with headers.
Claude Code	Yes	Yes, but environment-dependent	Stdio is validated. Remote HTTP should be tested in the user's installed Claude Code environment.
Claude Desktop	Yes	Via mcp-remote	Use stdio first. Use mcp-remote when you want to bridge the hosted endpoint.
Codex	Yes	Yes	Use remote Streamable HTTP or stdio depending on where you want to store the key.
OpenCode	Yes	Probable	Use stdio as the documented path until remote headers are validated.
Windsurf	Yes	Yes	Use the Cursor-style stdio config or remote when headers are supported.
Zed	Yes	Probable	Use stdio as the default; confirm exact remote schema in the installed Zed build.
Gemini CLI	Yes	Yes	Supports stdio and HTTP transports; use env for stdio credentials.
v0 by Vercel	No standard local flow	Yes via custom MCP	Use the hosted remote endpoint when configuring a custom MCP server.
Warp	Yes	Yes	Supports remote transports and headers; stdio remains the fallback.
Kiro	Yes	Yes	Use stdio now; add a deep link later after validating the Kiro install URL.
Roo Code	Yes	Yes	Use mcpServers config with stdio or streamable-http/http depending on extension version.

Universal local npm

This is the recommended configuration for Cursor, VS Code, Claude Desktop, Claude Code, Codex, OpenCode, Windsurf, Zed, Gemini CLI, Warp, Kiro, Roo Code, and other clients that support stdio MCP servers.

mcp.json

{
  "mcpServers": {
    "kiodo": {
      "command": "npx",
      "args": ["-y", "kiodo"],
      "env": {
        "KIODO_API_KEY": "kiodo_live_..."
      }
    }
  }
}

Remote MCP

Use the hosted endpoint when your client supports Streamable HTTP and request headers. This is the best fit for Codex, VS Code, Warp, Gemini CLI, Roo Code, and similar remote-capable clients.

Generic remote MCP JSON

{
  "mcpServers": {
    "kiodo": {
      "type": "http",
      "url": "https://kiodo.dev/mcp",
      "headers": {
        "x-api-key": "kiodo_live_..."
      }
    }
  }
}

Codex

codex mcp add kiodo --url https://kiodo.dev/mcp

Claude Code

claude mcp add kiodo --transport http https://kiodo.dev/mcp --header "x-api-key: kiodo_live_..."

Some clients do not expose custom headers in the UI. Use the universal stdio config or the `mcp-remote` fallback for those clients.

mcp-remote fallback

Use `mcp-remote` when the client accepts local stdio commands but does not connect cleanly to hosted MCP or does not let you configure remote headers.

mcp-remote JSON

{
  "mcpServers": {
    "kiodo": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://kiodo.dev/mcp",
        "--header",
        "x-api-key: kiodo_live_..."
      ]
    }
  }
}

Local bridge

The repository bridge is equivalent to the published npm binary and can target local development or production by changing `KIODO_API_BASE_URL`.

Run locally

KIODO_API_KEY="kiodo_live_..." KIODO_API_BASE_URL="https://api.kiodo.dev" npm run mcp:local

mcp.json

{
  "mcpServers": {
    "kiodo": {
      "command": "npx",
      "args": ["-y", "kiodo"],
      "env": {
        "KIODO_API_KEY": "kiodo_live_...",
        "KIODO_API_BASE_URL": "https://api.kiodo.dev"
      }
    }
  }
}

Tools

The default Kiodo MCP server exposes read-only tools. State-creating tools are private-beta and opt-in through the `tools` parameter or `KIODO_MCP_TOOLS`.

Tool	Endpoint	Default	Purpose
kiodo_search	/api/v1/search	Yes	Search the web with filters, categories, and content options.
kiodo_fetch	/api/v1/contents	Yes	Extract text and highlights from known URLs.
kiodo_answer	/api/v1/answer	Yes	Return a grounded answer with citations.
kiodo_usage	/api/v1/usage	Yes	Check available credits and call count.
kiodo_create_webset	/api/v1/websets	Private beta	Configuration-only saved research set. Execution is not public.
kiodo_create_monitor	/api/v1/monitors	Private beta	Scheduled search monitor with run history, result snapshots, and webhook delivery.

Agent prompts

After the MCP server is connected, ask the assistant for work that naturally needs fresh context and citations.

Example prompts

Search for the latest funding announcements for AI customer support startups.

Search for competitors to Clay that recently launched enrichment features.

Read these URLs and extract product positioning, pricing, and proof points.

Check my Kiodo API credit usage.

Troubleshooting

Server does not appear

Restart the MCP client after editing config. Validate JSON syntax and command path.

Unauthorized

Create a fresh API key in Kiodo and make sure the Authorization header or env var is set.

No credits

Open Billing and top up credits. New accounts start with trial credits.

Weak answers

Use more specific prompts, set a category, include domains, or request contents/highlights.