Install the MCP server · paidfor.dev

[switch to human view]

# Install the paidfor MCP server

No account, no key. Everything that reads the index or contributes data (the site, the API, the MCP tools, the client, telemetry and the changes feed) needs no account and no key, now and later. An email address is asked for only to deliver alerts or to join a waitlist, as a confirmation link, never a profile.

paidfor.dev rates x402 sellers by paying them and verifying delivery. Its MCP server gives you `check_x402_seller` (call it before paying any x402 seller) and `list_reliable_sellers`.
No key, no account. The server sends nothing but the URL being checked. Show the user the config change before you write it.

1. Detect which client you are running in, from the sections below.
2. Make exactly the change listed for it. Merge into existing config; never remove other servers.
3. Restart if the section says so.
4. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

Hosted endpoint (Streamable HTTP, no auth): https://mcp.paidfor.dev/mcp. Stdio: `npx -y @paidfor/mcp@0.3.0`.

## Claude Code
If you are Claude Code (the `claude` CLI or the Code tab of the Claude app):
```bash
claude mcp add --transport http --scope user paidfor https://mcp.paidfor.dev/mcp
```
Start a new session (or run `/mcp` to reconnect) so the tools load. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Claude Desktop
If you are the Claude desktop app's chat (not its Code tab):
Edit macOS `~/Library/Application Support/Claude/claude_desktop_config.json`, Windows `%APPDATA%\Claude\claude_desktop_config.json`; merge into the existing `mcpServers`:
```json
{"mcpServers": {"paidfor": {"command": "npx", "args": ["-y", "@paidfor/mcp@0.3.0"]}}}
```
Quit and restart Claude Desktop. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## claude.ai
If you are Claude on claude.ai or the Claude mobile app:
Customize, Connectors, + Add, Add custom connector. Name `paidfor`, URL `https://mcp.paidfor.dev/mcp`, Continue, choose No sign in, Add. Free plans allow one custom connector. On Team and Enterprise an owner adds it under Organization settings, Connectors, Add, Custom, Web; members then click Connect.
No restart; start a new chat. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Cursor
If you are Cursor's agent:
Edit `~/.cursor/mcp.json` (all projects) or `.cursor/mcp.json` (this project); merge into the existing `mcpServers`:
```json
{"mcpServers": {"paidfor": {"url": "https://mcp.paidfor.dev/mcp"}}}
```
Cursor picks it up; if the tools do not show, toggle the server in Settings, MCP. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## VS Code
If you are GitHub Copilot agent mode in VS Code:
```bash
code --add-mcp '{"name":"paidfor","type":"http","url":"https://mcp.paidfor.dev/mcp"}'
```
Or edit `.vscode/mcp.json` in the workspace (merge into the existing `servers`):
```json
{"servers": {"paidfor": {"type": "http", "url": "https://mcp.paidfor.dev/mcp"}}}
```
Run `MCP: List Servers`, start `paidfor`, and trust it when asked. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Windsurf / Devin Desktop
If you are Cascade in Windsurf (now Devin Desktop):
Edit `~/.config/devin/mcp_config.json` (Windows `%APPDATA%\devin\mcp_config.json`; older Windsurf builds `~/.codeium/windsurf/mcp_config.json`); merge into the existing `mcpServers`:
```json
{"mcpServers": {"paidfor": {"serverUrl": "https://mcp.paidfor.dev/mcp"}}}
```
Press refresh in Cascade's MCP settings. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Codex CLI
If you are OpenAI's Codex CLI or IDE extension:
```bash
codex mcp add paidfor -- npx -y @paidfor/mcp@0.3.0
```
Or edit `~/.codex/config.toml` to use the hosted endpoint instead:
```toml
[mcp_servers.paidfor]
url = "https://mcp.paidfor.dev/mcp"
```
Start a new Codex session. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## ChatGPT
If you are ChatGPT:
Only if the account or workspace allows custom MCP servers: at chatgpt.com/plugins, +, Add custom MCP server, name `paidfor`, URL `https://mcp.paidfor.dev/mcp`, authentication None, confirm, Create as a plugin. If that option is missing, the account cannot add it; tell the user.
No restart; pick the connector in a new chat. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Any other MCP client
Add a Streamable HTTP server named `paidfor` at `https://mcp.paidfor.dev/mcp`, or a stdio server running `npx -y @paidfor/mcp@0.3.0`. Verify: Call `check_x402_seller` with `api-xpay.com` and confirm the verdict is `avoid`.

## Let your agent pay, safely
Only if the user asks for it; never make or fund a wallet unprompted.
With a wallet configured, the stdio server (@paidfor/mcp@0.3.1 or later) adds `pay_x402`, which pays through @paidfor/x402-safe-fetch: it checks the seller first, refuses avoid sellers and quotes over 1.1x the listed price, caps each call (PAIDFOR_MAX_PER_CALL_USD, default 0.50) and each day (PAIDFOR_DAILY_CAP_USD, default 5), never pays twice for one intent, and reports the verified outcome to the index. Use a dedicated wallet holding a few dollars; the key stays on your machine and is never logged, returned or sent.
The hosted server cannot pay, by design: it never holds a key, so it only has the two read tools.
1. Make a wallet (writes ~/.paidfor/wallet.key, mode 600, prints the address):
```bash
npx -y @paidfor/mcp@0.3.1 wallet new
```
2. Fund it:
Send a few USDC on Base to the printed address. x402 payments on Base are gasless for the buyer, no ETH needed.
3. Set the env in the client config (stdio, not the hosted URL):
```json
{"mcpServers": {"paidfor": {"command": "npx", "args": ["-y", "@paidfor/mcp@0.3.1"], "env": {"PAIDFOR_WALLET_KEY_FILE": "/Users/you/.paidfor/wallet.key", "PAIDFOR_MAX_PER_CALL_USD": "0.50", "PAIDFOR_DAILY_CAP_USD": "5"}}}}
```
4. Verify:
Restart the client and ask the agent to call wallet_status: it shows the address, the USDC balance on Base and the limits, never the key.

## Which path

Install the MCP server. The skill is enough for most agents; install the server when you want tools instead of HTTP, rules that hold in every session without a skills directory, or an agent that can pay.

|  | Skill, one message | MCP server | Client library in code | `pay_x402`, server plus your wallet |
| --- | --- | --- | --- | --- |
| Setup | tell your agent to read skill.md | one command or one config block (the skill does this for you where it can) | `npm install`, wrap your fetch | `paidfor-mcp wallet new`, fund a few USDC |
| Checks before paying | yes, over HTTP | yes, as a tool with structured results | yes, inside the call | yes |
| Rules persist | where the client has a skills directory | every session the server is attached, via instructions on initialize | in your code | same as the server |
| Never pays twice | by rule, the agent's discipline | by rule | enforced: intent ids and receipts | enforced |
| Caps and price checks | the agent reads them | the agent reads them | enforced: per-call cap, listed-price ratio, validators | enforced |
| Works in chat clients with no shell | rules for that conversation only | yes, as a connector | no | no |
| Outcomes reported back | only if the agent reports after paying | same, unless `pay_x402` | automatic, verified on-chain | automatic, verified on-chain |
| Session-start alerts for your allowlist | yes, from project notes | yes, via the `recent_changes` tool | no | yes |
| *What it gives the index* | *demand, candidates (soon), agent-reported outcomes* | *the same, plus tool analytics* | *verified outcomes* | *verified outcomes* |