Skip to main content
Glama
CryptoAPIs-io

CryptoAPIs x402 Pay MCP

Official

@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 returns 402 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

url

the (possibly paywalled) resource

apiKey

your CryptoAPIs key (X402_BUYER feature) — only used to call the buyer /authorize

walletId

the wallet record id from POST /wallets (a registry _id) — NOT the on-chain address (an address gets wallet_not_found)

privateKey

the wallet's EVM key — signs locally, never sent anywhere

method/body/headers

the request to make

allowedNetworks

restrict which CAIP-2 networks to pay on

maxAmount

safety cap — refuse if the required atomic-unit amount exceeds it

allowedHosts

restrict WHICH SITES may be paid, e.g. ["api.acme.com"] (leading dot = subdomains). A url outside the list is refused before any network call. Falls back to X402_ALLOWED_HOSTS (comma-separated) — pin it there to keep the allowlist outside the model's reach

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

type

filter by resource type, e.g. "http"

limit

page size, 1–100 (default 20)

offset

rows to skip, for paging (default 0)

facilitatorBaseUrl

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

  1. fetch(url). Not 402 → return it.

  2. 402 → pick an accepts entry (allowlist-aware), authorize via buyer /authorize → the signing artifact.

  3. Sign locally (@cryptoapis-io/mcp-signer evm_sign typed-data) → build the x402 PaymentPayload (wire scheme is always exact; the family is in network).

  4. Retry with the base64 X-PAYMENT header; return the paid response + the X-PAYMENT-RESPONSE settlement.

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

ParametersJSON Schema
NameRequiredDescriptionDefault
typeNoFilter by resource type, e.g. "http". Omit to list every type.
limitNoMax results to return, 1-100 (default 20). The facilitator clamps out-of-range values rather than erroring.
offsetNoHow many results to skip, for paging (default 0). Use with `pagination.total` from a previous call.
facilitatorBaseUrlNoOverride the facilitator base URL (default https://ai.cryptoapis.io/x402/merchant). Useful against QA/local.

TDQS

A4.7/5.0
Behavior5/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines5/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesThe (possibly paywalled) resource URL to fetch
bodyNoRequest body (string; set content-type via headers if needed)
apiKeyNoYour 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.
methodNoHTTP method (default GET)
headersNoExtra request headers
tronKeyNoTron private key (hex). Falls back to X402_TRON_KEY, then to privateKey/X402_PRIVATE_KEY (same secp256k1 curve).
utxoWifNoUTXO private key in WIF format — signs utxo-transaction payments (bitcoin/ltc/doge/dash/bch/zcash). Falls back to X402_UTXO_WIF.
xrpSeedNoXRP secret/seed (base58, e.g. s...) — signs xrp-transaction payments. Falls back to X402_XRP_SEED.
kaspaKeyNoKaspa private key (hex, 32 bytes) — signs kaspa-transaction payments. Falls back to X402_KASPA_KEY.
walletIdNoThe 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.
maxAmountNoOptional safety cap: refuse to pay if the required atomic-unit amount exceeds this
svmSecretNoSolana secret key, base58-encoded (64-byte keypair secret) — signs svm-transaction payments. Falls back to X402_SVM_SECRET.
privateKeyNoEVM 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.
allowedHostsNoRestrict 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.
buyerBaseUrlNoOverride the buyer service base URL (default https://ai.cryptoapis.io/x402/buyer)
allowedNetworksNoRestrict which CAIP-2 networks to pay on (e.g. ["eip155:8453"])

TDQS

A4.6/5.0
Behavior5/5

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.

Conciseness4/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 2 tool updatesv0.3.0
    • First observedx402_discover
    • First observedx402_pay

TDQS

A4.6/5.0
Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivitySlowing
ResponsivenessUnresponsive

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

Related MCP Servers

  • A
    license
    Not graded
    quality
    A
    maintenance
    A 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.
    8
    MIT

Latest Blog Posts

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