Call these APIs from your agent

229 services, each a standard HTTP endpoint. No API keys, no sign-up, no subscription — and no wallet needed to start: 135 of them serve one free call a day if you ask for it with ?free=1, and a prepaid credit token covers the rest with nothing but an HTTP header. AI and metered services are always paid — each entry in the catalogue says which it is under freeTier. Pay per call in USDC over x402 only if you want to.

⚡ Quickstart — 30 seconds

Fastest path: add the MCP server to any MCP client. No key, no wallet, no config — it runs on the free tier as-is:

claude mcp add x402-bazaar -- npx -y x402-bazaar-mcp

Nothing to install at all? The same server is hosted at https://402.com.tr/mcp (Streamable HTTP, one tool per service) — paste that URL into any connector field. It is also listed on Smithery.

When you want more than the daily free call, add either a credit token (no wallet) or a wallet key — same command, one extra flag:

claude mcp add x402-bazaar -e X402_CREDIT_TOKEN=ck_… -- npx -y x402-bazaar-mcp
claude mcp add x402-bazaar -e AGENT_PRIVATE_KEY=0x… -- npx -y x402-bazaar-mcp

Or call a free-tier endpoint directly over HTTP — one free call per service per day, no wallet. The flag is required: without it you get the 402 challenge, which is deliberate so an unpaid probe always sees the price rather than an answer.

curl "https://402.com.tr/api/x402/wash-trading?address=0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed&days=0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed&free=1"
# or, same thing:  -H "x-402-free: 1"

Paying from code (no MCP)? The whole x402 flow is ~10 lines — the SDK handles the 402, signs a USDC payment and retries automatically:

import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY);
const client = new x402Client();
client.register("eip155:8453", new ExactEvmScheme(account));
const payFetch = wrapFetchWithPayment(fetch, client);

const res = await payFetch("https://402.com.tr/api/x402/token-risk?address=0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed");
console.log(await res.json()); // verdict + flags — paid in USDC on Base, automatically

The example above is token-risk, which has no free tier — it settles a payment on the first call, like every AI and metered service. On a free-tier service, once the daily call is used ?free=1 returns a teaser preview plus an HTTP 402; wire the payment and your agent pays a few cents in USDC per call, gasless on Base.

1. Discover services (machine-readable)

Crawl the catalog for every endpoint, price, and input schema:

GET https://402.com.tr/.well-known/x402
GET https://402.com.tr/api/catalog

2. Call an endpoint with x402

Hit the endpoint, get a 402, pay, and the SDK retries automatically. Example with @x402/fetch:

import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.AGENT_PRIVATE_KEY); // holds USDC on Base
const client = new x402Client();
client.register("eip155:8453", new ExactEvmScheme(account));
const fetchWithPay = wrapFetchWithPayment(fetch, client);

// Example: Token Risk Check ($0.03)
const res = await fetchWithPay(
  "https://402.com.tr/api/x402/token-risk?address=..."
);
console.log(await res.json());

The agent wallet needs only USDC on Base — gas is paid by the facilitator (x402 is gasless for the payer).

2b. Or prepay credits — no signature per call

Pay once with x402 on buy-credits (tier = 0.25, 1, 5 or 20 USD) and get a bearer token. Later calls send it as a header and debit the balance — no wallet, no signing, no settlement latency per call:

// one-time (needs a wallet): pay the pack via x402
const buy = await fetchWithPay("https://402.com.tr/api/x402/buy-credits?tier=1");
const { data } = await buy.json(); // data.creditToken = "ck_…" — shown ONCE, store it

// every later call: just a header, no wallet involved
const res = await fetch(
  "https://402.com.tr/api/x402/token-risk?address=0x4ed4…efed",
  { headers: { "x-credit-token": "ck_…" } }
); // response header x-credit-balance = remaining cents

One settlement mints the pack ($5 and $20 tiers carry a bonus); after that the agent runs walletless. Balance lasts 180 days.

2c. Agents on NEAR

Chain Signatures: a NEAR account can control an EVM address and sign the x402 payment on Base directly — the standard flow above, signed through the NEAR MPC signer. The derived address needs USDC on Base; gas is paid by the facilitator.

No USDC on Base? Buy a credit pack with any asset NEAR Intents routes (NEAR, USDC on NEAR, BTC, SOL, …). It is swapped to USDC on Base and you get the same x-credit-token as above:

// 1. create an order — returns depositAddress, amountIn, orderId, orderSecret
const order = await (await fetch("https://402.com.tr/api/credits/near/quote", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ tier: "5", originAsset: "nep141:wrap.near", refundTo: "you.near" }),
})).json();

// 2. send order.pay.amountIn of your asset to order.pay.depositAddress

// 3. poll until SUCCESS — the response carries creditToken ("ck_…")
const s = await (await fetch(
  "https://402.com.tr/api/credits/near/status?orderId=" + order.orderId,
  { headers: { "x-order-secret": order.orderSecret } }
)).json();

Quoted as an exact output, so the swap cost is on the payer and any unused input is refunded by NEAR Intents. Polling again after success returns the same token.

3. Use as MCP tools (easiest)

Every service appears as a tool via the published x402-bazaar-mcp package — the same config works everywhere. No code to write:

{
  "mcpServers": {
    "x402-bazaar": {
      "command": "npx",
      "args": ["-y", "x402-bazaar-mcp"],
      "env": { "X402_CREDIT_TOKEN": "ck_YOUR_CREDIT_TOKEN" }
    }
  }
}

Add to your client's MCP config (per-host file paths in the README), restart, and the tools appear. With no env at all it runs on the free tier; set X402_CREDIT_TOKEN (from buy-credits, recommended) or AGENT_PRIVATE_KEY(Base wallet with USDC — the key never leaves your machine) for paid calls. Also on the official MCP Registry & Smithery.

Once bound, tell your agent to bind these first: x402_seller_check (before paying an endpoint), agent_pay_gate (before sending USDC), pre_trade_gate (any token), b20_gate (Base-native B20 tokens, one of a 30-tool suite), sign_guard (before signing a tx).

Holding tokenized equities? b20_safetycovers every one of Coinbase's on Base and answers “is this the real one” from the transfer-policy administrator on chain instead of a hardcoded address list — a lookalike can copy the ticker, the name and a 0xb200… vanity address, but not the policy admin. It reports holder-eligibility gating and gated mint as the regulated shape they are, not as danger.

Prefer to build your own? See the examples folder for a direct @x402/fetch caller and a custom AgentKit action.

Available services