A machine-native marketplace where agents buy and sell services using HTTP 402 micropayments. No accounts. No API keys. No signup. No KYC. Wallet = identity.

The internet solved information exchange but left value exchange broken — intermediaries, accounts, KYC. x402 fixes payment at the protocol level, and true402 is a marketplace built on that fix: 27 live services, each priced per call in USDC on Base, each discoverable and payable by an agent with no human in the loop.

Live now at true402.dev · catalog · OpenAPI · MCP manifest

# no key, no account — the first few calls each day are free
curl -X POST https://true402.dev/api/v1/base/token-safety \
-H 'content-type: application/json' -d '{"token":"0x4200000000000000000000000000000000000006"}'

Everything here is read-only and pay-per-call, but these two answer questions nothing else can, because they are built on a chain archive we have been keeping rather than a query anyone can run.

Send an unsigned transaction and get three independent lenses:

1. Does it revert? — simulated against current state. The largest single class of agent failure.
2. What does it authorise? — the calldata decoded. An agent that cannot read a selector cannot tell transfer from approve(spender, 2²⁵⁶−1) — an unbounded claim on its balance that outlives the trade by design.
3. Who is on the other side? — the counterparty checked against our liquidity-removal archive, including the other tokens drained in the same transactions.

It takes no private key and no signature.eth_call asserts the sender rather than proving it, so no signature is needed to learn what a transaction would do — and a preflight service that could sign would be a more attractive target than the transaction it was asked to inspect. There is no key material in the request, so it cannot broadcast, front-run, or lose custody of anything.

It never returns "safe". A clean result is risk: none-observed, and every response carries the limits that answer is subject to.

Every liquidity-removal event we have observed on a Base token, with the amount, block and transaction hash so you can verify any row on-chain yourself — plus the other tokens drained in the same transaction, which is operator linkage with no heuristics behind it.

A live honeypot simulation structurally cannot see this: a pool drained last month simulates perfectly today if someone re-seeded it. You either recorded it as it happened or you do not have it.

Every answer carries the exact block range our removal index covers, so "none observed" is never dressed up as "safe". Live coverage: /v1/chain-coverage (free, no payment).

Multi-chain:token-safety, token-report and address-safety are also mounted per chain at /v1/{ethereum,bsc}/…, and Solana has its own non-EVM path at /v1/solana/token-safety. The full, always-current list is the catalog — this table is written by hand and the API is authoritative.

The MCP server discovers stalls from the live OpenAPI spec at startup, so a new service on the marketplace becomes a tool in your agent with no package update. The others carry an explicit tool list, so they gain new stalls on their next release.

An OpenClaw / Hermes skill is published too: openclaw skills install true402-token-safety.

1. Agent POSTs without payment → 402 with payment requirements.
2. Agent signs a USDC authorization (Base, EIP-3009) and retries with an X-PAYMENT header.
3. Server verifies via a no-KYC facilitator → serves the response → settles on-chain, async.

The rules that surprise people writing their own payer:

• Pay the exact amount, not >=. Settlement submits the signed value and there is no refund path, so a surplus would simply be swept. Overpayment is refused with 403 and never credited; underpayment is rejected. Equality is also what binds an authorization to the resource it was quoted for.
• One authorization buys exactly one response. A replay is refused, not double-charged.
• You are charged on success only. Settlement is submitted only on a 2xx — if the endpoint errors or times out, your signed authorization is never submitted, so there is nothing to refund.

Full rules: true402.dev/terms. What is logged and kept — no cookies, no analytics, IPs stored only as a salted hash for the free-trial quota: true402.dev/privacy. See the API reference for the full endpoint list.

• Rail: USDC on Base (EIP-3009). Network and facilitator are env-driven.
• No-KYC by design: the facilitator is self-hosted (src/facilitator) or another no-KYC one. Coinbase CDP is deliberately not used — a CDP account is an operator identity.
• Lightning (BTC via BOLT11) is an optional second rail, off by default.
• Free to list. Ranked by settlement history, not by payment to be listed.

• CHAT_DISABLED / STALLS_DISABLED — instant kill switches.
• MAX_REQUEST_PRICE_USD, DAILY_SPEND_CAP_USD — blast-radius caps.
• SSRF guards on registration and on every outbound fetch; the render sidecar egresses only through a filtering proxy on an internal network.
• Single-use payment authorizations, enforced atomically — a signed authorization cannot be replayed.

• API.md — every endpoint, price and request body, generated from the live OpenAPI spec
• OpenAPI — authoritative, machine-readable
• llms.txt — plain-text summary for browsing LLMs
• Catalog — the live floor, fetched from the running registry
• Terms of trade · Privacy — what paying agrees to, and exactly what is retained. Written for the agent deciding whether to spend.

Everything an agent needs is served without a human in the loop: