Connect Tanod to your MCP client

Connect your MCP client to https://tanod.dev/mcp for document, PDF, image and data tools. The remote server uses streamable HTTP and needs no account, API key or OAuth.

Eligible tools have a free daily allowance. When a call needs payment, the server returns a quote instead of a result; your client is not charged unless it pays. Full document conversions have different limits: check free vs paid.

Updated 2026-11-13

Need a starting task? Try Document to Markdown, Merge PDF or Resize image. The full server offers 328 tools; see API pricing.

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

Try an API call before connecting

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.

Try next: 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.

Payment options, charge rules and verification

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. Full calls to heavy document tools (document conversion, PDF OCR, PDF compress and image conversions) are paid from a desktop or IDE client; document to Markdown has a bounded free preview (below). Eligible Claude.ai and ChatGPT connectors draw on shared daily docs allowances instead. Speech to text is paid in every client. 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, three commands) also works; it calls our HTTP routes and pays them from its own USDC balance. No crypto wallet at all? Thirty-nine of the tools also run on Apify, billed by card.

A payment settles when the call returns HTTP 200, and timeouts, server errors and bad input cost nothing. Contract scans are the exception: a scan that fails after it starts is still charged. Details, retries and receipts: when a paid call is charged.

After every deploy, each priced route is called once without payment and must answer with its 402 quote. /healthz reports the service, and MCP health checks show the latest connection results.

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. The payee file lists the configured recipient address per enabled network, the applicable hosts and a last-changed date; pin a trusted copy independently of a 402, since fetching it from a compromised endpoint does not establish trust. 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, scan reports kept 30 days, a paid answer kept 1 hour for a payment-ID retry, two speed-up caches, repository IDs and public facts cached for reuse up to 6 hours, a keyed hash of each seller origin sent to the price check, kept 30 seconds, and keyed hashes of a payment that ended without a charge, kept up to about 7 days, and of the paying wallet or credit account with its call counts, kept 1 hour) 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", "mcp-remote@0.14.3", "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 mcp-remote@0.14.3 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), /.well-known/x402-payees.json (payTo per enabled network, applicable hosts and last-changed date), /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

Eight servers that do one job each, for a client or a directory that wants a single clear tool. They reach the same tools, with the same prices, free allowance and payment flow as /mcp. Paste the URL as the server URL (no key or 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
GPU Rental Prices
https://tanod.dev/mcp/gpu-prices
Web Search
x402 Endpoint Check
https://tanod.dev/mcp/x402-check

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. Full calls over ordinary MCP are paid for 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. Document to Markdown with preview=true has 1 bounded attempt per IP per UTC day within a global budget (preview limits). Over HTTP, PDF to Word, document to Markdown and PDF compress share 2 free calls per IP per UTC day with X-Tanod-Free: 1, inline base64 only, up to 1 MB. Eligible Claude.ai and ChatGPT connectors use shared daily docs allowances, not a personal quota. 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.

Desktop: a local paying MCP client

Use npx -y tanod-mcp as a local stdio server in your desktop or IDE client, instead of the remote URL. Client configuration. Configure a dedicated Base USDC wallet locally; never paste a private key into chat. The client checks your per-call and daily spending caps before signing. Without a wallet, it stays on the free allowance.

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. The PAYMENT-REQUIRED header and the JSON body carry the same requirements. 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), except a contract scan, which is charged when it starts; 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.

AgentCash in three commands

AgentCash keeps one balance for your agent and pays x402 or MPP. Set up its wallet, see the document tools with their prices, then save the origin for your agent:

Terminal
npx agentcash onboard
npx agentcash try https://docs.tanod.dev
npx agentcash add https://docs.tanod.dev

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 (a contract scan is charged when it starts), 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.

Full index: bulk_agent_index exceeds the local client's default caps. Check its current price in OpenAPI or the tool's payment quote. Only with your explicit approval, set per-call and remaining daily budgets to cover that price. With @x402/mcp, check the core spendControls.maxAmountPerPayment limit as well as onPaymentRequested; approving one does not bypass the other. For a narrower search, call query_agent_index instead. No limits are raised automatically.

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

New to Apify? Sign up (affiliate link).

Thirty-nine Tanod 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 of our actors accept it (Apify Store data, 10 Nov). 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 reviewed before posting, so expect hours), and watch #changelog for new tools and price changes. Or email ops@tanod.dev.

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.