CryptoAPIs x402 Pay MCP
OfficialClick on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@CryptoAPIs x402 Pay MCPFetch https://api.example.com/v1/alpha and pay if it returns 402."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@cryptoapis-io/mcp-x402-pay
This is the BUYER side of x402 — the tool an agent uses to spend (pay for a resource). Merchants who want to charge for an API use the middleware SDK (
@cryptoapis-io/x402-merchant-sdk), not an MCP tool.
An MCP server that lets an AI agent find and pay x402-gated HTTP endpoints.
x402_pay— fetches a URL and, if the server returns402 Payment Required, authorizes the payment via the CryptoAPIs buyer service, signs locally, retries, and returns the paid response.x402_discover— browses the facilitator's catalogue of x402 resources and their prices, so an agent can find a paid API instead of only calling one it was handed.
Non-custodial: the private key is passed per request and never leaves the process (no HTTP server — stdio only).
Supported today: EVM (eip712, e.g. Base USDC) and Solana. Tron, Bitcoin/UTXO, XRP and Kaspa are
upcoming — wired but not yet enabled; paying on them returns a clear family_not_yet_supported
("coming soon") result.
Run
node dist/cli.js # stdio MCP server (no --api-key at startup; keys are per-tool-call)Related MCP server: PipRail
Prerequisite — an agent walletId
x402_pay pays from a CryptoAPIs agent wallet (walletId). Create one ONCE per blockchain+network
before paying — a single POST to the buyer API returns the id (non-custodial: you register only your
PUBLIC address):
curl -X POST https://ai.cryptoapis.io/x402/buyer/wallets \
-H "x-api-key: $CRYPTOAPIS_API_KEY" -H "content-type: application/json" \
-d '{"blockchain":"base","network":"eip155:8453","address":"0xYourAddress"}'
# → { "walletId": "…" }network MUST be the CAIP-2 id (eip155:8453, solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp, …), not a
bare name — and exactly one of address (any chain; required for Solana/Kaspa) or xpub
(xpub-capable chains). A malformed body returns a clear 400 malformed_request. Set the returned id as
X402_WALLET_ID (or pass walletId).
Tool: x402_pay
Input | Required | Description |
| ✓ | the (possibly paywalled) resource |
| ✓ | your CryptoAPIs key (X402_BUYER feature) — only used to call the buyer |
| ✓ | the wallet record id from |
| ✓ | the wallet's EVM key — signs locally, never sent anywhere |
| the request to make | |
| restrict which CAIP-2 networks to pay on | |
| safety cap — refuse if the required atomic-unit amount exceeds it | |
| restrict WHICH SITES may be paid, e.g. |
Returns { status, paid, body, settlement? }. On a 402 with no acceptable option (or over maxAmount),
paid:false with a reason — nothing is signed or paid.
Tool: x402_discover
Browse the x402 "Bazaar" — the registered x402 resources and what each charges (spec §8).
Input | Required | Description |
| filter by resource type, e.g. | |
| page size, 1–100 (default 20) | |
| rows to skip, for paging (default 0) | |
| override the facilitator (QA/local) |
Returns { resources: [{ resource, type, x402Version, accepts, lastUpdated, metadata? }], pagination }.
Public — no API key, no wallet, spends nothing, so it is always safe to call. Note accepts[].amount
is in atomic units (USDC 6-decimals: "10000" = $0.01) — convert before quoting a price to a user.
Pass a chosen resource to x402_pay to actually buy it.
Flow
fetch(url). Not 402 → return it.402 → pick an
acceptsentry (allowlist-aware), authorize via buyer/authorize→ the signing artifact.Sign locally (
@cryptoapis-io/mcp-signerevm_signtyped-data) → build the x402PaymentPayload(wire scheme is alwaysexact; the family is innetwork).Retry with the base64
X-PAYMENTheader; return the paid response + theX-PAYMENT-RESPONSEsettlement.
Security
The private key is a tool parameter and may be logged by MCP clients or stored in conversation
history — use only in trusted local environments. This mirrors @cryptoapis-io/mcp-signer.
Available Tools
2 toolsx402_discoverA
Discover x402-gated APIs you can pay for — browse the facilitator's Bazaar catalogue of registered x402 resources, each with the price and payment terms it accepts. Use this BEFORE x402_pay whenever you need to FIND a paid endpoint rather than call one you were already given: the pay tool only fetches a URL you hand it, so this is the only way to locate a monetized API on your own. Returns { resources: [{ resource, type, x402Version, accepts: [{ scheme, network, amount, asset, payTo }], lastUpdated, metadata? }], pagination: { limit, offset, total } } — amount is in ATOMIC units (USDC 6-decimals: "10000" = $0.01), so convert before quoting a price to the user. PUBLIC: needs no API key, no wallet and spends nothing, so it is always safe to call. Filter with type (e.g. "http") and page with limit/offset. Then pass a chosen resource URL to x402_pay to actually buy it.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Filter by resource type, e.g. "http". Omit to list every type. | |
| limit | No | Max results to return, 1-100 (default 20). The facilitator clamps out-of-range values rather than erroring. | |
| offset | No | How many results to skip, for paging (default 0). Use with `pagination.total` from a previous call. | |
| facilitatorBaseUrl | No | Override the facilitator base URL (default https://ai.cryptoapis.io/x402/merchant). Useful against QA/local. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and succeeds. It discloses that the call is 'PUBLIC: needs no API key, no wallet and spends nothing, so it is always safe to call,' and warns that `amount` is in ATOMIC units (with a conversion example). These are behavioral traits beyond what the schema/annotations convey, essential for an agent to safely invoke the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately long but each sentence earns its place: purpose, sibling differentiation, return structure, atomic-unit caveat, safety, and filtering/pagination guidance. It is front-loaded with the main purpose and flows logically. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description fully compensates by detailing the return shape ({ resources: [...], pagination: {...} }), explaining atomic unit conversion, and noting safety. It also covers filtering and pagination usage. For a moderately complex tool with no annotations or output schema, this description is comprehensive enough for correct selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description mentions 'Filter with `type` (e.g. "http") and page with `limit`/`offset`,' but this largely restates the schema descriptions and adds minimal new meaning. It does contextualize parameters in the workflow, but doesn't go beyond what the schema already provides, so it remains at baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Discover x402-gated APIs you can pay for — browse the facilitator's Bazaar catalogue of registered x402 resources.' It uses a specific verb ('Discover') and resource, and explicitly distinguishes from its sibling x402_pay by noting that the pay tool only fetches a URL you already have, making this the only way to locate a paid endpoint independently.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit guidance: 'Use this BEFORE x402_pay whenever you need to FIND a paid endpoint rather than call one you were already given.' It also provides follow-up direction ('Then pass a chosen `resource` URL to x402_pay') and clarifies exclusions (when you already have a URL, use pay instead). This fully covers when-to-use and alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
x402_payA
Fetch an HTTP resource and, if it returns 402 Payment Required, pay it automatically with x402 and return the paid response. On a 402 it: parses the merchant's price, authorizes via the CryptoAPIs buyer /authorize, signs the payment LOCALLY (non-custodial — the key never leaves this process), and retries with the X-PAYMENT header. Returns { status, paid, body, settlement? }. Supported today: EVM (eip712, e.g. Base USDC) and Solana. Tron, UTXO (bitcoin/ltc/doge/dash/bch/zcash), Kaspa and XRP are UPCOMING — wired but not yet enabled, and paying on them returns a clear coming-soon (family_not_yet_supported) result. Set CRYPTOAPIS_API_KEY + X402_WALLET_ID once, plus the signing key(s) for the chain(s) you pay on: X402_PRIVATE_KEY (EVM hex), X402_SVM_SECRET (base58). A scheme with no configured key errors cleanly (never mis-signs). Env vars keep keys OUT of tool-call logs. Use allowedNetworks to restrict chains, maxAmount as a per-call spend cap, and allowedHosts to restrict WHICH SITES may be paid (a url outside the list is refused before any network call; set X402_ALLOWED_HOSTS in the MCP config to pin it outside the model's reach). SECURITY: this tool holds spending keys — use only in trusted local environments, and prefer pinning allowedHosts + maxAmount via env for unattended runs.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The (possibly paywalled) resource URL to fetch | |
| body | No | Request body (string; set content-type via headers if needed) | |
| apiKey | No | Your CryptoAPIs API key with the X402_BUYER feature (used only to call the buyer /authorize). Falls back to the CRYPTOAPIS_API_KEY env var — set it once and omit this. | |
| method | No | HTTP method (default GET) | |
| headers | No | Extra request headers | |
| tronKey | No | Tron private key (hex). Falls back to X402_TRON_KEY, then to privateKey/X402_PRIVATE_KEY (same secp256k1 curve). | |
| utxoWif | No | UTXO private key in WIF format — signs utxo-transaction payments (bitcoin/ltc/doge/dash/bch/zcash). Falls back to X402_UTXO_WIF. | |
| xrpSeed | No | XRP secret/seed (base58, e.g. s...) — signs xrp-transaction payments. Falls back to X402_XRP_SEED. | |
| kaspaKey | No | Kaspa private key (hex, 32 bytes) — signs kaspa-transaction payments. Falls back to X402_KASPA_KEY. | |
| walletId | No | The CryptoAPIs buyer-service wallet RECORD ID (the id returned by POST /wallets) — NOT the on-chain address; passing an address returns wallet_not_found. Falls back to the X402_WALLET_ID env var. Create one first (once per blockchain+network): POST https://ai.cryptoapis.io/x402/buyer/wallets with {blockchain, network (CAIP-2 id like eip155:8453 or solana:<genesisHash> — NOT a bare name), address (your public address; required for Solana/Kaspa)} → returns walletId. | |
| maxAmount | No | Optional safety cap: refuse to pay if the required atomic-unit amount exceeds this | |
| svmSecret | No | Solana secret key, base58-encoded (64-byte keypair secret) — signs svm-transaction payments. Falls back to X402_SVM_SECRET. | |
| privateKey | No | EVM private key (hex, 0x optional) — signs the eip712 (EVM) payment, and Tron by default. Falls back to X402_PRIVATE_KEY. SECURITY: trusted local environments only. | |
| allowedHosts | No | Restrict WHICH HOSTS may be paid, e.g. ["api.acme.com"] (a leading dot matches subdomains: ".acme.com"). A url outside the list is refused BEFORE any network call. Falls back to the X402_ALLOWED_HOSTS env var (comma-separated) — set it there to pin the allowlist OUTSIDE the model's reach, so a prompt-injected url cannot widen it. | |
| buyerBaseUrl | No | Override the buyer service base URL (default https://ai.cryptoapis.io/x402/buyer) | |
| allowedNetworks | No | Restrict which CAIP-2 networks to pay on (e.g. ["eip155:8453"]) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral disclosure. It explicitly states that signing is LOCAL and non-custodial ('key never leaves this process'), explains the retry with X-PAYMENT header, details the return shape, and discloses error behavior ('errors cleanly (never mis-signs)'). It also highlights security tradeoffs (holding spending keys, env var protection, allowlist pinning). This is exemplary transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a dense, single paragraph but is front-loaded with the core action and then structured into relevant sections (flow, supported chains, setup, safety, security). Every sentence conveys non-obvious information, and no content is filler. It could be slightly more scannable with line breaks, but the content justifies the length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 16 parameters and no output schema, the description covers all essential context: supported blockchains, key configuration per chain, return format, error semantics, security warnings, and safety mechanisms. It even explains how to create a walletId. The lack of an output schema is mitigated by explicitly specifying 'Returns { status, paid, body, settlement? }'. This is complete for a tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the shared env-var fallback pattern, the walletId vs address distinction, and the security rationale for params like allowedHosts and maxAmount. It references several params directly, but not all 16—though the schema descriptions already handle those. Overall it meaningfully enriches setup and intent without fully compensating for every param.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource+behavior: 'Fetch an HTTP resource and, if it returns 402 Payment Required, pay it automatically with x402 and return the paid response.' It clearly distinguishes from sibling x402_discover by focusing on the payment execution flow rather than discovery. The step-by-step breakdown of the 402 handling further reinforces a unique, well-defined purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool (on any 402-paywalled resource) and provides explicit guidance on configuration, supported networks, and safety controls. It notes that Tron/UTXO/etc. are 'UPCOMING' and return a coming-soon error, which implicitly tells users not to rely on those yet. It doesn't explicitly contrast with x402_discover, but the usage context is unambiguous and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
2 tool updates
v0.3.0- First observed
x402_discover - First observed
x402_pay
TDQS
The two tools are cleanly separated: x402_discover is for finding monetized endpoints, while x402_pay is for paying them. There is no overlap or ambiguity between their purposes.
Both tool names follow a consistent x402_ + verb pattern (discover, pay). The prefix clearly ties them to the domain, and the verbs are precise and predictable.
With only 2 tools, the set is on the small side, but the server's purpose is extremely focused on a single payment workflow. The count feels slightly thin but reasonable for the narrow scope.
The surface covers the essential flow: discover a paid resource, then pay for it. Minor gaps exist (e.g., no explicit payment status or history retrieval beyond the settlement info returned by pay), but the core lifecycle is functional.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Pay for HTTP APIs and charge for your own: x402 micropayments in USDC on Base.
Discover machine-payable APIs, probe x402 payment terms, and run seller operations. Non-custodial.
Agent x402 Paywall MCP — Coinbase HTTP 402 protocol + on-chain settlement. Agents pay per-call
x402 paid API tools for AI agents on Solana: crypto safety, market data, KYB/AML verification.
Related MCP Servers
AlicenseNot gradedqualityDmaintenanceEnables AI agents to discover, pay for, and sell APIs using crypto on Solana and Base networks, with support for automated x402 payments.813MIT- AlicenseNot gradedqualityAmaintenanceA budget-bound x402 payment wallet for AI agents: it autonomously pays HTTP 402 payment-gated URLs across every major chain (EVM, Solana, and many non-EVM families). Self-custodial and backendless, your key, your RPC, with spend caps enforced before any on-chain send.8MIT

@arispay/payagent-mcpofficial
AlicenseAqualityAmaintenanceEnables AI agents to call paid APIs and settle HTTP 402 payment challenges with USDC on Base, without private keys ever being involved.7923MIT
@hpp-io/x402-mcp-bridgeofficial
AlicenseNot gradedqualityBmaintenanceEnables AI agents to autonomously pay for and discover services using HPP USDC.e over the x402 protocol, without API keys or manual signing.148Apache 2.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/CryptoAPIs-io/cryptoapis-mcp-x402-pay'
If you have feedback or need assistance with the MCP directory API, please join our Discord server