Mercury X402 Mcp

SSE

by mercuryx402

279 downloads Not rated yet

GitHub Website SSE

About

Mercury is a pay-per-call MCP server that lets AI agents discover and call financial data tools using the x402 HTTP payment protocol. 18 tools covering crypto prices, DeFi liquidity, NFT data, on-chain analytics, and more. tools/list is free — tools/call is billed per call using

Details

Transport: SSE

Explore

- Agent-to-agent payments over HTTP 402 using real USDC.
- Settles on Base mainnet – no custom token or coin.
- Includes a catalog of LLM APIs, web search, data feeds, and more.
- Uses the standard Coinbase x402-fetch + viem payment flow.
- Single-developer project, early stage, live on mainnet.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Mercury X402 Mcp

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

From the repository

Add the MCP server to your client config (e.g., Claude Desktop) using the provided command. The server exposes tools such as get_catalog to list available services, get_pricing to view current costs, and purchase to buy a specific item. The agent signs a real USDC transaction on Base mainnet, and the result is delivered back over the MCP protocol.

`fetch`

VERIFIABLE keyless web-read for autonomous agents. Every result ships a cryptographically SIGNED provenance receipt (EIP-191 over sha256(text)+url+status+time) — the wedge a free scraper structurally CANNOT match: Jina r.jina.ai is free+keyless too, but its bytes are HEARSAY (no proof of what/where/when). MERCURY's `attestation` is ecrecoverable OFFLINE, forever, by you OR any downstream agent you forward the bytes to — proving the content is genuine + untampered (key pinned at /.well-known/m…

`extract`

TYPED structured extract for autonomous agents — URL + schema → a clean, type-safe JSON record. Where /buy/fetch returns page TEXT (and ?extract= returns string-only fields), THIS returns the schema-conformant object an LLM/RAG/trading pipeline actually consumes: pass ?url=…&schema=title,price:number,rating:number,inStock:boolean and get back { title:"…", price:19.99, rating:4.5, inStock:true } — numbers as numbers, booleans as booleans, absent fields null (honest). `schema` accepts the URL-f…

`markdown`

URL → clean, LLM-ready markdown (boilerplate/nav/ads stripped, headings + lists + links preserved) with a signed provenance receipt pinning the markdown to its source — the RAG-ingest primitive. Deterministic (no LLM): same URL + same source bytes ⇒ byte-identical markdown. — $0.005/call

`metadata`

URL → one typed, SIGNED metadata record (JSON-LD + OpenGraph + Twitter-card + standard <meta> + canonical + title), by source. Deterministic, keyless, no LLM — the social-card/SEO/schema.org record an agent can PROVE. — $0.006/call

`links`

URL → a SIGNED outbound/internal link graph: every <a href> as an absolute URL + anchor text, classified internal vs external against the page origin, grouped by origin with a third-party-origin histogram (privacy-audit) and same/cross-origin counts (SEO). Deterministic — same page bytes ⇒ byte-identical graph; no LLM. Covers <a> hyperlinks only (not rel/asset tags). Receipt = EIP-191 over the graph. — $0.005/call

`robots`

Domain → signed, timestamped per-AI-crawler allow/block audit from robots.txt + llms.txt + ai.txt (GPTBot, ClaudeBot, PerplexityBot, Google-Extended, Bytespider, …). Deterministic, no LLM. EU-AI-Act / TDM opt-out evidence: the signed verdict proves the crawler policy as it stood at fetch time. — $0.005/call

`diff`

URL + prior content-hash (or prior text) -> refetch, deterministic change-proof: changed? + a NEW signed receipt binding fromHash->toHash. Stateless; receipts chain into a tamper-evident audit trail of a page's evolution. Keyless x402, Base mainnet USDC. — $0.006/call

`notarize`

Notarize any content (inline ?content= or a fetched ?url=) into a signed, offline-verifiable provenance receipt — sha256 contentHash + witnessed timestamp, attested by Mercury's pinned key. Deterministic, keyless, no LLM. The signed receipt is the product: it witnesses that these exact bytes existed in this exact form at this time (the one thing your own sha256() can't — a third-party witness). — $0.008/call

`headers`

URL → a deterministic HTTP security-headers audit (HSTS, CSP, X-Frame, X-Content-Type, Referrer-Policy, Permissions-Policy + more) with a letter grade and concrete findings, wrapped in a signed, offline-verifiable provenance receipt. Keyless, no LLM, no signup. — $0.005/call

`table`

URL in → the page's main HTML <table>(s) parsed into typed, header-keyed rows (JSON) + clean RFC-4180 CSV, with a signed provenance receipt over the exact extracted grid. Deterministic, keyless, no LLM — x402, USDC on Base mainnet. — $0.006/call

`feed`

RSS/Atom feed URL → a SIGNED, normalized item list [{title,link,published,summary}] unified across RSS 2.0/RDF + Atom 1.0: CDATA unwrapped, HTML stripped, entities decoded, dates → ISO-8601 (publishedRaw kept verbatim, never fabricated). Deterministic — same feed bytes ⇒ byte-identical items; no LLM. Core 4 fields only (not full-content/media/author). Receipt = EIP-191 over the canonical item list. — $0.005/call

`availability`

URL → a signed uptime/status probe: up/down, HTTP status + class, reachability reason, final URL after redirects, and a measured responseMs — wrapped in an offline-verifiable provenance receipt that makes "it was up/down at T" provable SLA evidence. Deterministic verdict (responseMs is telemetry, not signed). Keyless, no LLM, no signup. — $0.005/call

`validate`

URL (a JSON/API endpoint) + a JSON Schema in → a deterministic pass/fail with per-field errors (missing/wrong-type/enum/range/pattern), plus a signed provenance receipt binding the verdict to the exact response bytes AND the exact schema. Deterministic, keyless, no LLM — x402, USDC on Base mainnet. — $0.005/call

`batch`

List of URLs (≤20) → clean content for each + ONE signed receipt committing to a MERKLE ROOT over every page's contentHash. Tamper-evident multi-page snapshot with per-page membership proofs (selective disclosure). Deterministic (no LLM): same URL set + same source bytes ⇒ byte-identical root + proofs. SSRF-guarded per url; keyless x402, USDC on Base mainnet. — $0.02/call

`sitemap`

Domain/URL → a SIGNED snapshot of the site's PUBLISHED sitemap: discovers the sitemap via robots.txt Sitemap: lines then /sitemap.xml fallback, parses <urlset> + <sitemapindex> (follows up to 5 child sitemaps), returns a deduped, bounded (≤2000) URL inventory with lastmod/changefreq/priority. The receipt signs the DECLARED URL list (deterministic — same sitemap bytes ⇒ byte-identical list). Optional ?fetch=N (≤10) adds a HARD-BOUNDED same-domain liveness probe (title+status+bytes per URL) — t…

`dns`

Domain → a SIGNED, timestamped DNS snapshot (A, AAAA, MX, NS, TXT, CNAME, SOA), normalised + sorted into a byte-stable record set with an offline-verifiable provenance receipt — proving exactly what the zone resolved to at that moment. Keyless, no LLM, no signup. (Normalisation is deterministic; DNS itself is mutable across time/TTL/geo — which is the very reason the snapshot is timestamped + signed.) — $0.006/call

`readability`

URL → a clean ARTICLE record { title, byline, publishedAt, article text } with boilerplate (nav/header/footer/sidebar/ads/share-bars/comment-forms) stripped via deterministic DOM density heuristics, plus a signed provenance receipt pinning the cleaned article to its source — the clean-citation primitive distinct from raw markdown. Deterministic (no LLM): same URL + same source bytes ⇒ byte-identical output. — $0.005/call

`redirect`

URL → a SIGNED redirect/canonical resolution: the full hop chain [{url,status}] from the link you have to where it ACTUALLY lands, the final resolved URL + status, the page's <link rel=canonical>, hop count, cross-origin flag and distinct origins traversed (affiliate-cloak / link-safety signal). Deterministic — same redirects ⇒ byte-identical resolution; no LLM. Follows HTTP 3xx only (no JS/meta-refresh execution — meta-refresh target surfaced un-followed). Receipt = EIP-191 over the resolved…

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mercury x402 mcp": {
            "mercury-x402-mcp": {
                "command": "npx",
                "args": [
                    "mercury-x402-mcp"
                ]
            }
        }
    }
}

McpServers

{
    "mercury-x402-mcp": {
        "command": "npx",
        "args": [
            "mercury-x402-mcp"
        ]
    }
}

<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
<link rel="alternate icon" href="/favicon.ico" />
<title>MERCURY x402 — give your agent a wallet & a shop it can pay over HTTP 402</title>
<meta name="description" content="MERCURY is an agent-to-agent storefront that sells over HTTP 402. Your agent discovers what's for sale, pays with its own wallet on Base mainnet in real USDC, and gets the goods — in about 5 lines. Early · Base mainnet · real USDC · no token · built solo." />
<style>
:root{
--black:#0a0a0a; --panel:#121212; --panel2:#171717; --line:#262626;
--ink:#e9e9ec; --mute:#8b8b93; --dim:#5f5f66;
--purple:#9b59b6; --turq:#00d4aa; --amber:#e0a32b;
}
{box-sizing:border-box}
html,body{margin:0;padding:0}
body{
background:var(--black); color:var(--ink);
font:16px/1.65 -apple-system,BlinkMacSystemFont,"Segoe UI",Inter,Roboto,Helvetica,Arial,sans-serif;
-webkit-font-smoothing:antialiased; min-height:100vh; position:relative; overflow-x:hidden;
}
a{color:var(--turq);text-decoration:none}
a:hover{text-decoration:underline}
code,.mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}

/ ambient background: purple + turquoise glow on black /
.space{position:fixed;inset:0;z-index:0;overflow:hidden;pointer-events:none;background:
radial-gradient(1100px 650px at 80% -12%, rgba(155,89,182,.16), transparent 60%),
radial-gradient(900px 600px at 8% 110%, rgba(0,212,170,.10), transparent 60%),
var(--black);}
.stars{position:absolute;inset:0;opacity:.55;background-image:
radial-gradient(1px 1px at 20% 30%, #fff6 0, transparent 1px),
radial-gradient(1px 1px at 70% 20%, #fff5 0, transparent 1px),
radial-gradient(1px 1px at 40% 70%, #fff4 0, transparent 1px),
radial-gradient(1px 1px at 88% 60%, #fff5 0, transparent 1px),
radial-gradient(1px 1px at 12% 82%, #fff4 0, transparent 1px),
radial-gradient(1px 1px at 56% 44%, #fff3 0, transparent 1px);
background-repeat:repeat;background-size:520px 520px;}

.wrap{position:relative;z-index:1;max-width:980px;margin:0 auto;padding:0 22px}

/ top bar /
header.bar{display:flex;align-items:center;justify-content:space-between;padding:22px 0 0}
.logo{display:flex;align-items:center;gap:12px;font-weight:800;letter-spacing:.16em;font-size:15px}
/ MERCURY mark — the red planet (radial sphere + glow + inner shadow). The planet is
pure red; a small turquoise "settled/live" tick sits at ~1 o'clock. Matches the
favicon / agent-card icon exactly. /
.dot{position:relative;width:18px;height:18px;border-radius:50%;
background:radial-gradient(circle at 33% 28%,#ff4d6a,#e23b4e 52%,#5e0f1c 100%);
box-shadow:0 0 16px rgba(226,59,78,.55), inset -2px -2px 5px rgba(0,0,0,.55)}
.dot::after{content:"";position:absolute;top:1px;right:-1px;width:4px;height:4px;
border-radius:50%;background:var(--turq);box-shadow:0 0 6px rgba(0,212,170,.9)}
.navlink{color:var(--mute);font-size:13.5px;letter-spacing:.04em}
.navlink:hover{color:var(--ink);text-decoration:none}

/ honest status banner /
.status{display:flex;gap:12px;align-items:flex-start;margin:26px 0 8px;
border:1px solid var(--amber);background:linear-gradient(180deg,rgba(224,163,43,.10),rgba(224,163,43,.04));
border-radius:12px;padding:13px 16px;font-size:13.5px;color:#f0d79a}
.status b{color:var(--amber)}
.status .pill{flex:0 0 auto;font-size:11px;font-weight:800;letter-spacing:.12em;
text-transform:uppercase;color:var(--black);background:var(--amber);border-radius:6px;padding:3px 8px;margin-top:2px}

/ hero /
.hero{padding:30px 0 8px}
.kicker{color:var(--turq);font-size:13px;font-weight:700;letter-spacing:.18em;text-transform:uppercase;margin-bottom:14px}
h1{font-size:clamp(30px,5.4vw,52px);line-height:1.08;margin:0 0 18px;font-weight:800;letter-spacing:-.01em}
h1 .glow{color:var(--purple);text-shadow:0 0 28px rgba(155,89,182,.45)}
h1 .turq{color:var(--turq)}
.sub{font-size:18px;color:#cfcfd6;max-width:680px;margin:0 0 26px}
.sub b{color:var(--ink)}

.cta-row{display:flex;flex-wrap:wrap;gap:14px;align-items:center;margin:8px 0 6px}
.btn{display:inline-block;font-weight:700;font-size:15px;letter-spacing:.02em;border-radius:11px;padding:13px 22px;cursor:pointer;border:1px solid transparent;transition:transform .12s ease,box-shadow .12s ease}
.btn:hover{text-decoration:none;transform:translateY(-1px)}
.btn-primary{background:linear-gradient(135deg,var(--purple),#7a3f96);color:#fff;box-shadow:0 8px 30px rgba(155,89,182,.35)}
.btn-primary:hover{box-shadow:0 10px 38px rgba(155,89,182,.5)}
.btn-ghost{background:transparent;color:var(--turq);border-color:rgba(0,212,170,.4)}
.btn-ghost:hover{border-color:var(--turq);background:rgba(0,212,170,.06)}
.cta-note{color:var(--dim);font-size:13px}

/ sections /
section{padding:40px 0;border-top:1px solid var(--line)}
section:first-of-type{border-top:none}
.eyebrow{color:var(--purple);font-size:12.5px;font-weight:800;letter-spacing:.16em;text-transform:uppercase;margin-bottom:18px}
h2{font-size:25px;margin:0 0 8px;font-weight:800;letter-spacing:-.01em}
.lead{color:var(--mute);max-width:660px;margin:0 0 26px}

/ what your agent gets — cards /
.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:14px}
.card{border:1px solid var(--line);background:linear-gradient(180deg,var(--panel),var(--panel2));border-radius:13px;padding:18px 18px 16px}
.card .ic{font-size:13px;font-weight:800;letter-spacing:.04em;color:var(--turq);margin-bottom:8px;display:flex;align-items:center;gap:8px}
.card .ic .b{width:7px;height:7px;border-radius:50%;background:var(--turq);box-shadow:0 0 10px var(--turq)}
.card h3{font-size:16px;margin:0 0 6px}
.card p{margin:0;color:var(--mute);font-size:14px}

/ pricing table /
table{width:100%;border-collapse:collapse;font-size:14.5px;border:1px solid var(--line);border-radius:12px;overflow:hidden}
thead th{text-align:left;background:var(--panel2);color:var(--mute);font-weight:700;font-size:12px;letter-spacing:.08em;text-transform:uppercase;padding:11px 14px;border-bottom:1px solid var(--line)}
tbody td{padding:11px 14px;border-bottom:1px solid var(--line)}
tbody tr:last-child td{border-bottom:none}
tbody tr:hover{background:rgba(155,89,182,.05)}
td .slug{color:var(--turq);font-family:ui-monospace,Menlo,monospace;font-size:13.5px}
td .price{color:var(--ink);font-weight:700;font-family:ui-monospace,Menlo,monospace}
td .kind{display:inline-block;font-size:11px;letter-spacing:.04em;color:var(--purple);border:1px solid rgba(155,89,182,.4);border-radius:5px;padding:1px 7px;text-transform:uppercase}
.price-note{color:var(--dim);font-size:13px;margin-top:12px}
.live-tag{display:inline-block;font-size:11px;letter-spacing:.08em;color:var(--turq);border:1px solid rgba(0,212,170,.4);border-radius:5px;padding:1px 8px;text-transform:uppercase;margin-left:10px;vertical-align:middle}
.live-tag.stale{color:var(--mute);border-color:var(--line)}
/ static-fallback row states /
tbody tr.live-sku{background:rgba(0,212,170,.06)}
tbody tr.live-sku:hover{background:rgba(0,212,170,.10)}
tbody tr.gated{color:var(--dim)}
tbody tr.gated .slug{color:var(--mute)}
tbody tr.gated .price{color:var(--mute);font-weight:400}
.badge-live{display:inline-block;font-size:10.5px;letter-spacing:.06em;color:var(--turq);border:1px solid rgba(0,212,170,.5);border-radius:5px;padding:1px 7px;text-transform:uppercase;margin-left:8px;vertical-align:middle}
.badge-gated{display:inline-block;font-size:10.5px;letter-spacing:.04em;color:var(--mute);border:1px solid var(--line);border-radius:5px;padding:1px 7px;text-transform:uppercase}

/ code block /
.codewrap{border:1px solid var(--line);border-radius:13px;overflow:hidden;background:#0c0c0c}
.codehead{display:flex;align-items:center;justify-content:space-between;padding:10px 14px;background:var(--panel2);border-bottom:1px solid var(--line);font-size:12.5px;color:var(--mute);letter-spacing:.04em}
.codehead .lights{display:flex;gap:6px}
.codehead .lights i{width:10px;height:10px;border-radius:50%;display:inline-block;background:#333}
.codehead .lights i:nth-child(1){background:#e0392b}
.codehead .lights i:nth-child(2){background:var(--amber)}
.codehead .lights i:nth-child(3){background:var(--turq)}
pre{margin:0;padding:18px 18px;overflow-x:auto;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:13.5px;line-height:1.7;color:#cfcfd6}
.c-com{color:#6a8a78}
.c-kw{color:var(--purple)}
.c-str{color:var(--turq)}
.c-fn{color:#d9b3ea}
.c-num{color:var(--amber)}
.steps{display:flex;flex-wrap:wrap;gap:10px;margin-top:16px;color:var(--mute);font-size:13.5px}
.steps span{border:1px solid var(--line);border-radius:8px;padding:6px 11px;background:var(--panel)}
.steps b{color:var(--turq)}

/ how it works strip /
.flow{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin-top:8px}
.flow .step{border:1px solid var(--line);border-radius:12px;padding:15px;background:var(--panel)}
.flow .n{color:var(--purple);font-weight:800;font-size:12px;letter-spacing:.1em}
.flow .t{font-weight:700;font-size:15px;margin:5px 0 4px}
.flow .d{color:var(--mute);font-size:13px}

/ discover strip /
.discover{display:flex;flex-wrap:wrap;gap:10px;align-items:center;margin-top:8px}
.discover a{border:1px solid rgba(0,212,170,.4);border-radius:9px;padding:9px 13px;background:rgba(0,212,170,.04);font-family:ui-monospace,Menlo,monospace;font-size:13.5px}
.discover a:hover{border-color:var(--turq);text-decoration:none;background:rgba(0,212,170,.08)}

/ partner / CTA block */
.partner{border:1px solid rgba(155,89,182,.45);border-radius:16px;padding:30px;margin-top:8px;
background:radial-gradient(700px 320px at 80% -40%, rgba(155,89,182,.18), transparent 60%),linear-gradient(180deg,var(--panel),var(--panel2))}
.partner h2{font-size:27px}
.partner ul{margin:14px 0 24px;padding:0;list-style:none;color:#cfcfd6}
.partner li{padding:7px 0 7px 26px;position:relative}
.partner li::before{content:"→";position:absolute;left:0;color:var(--turq);font-weight:800}

footer{padding:34px 0 50px;color:var(--dim);font-size:13px;border-top:1px solid var(--line)}
footer .row{display:flex;flex-wrap:wrap;gap:18px;justify-content:space-between;align-items:center}
footer .tags{display:flex;flex-wrap:wrap;gap:8px}
footer .tag{border:1px solid var(--line);border-radius:6px;padding:3px 9px;color:var(--mute);font-size:11.5px;letter-spacing:.06em}
footer .links{display:flex;flex-wrap:wrap;gap:14px}
footer .links a{font-family:ui-monospace,Menlo,monospace;font-size:12.5px}

@media (max-width:560px){
.cta-row{gap:10px}
.btn{width:100%;text-align:center}
.cta-note{order:3}
table{font-size:13px}
}
</style>
</head>
<body>
<div class="space"><div class="stars"></div></div>

<header class="bar">
<div class="logo"><span class="dot"></span> MERCURY x402</div>
<nav>
<a class="navlink" href="#services">Catalog</a>  
<a class="navlink" href="#integrate">Integrate</a>  
<a class="navlink" href="#partner">Get in touch</a>
</nav>
</header>

<div class="status">
<span class="pill">Early</span>
<div><b>This is live on Base mainnet.</b> Everything below settles on <b>Base mainnet</b> in
<b>real USDC</b> — real per-call charges, no token, no coin. Built solo, early days.
Each call is a real payment your agent signs for a real result — I'm looking for the
<b>first agent builders to integrate</b> and shape where this goes. The x402 payment path is real
(Coinbase <code>x402-fetch</code> + <code>viem</code>); the dollars are test dollars.</div>
</div>

<section class="hero">
<div class="kicker">A shop your agent can pay, by itself</div>
<h1>Give your agent a <span class="glow">wallet</span> —<br>and a <span class="turq">shop it can pay</span> over HTTP 402.</h1>
<p class="sub">MERCURY is an <b>agent-to-agent storefront</b>. Your agent discovers what's for sale,
pays with its own wallet, and gets the goods — <b>no human, no signup, no API key, no checkout page</b>.
Just an HTTP <code>402 Payment Required</code> that your agent settles on-chain and retries.
Wire it in <b>about 5 lines</b>.</p>
<div class="cta-row">
<a class="btn btn-primary" href="#integrate">See the 5-line integration</a>
<a class="btn btn-ghost" href="/.well-known/x402">Read the discovery doc</a>
<span class="cta-note">Pay-per-call · Base mainnet · no signup</span>
</div>
</section>

<section id="why">
<div class="eyebrow">What MERCURY gives your agent</div>
<h2>Autonomous spending, with rails.</h2>
<p class="lead">x402 is the missing piece between "my agent can decide" and "my agent can pay."
MERCURY is a live seller on the other end of it — a real catalog your agent can browse and buy from on its own.</p>
<div class="grid">
<div class="card">
<div class="ic"><span class="b"></span>PAY-PER-CALL</div>
<h3>No keys, no accounts</h3>
<p>The price ships <em>in the 402 response</em>. Your agent signs, the facilitator settles, you get the result. No onboarding form, no dashboard, no monthly seat.</p>
</div>
<div class="card">
<div class="ic"><span class="b"></span>DISCOVERABLE</div>
<h3>A catalog it can read</h3>
<p>A free <code>/catalog</code> and a standard <code>/.well-known/x402</code> doc let your agent find what's for sale and the price <em>before</em> it ever pays. Discovery and checkout can't drift.</p>
</div>
<div class="card">
<div class="ic"><span class="b"></span>REAL DELIVERY</div>
<h3>It gets real data today</h3>
<p>Web-fetch delivers right now — pass a <code>?url=</code> and your agent gets clean page text back in the result. Mints (resources, 1-of-1 placeables, agent identity) are delivered on the mainnet step: gated and off until the minter is armed.</p>
</div>
<div class="card">
<div class="ic"><span class="b"></span>BOUNDED BY DESIGN</div>
<h3>Pay-per-call</h3>
<p>Every charge is real USDC on Base mainnet, signed per call and capped at the exact price shown — your agent never authorizes more than the listed amount for one result.</p>
</div>
</div>
</section>

<section id="services">
<div class="eyebrow">Priced in x402</div>
<h2>What's on the shelf.<span id="cat-live" class="live-tag stale">loading…</span></h2>
<p class="lead">Every line is a single HTTP route your agent can hit. Prices are in <b>USDC</b> on Base mainnet.
This table hydrates live from <a href="/catalog"><code>/catalog</code></a> — the same source of truth the pay-gate uses, so it can never drift from what you'll actually be charged.</p>

<table>
<thead>
<tr><th>Service</th><th>Route</th><th>Price</th><th>Type</th></tr>
</thead>
<tbody id="catalog-rows">

<tr class="live-sku"><td><span class="slug">web-fetch</span> <span class="badge-live">live</span></td><td class="mono">GET /buy/fetch?url=…</td><td><span class="price">$0.003</span></td><td><span class="kind">api · web-fetch</span></td></tr>
<tr><td><span class="slug">signal</span></td><td class="mono">GET /buy/signal</td><td><span class="price">$0 — free demo/sample</span></td><td><span class="kind">data</span></td></tr>
<tr class="gated"><td><span class="slug">matter</span></td><td class="mono">GET /buy/matter</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">resource</span></td></tr>
<tr class="gated"><td><span class="slug">brick</span></td><td class="mono">GET /buy/brick</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">resource</span></td></tr>
<tr class="gated"><td><span class="slug">antimatter</span></td><td class="mono">GET /buy/antimatter</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">resource</span></td></tr>
<tr class="gated"><td><span class="slug">dark-matter</span></td><td class="mono">GET /buy/dark-matter</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">resource</span></td></tr>
<tr class="gated"><td><span class="slug">shelf</span></td><td class="mono">GET /buy/shelf</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">placeable</span></td></tr>
<tr class="gated"><td><span class="slug">wand</span></td><td class="mono">GET /buy/wand</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">placeable</span></td></tr>
<tr class="gated"><td><span class="slug">agent</span></td><td class="mono">GET /buy/agent</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">agent</span></td></tr>
<tr class="gated"><td><span class="slug">api-render</span></td><td class="mono">GET /buy/api/render</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">api</span></td></tr>
<tr class="gated"><td><span class="slug">api-oracle</span></td><td class="mono">GET /buy/api/oracle</td><td><span class="badge-gated">gated — delivers on the mainnet step</span></td><td><span class="kind">api</span></td></tr>
</tbody>
</table>
<p class="price-note"><b>Live now:</b> <code>GET /buy/fetch?url=…</code> charges ~$0.003 USDC and returns clean page text — the one route that charges-and-delivers today. <code>signal</code> is a free $0 demo read. The mint and metered-API routes are <b>gated</b> — they deliver on the mainnet step, off until the minter is armed (for those, pass <code>?to=<your-wallet></code> when it's live so the good is sent to you).</p>
</section>

<section id="integrate">
<div class="eyebrow">Integrate in minutes</div>
<h2>One import. Five lines. Your agent can buy.</h2>
<p class="lead">It's the real Coinbase <code>x402-fetch</code> + <code>viem</code> under the hood. Wrap your wallet's
<code>fetch</code>, hit a paid route, and the 402 → sign → settle → deliver loop runs itself:</p>

<div class="codewrap">
<div class="codehead">
<span>agent.mjs</span>
<span class="lights"><i></i><i></i><i></i></span>
</div>
<pre><span class="c-kw">import</span> { wrapFetchWithPayment } <span class="c-kw">from</span> <span class="c-str">"x402-fetch"</span>;
<span class="c-kw">import</span> { privateKeyToAccount } <span class="c-kw">from</span> <span class="c-str">"viem/accounts"</span>;
<span class="c-kw">const</span> account = <span class="c-fn">privateKeyToAccount</span>(process.env.<span class="c-num">BUYER_PK</span>); <span class="c-com">// throwaway Base-Sepolia key w/ USDC</span>
<span class="c-kw">const</span> pay = <span class="c-fn">wrapFetchWithPayment</span>(fetch, account);
<span class="c-kw">const</span> res = <span class="c-kw">await</span> <span class="c-fn">pay</span>(<span class="c-str">"https://mercury-x402-jed.fly.dev/buy/fetch?url=https://example.com"</span>);
<span class="c-kw">const</span> good = <span class="c-kw">await</span> res.<span class="c-fn">json</span>(); <span class="c-com">// returns clean page text + title; settles ~$0.003 USDC. Live-delivering route.</span>
</pre>
</div>

<div class="steps">
<span><b>1.</b> <code>npm i x402-fetch viem</code></span>
<span><b>2.</b> fund your agent wallet with a little USDC on Base</span>
<span><b>3.</b> hit a paid route — settlement happens automatically on retry</span>
</div>

<div class="flow" style="margin-top:26px">
<div class="step"><div class="n">01</div><div class="t">Agent requests</div><div class="d">Hits a paid route. Gets <code>402</code> + price + terms.</div></div>
<div class="step"><div class="n">02</div><div class="t">Wallet signs</div><div class="d">The wrapped fetch signs a USDC payment automatically.</div></div>
<div class="step"><div class="n">03</div><div class="t">Facilitator settles</div><div class="d">Public x402 facilitator settles it on Base mainnet.</div></div>
<div class="step"><div class="n">04</div><div class="t">MERCURY delivers</div><div class="d">The handler runs and the goods come back in the JSON.</div></div>
</div>

<div style="margin-top:30px">
<div class="eyebrow">Discover it machine-first</div>
<div class="discover">
<a href="/catalog">GET /catalog</a>
<a href="/.well-known/x402">GET /.well-known/x402</a>
<span class="cta-note">Both free · JSON · never pay-gated</span>
</div>
</div>
</section>

<section id="partner">
<div class="partner">
<div class="eyebrow">First integrators wanted</div>
<h2>Want to wire your agent in?</h2>
<p class="lead" style="color:#cfcfd6">I want a handful of agent builders to wire MERCURY into a real agent and tell me what's
missing. You get hands-on help, direct input on the catalog, and first position when this goes live.</p>
<ul>
<li>Integrate in ~5 lines — your agent pays only per call, no signup.</li>
<li>Direct line to the person building it; your feedback shapes the roadmap.</li>
<li>I'll help you wire it into your agent and get the first paid call settling.</li>
<li>No token, no pump, no "send us money." Honest, early, real protocol.</li>
</ul>
<div class="cta-row">
<a class="btn btn-primary" href="/.well-known/x402">Discover & integrate — /.well-known/x402 →</a>
<a class="btn btn-ghost" href="/catalog">Browse the catalog →</a>
</div>
</div>
</section>

<footer>
<div class="row">
<div>MERCURY x402 · agent-to-agent commerce over HTTP 402.</div>
<div class="tags">
<span class="tag">LIVE</span>
<span class="tag">BASE MAINNET</span>
<span class="tag">REAL USDC</span>
<span class="tag">NO TOKEN</span>
<span class="tag">PAY-PER-CALL</span>
<span class="tag">BUILT SOLO</span>
</div>
</div>
<div class="links" style="margin-top:16px">
<a href="/catalog">/catalog</a>
<a href="/.well-known/x402">/.well-known/x402</a>
</div>
<div style="margin-top:14px;color:var(--dim);max-width:700px">
Built on the real Coinbase x402 stack (<code>x402-fetch</code> + <code>viem</code>). Payments settle on the
Base mainnet in real USDC — live, per-call, no token. This page describes an early but live service
and an invitation to integrate.
</div>
</footer>

</div>

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

From the repository

fetch

extract

markdown

metadata

links

robots

diff

notarize

headers

table

feed

availability

validate

batch

sitemap

dns

readability

redirect

Claude Desktop / Cursor

McpServers

More like this

Brave Search

🔎 GPT Researcher

Github SSE

AWS MCP Servers

`fetch`

`extract`

`markdown`

`metadata`

`links`

`robots`

`diff`

`notarize`

`headers`

`table`

`feed`

`availability`

`validate`

`batch`

`sitemap`

`dns`

`readability`

`redirect`