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.

The only value you need

https://tanod.dev/mcp

Free in every client, paid only from an x402 client. Each tool has a free daily allowance per IP address, and over MCP it is applied for you. 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.

Payments are x402 v2, scheme exact, in USDC on Base or Polygon, settled through the CDP facilitator. The SDKs pay on Base.

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

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

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

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.

.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.

Free allowance and paid calls

Every tool has 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 exact numbers for each route are in the fare matrix and in llms.txt.

Over MCP the allowance applies automatically; there is nothing to turn on.
When it is used up, the tool returns an error result instead of the answer. Its structuredContent is an x402 PaymentRequired object with the price, and the message states the price in words.
A client that can pay retries the same call with a signed payment in _meta["x402/payment"] (the x402 MCP transport). Desktop and IDE clients don't do this today, so with them you stay on the free allowance.
Over plain HTTP the allowance is opt-in: send X-Tanod-Free: 1 on an unpaid call. Without it, an unpaid call gets 402 Payment Required and nothing is used.

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. Source and docs: tanod-labs/integrations (MIT).

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 USDC on Base (eip155:8453) and on Polygon (eip155:137), in the PAYMENT-REQUIRED header and, identical, in the JSON body. Any x402 client library signs one of them and retries with PAYMENT-SIGNATURE (X-PAYMENT also works); the receipt comes back in PAYMENT-RESPONSE. Payments are verified and settled through the CDP facilitator. There is nothing to register first. The walk-through with a real 402 is in Pay-per-call APIs with x402, and every route and price is in OpenAPI.

Troubleshooting

Check the server from a terminal. This should print a JSON list of tools:

Terminal

curl -s -X POST https://tanod.dev/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

The client connects but lists no tools, or times out. It is probably using the old SSE transport. Set the streamable HTTP type the client expects: "type": "streamableHttp" in Cline, httpUrl instead of url in Gemini CLI, "type": "http" in Claude Code and VS Code.
The client asks you to sign in. Tanod has no OAuth and no API key. Choose no authentication, leave the OAuth fields empty, or set "oauth": false in OpenCode.
The client only runs local commands. Use the mcp-remote bridge shown under Claude Desktop.
A tool says payment is required. The free allowance for that route is used up for today. Wait for 00:00 UTC, or call it from an SDK or another x402 client.
The allowance seems used up before you started. It is counted per IP address. Claude connectors and ChatGPT call from their own servers, so you may share an address with other users; a client on your own machine counts only your calls.
429 or 503 responses. The limit is 60 requests per minute per IP, and scans run one at a time with a short queue. A 503 carries Retry-After and is never charged.

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.