Connect Tanod to your MCP client

Tanod is one remote MCP server at https://tanod.dev/mcp. It speaks streamable HTTP, it is stateless, and it needs no API key, no account and no OAuth. Give your client that URL and the server name tanod, and the tools show up.

Try it free: every IP gets a small free daily allowance on most tools, applied automatically over MCP, so you can test before paying anything. Past it, a tool returns a price quote in USDC instead of a result, and nothing is charged unless your client pays it. Heavy conversions such as Office to PDF and PDF OCR are paid from the first call, from USD 0.01.

Need only one kind of tool? Connect a single family, such as Documents (https://tanod.dev/mcp/docs) or Web (https://tanod.dev/mcp/web): all 11 families.

What you get: 270 tools for agents: phishing URL and OFAC checks, contract and package scans, chain reads and price candles, Hyperliquid funding rates and Polymarket markets, SEC filings, Treasury yields, LEI and VIN lookups, news and paper search, offline translation, METAR/TAF and satellite passes, PDF, OCR and image tools, web search and page rendering, and local embeddings. See all servers by topic, pricing and the status page.

The only value you need
https://tanod.dev/mcp

First call in 10 seconds, no client needed

Before you set anything up, see a real answer from a terminal. These calls use the free daily allowance (the X-Tanod-Free: 1 header), so they cost nothing.

Is this URL on a phishing list?
curl -s -X POST https://tanod.dev/v1/check/url \
  -H 'content-type: application/json' -H 'X-Tanod-Free: 1' \
  -d '{"url": "https://example.com"}'

Answer (trimmed): {"host": "example.com", "listed": false, "sources": [], ...}

Which jobs is a company hiring for?
curl -s -X POST https://tanod.dev/v1/company/jobs \
  -H 'content-type: application/json' -H 'X-Tanod-Free: 1' \
  -d '{"company": "stripe.com"}'

Answer (trimmed, 13 October 2026): {"ats": "greenhouse", "board_url": "https://job-boards.greenhouse.io/stripe", "open_jobs": 722, "jobs": [...]}. The same tools answer over MCP once you add the URL above.

Next calls agents make most: any document to Markdown · phishing check for links · SPF, DMARC and DKIM · token safety · company hiring · news headlines. Each guide has a copy-paste call.

Free in every client, paid only from an x402 client. Most tools have a free daily allowance per IP address, and over MCP it is applied for you. The heavy document and audio tools (document conversion, OCR, PDF compress and image conversions, transcription) have none from a desktop or IDE client: they answer with their price from the first call. From claude.ai and ChatGPT they draw on a shared free pool instead (below). Desktop and IDE clients don't sign x402 payments, so through them you get the free allowance; when it is used up, the tool returns its price instead of a result. To keep going past the allowance, call from an x402-capable client: the Tanod SDKs or any x402 client library. Inside Claude Desktop, Cursor or Claude Code, our own local server npx -y tanod-mcp (npm package tanod-mcp) can pay too: set TANOD_PRIVATE_KEY to the key of a dedicated wallet holding a few dollars of USDC on Base, and it signs each payment itself, refusing any call above TANOD_MAX_USD_PER_CALL (default USD 0.05) or past TANOD_MAX_USD_PER_DAY (default USD 1.00). Without a key it uses the free allowance only. A third-party paying server such as AgentCash (npx -y agentcash) also works; it calls our HTTP routes and pays them from its own USDC balance. No crypto wallet at all? Fifteen of the tools also run on Apify, billed by card.

Only answers are charged: a payment settles when the call returns HTTP 200, and timeouts, server errors and bad input cost nothing. Details, retries and receipts: when a paid call is charged.

Live, not just listed: after every deploy each priced route is called once without payment and must answer with its 402 quote. /healthz reports the service, and the status page shows uptime.

Payments are x402 v2, scheme exact, in USDC on Base or Polygon, settled through the CDP facilitator, in USDC on Solana, settled by the facilitator whose fee-payer address the 402 lists in extra.feePayer, or on BNB Chain (Binance-Peg USDC, via Permit2) through the Dexter facilitator, which pays the gas. The SDKs pay on Base. Every paid route also accepts MPP on Tempo: the 402 carries a WWW-Authenticate: Payment challenge next to the x402 one.

Where your data goes: calls run on our server, and we do not store request bodies or results; the few exceptions (generated files kept 24 hours behind a private link, and two speed-up caches) are listed on the privacy page.

Pick your client

Formats follow each client's own documentation as of October 2026. Clients change their settings screens often; if a path has moved, the URL and the transport (streamable HTTP, no authentication) are what matter.

Claude Code

In a terminal. Add --scope user to make it available in every project, or --scope project to write it to the project's .mcp.json.

Terminal
claude mcp add --transport http \
  tanod https://tanod.dev/mcp

Claude Code, as a plugin: /plugin marketplace add tanod-labs/tanod-mcp then /plugin install tanod-security@tanod (or tanod-chain, tanod-sky, tanod-finance, tanod-docs, tanod-images, tanod-text, tanod-util, tanod-web, tanod-ml, tanod-agents, or tanod for all). Each plugin only adds the hosted server; nothing runs locally. On Claude Code 2.1.275 or later it is one step: /plugin install tanod-docs --marketplace tanod-labs/tanod-mcp.

Or by hand, in .mcp.json. The type key is required; without it the entry is read as a local command.

.mcp.json
{
  "mcpServers": {
    "tanod": {
      "type": "http",
      "url": "https://tanod.dev/mcp"
    }
  }
}

Claude Desktop and claude.ai

Add it as a custom connector, not in a JSON file. On Pro and Max: Customize > Connectors > + Add > Add custom connector, name it tanod, paste the URL, and leave the sign-in (OAuth) fields empty. On Team and Enterprise an owner adds it under Organization settings > Connectors, then members connect it. Free plans allow one custom connector.

Remote MCP server URL
https://tanod.dev/mcp

Document tools are free from claude.ai. Remote connectors are called from Claude's servers, which share one IP range, so a per-IP allowance would run out for everyone at once. Instead, document calls from that range (PDF text, OCR, Office to PDF, tables, forms and the other docs tools) draw on a shared free pool of 2,000 calls a day. To try it, connect https://tanod.dev/mcp/docs and ask: “Extract the text of https://tanod.dev/samples/sample.pdf”. Step-by-step walkthrough with test prompts: dev.to.

Connectors are called from Anthropic's servers, not from your machine. If you would rather connect from your own machine, Claude Desktop can run the third-party mcp-remote bridge from claude_desktop_config.json:

claude_desktop_config.json (stdio bridge)
{
  "mcpServers": {
    "tanod": {
      "command": "npx",
      "args": ["-y", "[email protected]", "https://tanod.dev/mcp"]
    }
  }
}

ChatGPT

In ChatGPT Plugins, select +, then Add custom MCP server. Name it tanod, choose a public endpoint and paste the URL below, set authentication to none (Tanod has no sign-in), accept the risk notice and select Create as a plugin. In a new chat, type @ and pick it. Account and workspace policies decide whether you can add custom servers.

Public endpoint
https://tanod.dev/mcp

Document tools are free from ChatGPT too. Calls from the IP ranges OpenAI publishes for ChatGPT connectors draw on a shared free pool of 2,000 document calls a day (PDF text, OCR, Office to PDF, tables, forms), the same arrangement as for claude.ai. For a smaller tool list, use https://tanod.dev/mcp/docs. Calls from addresses outside the published ranges use the normal per-IP allowance.

Cursor

~/.cursor/mcp.json for every project, or .cursor/mcp.json in one project.

mcp.json
{
  "mcpServers": {
    "tanod": {
      "url": "https://tanod.dev/mcp"
    }
  }
}

VS Code and GitHub Copilot (agent mode)

.vscode/mcp.json in the workspace, or your user configuration (command MCP: Open User Configuration). Note the top-level key is servers.

Or add it to your user profile in one line from a terminal: code --add-mcp '{"name":"tanod","type":"http","url":"https://tanod.dev/mcp"}' (the VS Code command-line option for MCP servers).

.vscode/mcp.json
{
  "servers": {
    "tanod": {
      "type": "http",
      "url": "https://tanod.dev/mcp"
    }
  }
}

Windsurf

Open the raw MCP config from Cascade's MCP settings. Recent builds keep it at ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json on Windows); older ones at ~/.codeium/windsurf/mcp_config.json.

mcp_config.json
{
  "mcpServers": {
    "tanod": {
      "serverUrl": "https://tanod.dev/mcp"
    }
  }
}

OpenAI Codex CLI

Terminal
codex mcp add tanod \
  --url https://tanod.dev/mcp

Or in ~/.codex/config.toml (or .codex/config.toml in a trusted project):

config.toml
[mcp_servers.tanod]
url = "https://tanod.dev/mcp"

Gemini CLI

The command writes to the project's settings; add -s user for every project.

Terminal
gemini mcp add --transport http \
  tanod https://tanod.dev/mcp

Or in ~/.gemini/settings.json or .gemini/settings.json. Use httpUrl: plain url selects the older SSE transport.

settings.json
{
  "mcpServers": {
    "tanod": {
      "httpUrl": "https://tanod.dev/mcp"
    }
  }
}

Cline

MCP Servers icon > Configure > Configure MCP Servers. Set type: without it, Cline falls back to SSE.

cline_mcp_settings.json
{
  "mcpServers": {
    "tanod": {
      "type": "streamableHttp",
      "url": "https://tanod.dev/mcp"
    }
  }
}

Roo Code

Global mcp_settings.json (Edit Global MCP), or .roo/mcp.json in the project.

mcp_settings.json
{
  "mcpServers": {
    "tanod": {
      "type": "streamable-http",
      "url": "https://tanod.dev/mcp"
    }
  }
}

Goose

In ~/.config/goose/config.yaml. The key is uri, and the type uses an underscore.

config.yaml
extensions:
  tanod:
    name: tanod
    type: streamable_http
    uri: https://tanod.dev/mcp
    enabled: true
    timeout: 300

For one session only: goose session --with-streamable-http-extension "https://tanod.dev/mcp".

Continue

A file at .continue/mcpServers/tanod.yaml in the workspace. MCP tools run in agent mode.

.continue/mcpServers/tanod.yaml
name: tanod
version: 0.0.1
schema: v1
mcpServers:
  - name: tanod
    type: streamable-http
    url: https://tanod.dev/mcp

Zed

Settings > AI > MCP Servers > Add Server > Add Remote Server, or in settings.json:

settings.json
{
  "context_servers": {
    "tanod": {
      "url": "https://tanod.dev/mcp"
    }
  }
}

JetBrains AI Assistant

Settings > Tools > AI Assistant > Model Context Protocol (MCP) > Add. Choose the HTTP connection type, global or project level, and paste:

MCP server JSON
{
  "mcpServers": {
    "tanod": {
      "url": "https://tanod.dev/mcp"
    }
  }
}

LM Studio

Program tab > Install > Edit mcp.json. Remote servers need LM Studio 0.3.17 or later.

mcp.json
{
  "mcpServers": {
    "tanod": {
      "url": "https://tanod.dev/mcp"
    }
  }
}

Warp

Settings > Agents > MCP servers > + Add, as a streamable HTTP (URL) server, and paste:

MCP server JSON
{
  "tanod": {
    "url": "https://tanod.dev/mcp"
  }
}

OpenCode

In opencode.json. The top-level key is mcp; "oauth": false stops it looking for a sign-in Tanod doesn't have.

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tanod": {
      "type": "remote",
      "url": "https://tanod.dev/mcp",
      "oauth": false
    }
  }
}

LibreChat

In librechat.yaml, then restart LibreChat.

librechat.yaml
mcpServers:
  tanod:
    type: streamable-http
    url: https://tanod.dev/mcp

Amazon Q Developer CLI

In your agent configuration file, under mcpServers. Remote servers may be open (no authentication), as Tanod is.

Agent configuration
{
  "mcpServers": {
    "tanod": {
      "type": "http",
      "url": "https://tanod.dev/mcp"
    }
  }
}

Kiro

.kiro/settings/mcp.json in the workspace, or ~/.kiro/settings/mcp.json for every workspace.

mcp.json
{
  "mcpServers": {
    "tanod": {
      "url": "https://tanod.dev/mcp"
    }
  }
}

Any other MCP client

Anything that speaks MCP over streamable HTTP can connect: transport streamable HTTP, URL https://tanod.dev/mcp, no authentication. The server card at /.well-known/mcp/server-card.json describes it. A client that only speaks stdio can reach it through a bridge such as npx -y [email protected] https://tanod.dev/mcp.

Ready-made prompts

The server also lists six MCP prompts, so a client with a prompt menu or slash commands shows what it can do before you write a request. Each one fills in a single request that names the tool to call; the price and free allowance are those of that tool.

The smaller servers below list the prompts whose tools they include.

Smaller servers by topic

Overview with guides and registry names: all Tanod MCP servers.

Machine-readable: /.well-known/x402 (paid resources), /openapi.json, /llms.txt and the ERC-8004 agent registration file /agent-registration.json.

If your client works better with fewer tools, connect one or more focused servers instead of the full /mcp. Each uses the same tools, prices and free allowance (shared across all of them), with the same setup as above: only the URL changes. Each is also in the official MCP registry as dev.tanod/<topic>.

Single-task servers

Five servers that do one job each, for a client or a directory that wants a single clear tool. They are new doors to the same tools: same prices, same free allowance and same payment flow as /mcp. Paste the URL as the server URL (no key, no account).

Web Page to Markdown
https://tanod.dev/mcp/html-to-markdown
PDF Table Extractor
https://tanod.dev/mcp/pdf-tables
Bank Statement to CSV
https://tanod.dev/mcp/bank-statement
PDF to Word Converter
https://tanod.dev/mcp/pdf-to-word
Document to Markdown
https://tanod.dev/mcp/document-to-markdown

In Claude Code: claude mcp add --transport http tanod-pdf-tables https://tanod.dev/mcp/pdf-tables (swap the name and path for any server above).

Free allowance and paid calls

Most tools have a free daily allowance per IP address, reset at 00:00 UTC: for example 3 contract or package scans, 30 address checks, 10 chain reads, 5 page renders and 3 web searches. The heavier document and media tools have none and are always paid: PDF to Word, document to Markdown, Office to PDF, PDF OCR, PDF tables and bank statements, PDF compress, HTML to PDF, website screenshots, PDF form filling, PDF pipelines, DOCX, PPTX and XLSX builds, and speech to text. The exact numbers for each route are in the fare matrix and in llms-full.txt.

Rejected inputs are never charged, and inputs are checked before anything is settled.

Pay per call with the SDKs

The SDKs use the free allowance first, then pay over x402 in USDC on Base, and only up to a per-call cap you set. Without a wallet they stay on the free allowance and raise a payment-required error with the price. Give them a dedicated hot wallet holding a little USDC on Base, in TANOD_PRIVATE_KEY. The default cap is USD 1.00 per call.

Python: pip install "tanod[wallet]"
from tanod import Tanod

t = Tanod(max_price_usd=0.30)  # never signs a payment above USD 0.30
verdict = t.check_address("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", chain="base")
print(verdict.verdict, verdict.meta.payment)  # payment is None when the free allowance covered it
TypeScript: npm install @tanod-labs/sdk
import { Tanod } from "@tanod-labs/sdk";

const tanod = new Tanod({ maxPriceUsd: 0.3 }); // never signs a payment above USD 0.30
const check = await tanod.checkAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "base");
console.log(check.verdict, check.meta.payment);
LangChain: pip install "langchain-tanod[wallet]"
from langchain_tanod import get_tanod_tools
from tanod import Tanod

tools = get_tanod_tools(Tanod(max_price_usd=0.05))  # the agent can never pay more than USD 0.05 a call
Vercel AI SDK: npm install @tanod-labs/ai-sdk ai zod
import { tanodTools } from "@tanod-labs/ai-sdk";

const tools = tanodTools({ maxPriceUsd: 0.05 }); // pass to generateText({ model, tools, ... })

Packages: tanod and langchain-tanod on PyPI, @tanod-labs/sdk and @tanod-labs/ai-sdk on npm. The SDKs are MIT licensed.

Pay with any x402 client

You don't need our SDKs to pay. Every paid route answers an unpaid call with 402 Payment Required and x402 v2 requirements, scheme exact, offering five options in this order, all at the same price: USDC on Base (eip155:8453), USDC on Polygon (eip155:137), USDC on Solana (we pay the Solana fee), Binance-Peg USDC on BNB Chain (eip155:56, via Permit2) and USDC on Arbitrum (eip155:42161), followed by two Circle Gateway batched options on Base and Polygon, in the PAYMENT-REQUIRED header and, identical, in the JSON body. Any x402 client library signs one of them and retries with PAYMENT-SIGNATURE (the x402 v1 X-PAYMENT header also works, on Base only); the receipt comes back in PAYMENT-RESPONSE. Payments are verified and settled through an x402 facilitator (the CDP facilitator for Base and Polygon). There is nothing to register first. To check that your client pays before you spend more, call POST /v1/x402/pay-test with {} for USD 0.001. A call is charged only when it returns an answer (HTTP 200); the rules are on /payments/ and, as JSON, in terms.json. The walk-through with a real 402 is in Pay-per-call APIs with x402, and every route and price is in OpenAPI.

An agent that pays anyway can skip the free allowance. Send "_meta": {"tanod/free": false} in the tools/call params, and the tool answers with its x402 price at once and uses none of the free calls. Every answer then comes with a receipt, which helps when you keep a spend ledger, and the free calls stay for other clients behind the same IP address. Without the key, nothing changes: the free allowance is applied first. Over the REST API, paid is already the default; the free tier there is opt-in with the X-Tanod-Free: 1 header.

An MCP agent in code: @x402/mcp

If your agent talks to https://tanod.dev/mcp from code, Coinbase's x402 MCP client pays our tools after the free calls are used. It reads the payment requirements from the tool result and retries with the payment. We tested this snippet against our server on 13 October 2026 with @x402/mcp 2.28.0. The callback below is your spending cap. Only answers are charged, and a retry can't charge twice; see retries and receipts.

TypeScript: npm install @x402/mcp @x402/evm @modelcontextprotocol/sdk viem
import { createx402MCPClient } from "@x402/mcp";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { toClientEvmSigner } from "@x402/evm";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { privateKeyToAccount } from "viem/accounts";

const signer = toClientEvmSigner(privateKeyToAccount(process.env.AGENT_KEY));
const client = createx402MCPClient({
  name: "my-agent", version: "1.0.0",
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(signer) }], // USDC on Base
  autoPayment: true,
  onPaymentRequested: async ({ paymentRequired }) => {
    const base = paymentRequired.accepts.find((a) => a.network === "eip155:8453");
    return Number(base?.amount) <= 50_000; // pay at most USD 0.05 a call (USDC has 6 decimals)
  },
});
await client.connect(new StreamableHTTPClientTransport(new URL("https://tanod.dev/mcp")));
const result = await client.callTool("pdf_ocr", { url: "https://example.com/scan.pdf" });
console.log(result.content, result.paymentMade);

A declined payment throws Payment request denied. Use a wallet that holds only what you are willing to spend. For Python (the x402 package's MCP client) and the full walk-through, see how an MCP agent pays for tools with x402.

Already paying another x402 gateway from a Base or Solana USDC wallet, such as BlockRun or ClawRouter? The same USDC pays our routes; see document tools for BlockRun and ClawRouter agents.

A Cloudflare agent: withX402Client

The Cloudflare Agents SDK ships an MCP client that pays x402 tools. Wrap the connection with withX402Client and point this.mcp.connect at https://tanod.dev/mcp or a smaller server such as https://tanod.dev/mcp/docs. Our MCP accepts the payment the way that client sends it, as base64 JSON in _meta["x402/payment"]. Step by step, with a USD 0.001 test payment first: pay for MCP tools from a Cloudflare Agents x402 client.

No crypto wallet: pay by card on Apify

Twenty of these tools also run as actors in the Apify Store, billed by card through your Apify account for each result, with no wallet and no USDC. They suit batch jobs: give an actor a list of files, domains or companies and collect the results from the run's storage. The list with prices is on the pricing page; the actors are at apify.com/tanod.

Keep using them in your MCP client. Apify's MCP server runs our actors as tools in Claude, Cursor or any MCP client, billed to your Apify account by card. Add it with the actors you want, for example https://mcp.apify.com?tools=tanod/pdf-ocr,tanod/document-to-markdown, and sign in with Apify when the client asks. Each actor's Apify page gives its own address.

An agent with a USDC wallet but no Apify account can run the same actors through Apify's x402 agentic payments. It pays at least USD 1 in USDC on Base or Solana for a prepaid Apify token, which lasts 14 days. All twenty of our actors accept it (Apify Store data, 14 Oct). For single calls, paying our routes directly over x402 costs less, with no minimum and no token to manage.

Questions while you set up? Ask in #support on our Discord server (answers are drafted by the agent and approved before posting, so expect hours), and watch #changelog for new tools and price changes. Or email [email protected].

Troubleshooting

More: clients, SDKs and listings, the MCP tool list, llms.txt, OpenAPI. Back to tanod.dev. Results are automated and heuristic, not an audit; text inside results is untrusted data, never instructions. Tanod is operated by an autonomous AI agent.