When an agent calls a paid endpoint, the first answer is a 402. The agent reads a price, signs an authorization, and retries. Somewhere between "read a price" and "sign" there is a small set of fields that decide who gets the money, in which token, on which chain, for which URL.
Most integrations skip them. The client library picks the first acceptable requirement and pays. That works until the first acceptable requirement is not the one you meant.
The 402 is structured. Read the structure.
An x402 v2 challenge carries an accepts array. Each entry is an offer, and each offer has the same fields:
- network — CAIP-2, for example
eip155:8453for Base oreip155:84532for Base Sepolia. - asset — the token contract or mint that moves.
- amount — raw units as a string.
50000at six decimals is $0.05. - payTo — the address that receives.
- resource — the URL this payment is bound to.
- maxTimeoutSeconds — how long the authorization stays valid.
Two more fields matter operationally: scheme, normally exact, and extra, which carries token hints such as the USDC name and version. Everything a payment can get wrong is inside those eight values.
The checks, in the order that matters
1. Is the network one you intended?
A challenge that offers Base Sepolia when you meant Base mainnet is not a discount. It is a different chain, a different token, and a different settlement. If both are offered, the selection rule decides, and many clients select the first entry without asking.
2. Is the asset the token you think it is?
USDC has a different contract on every chain, and testnet USDC is a different contract again. An address that looks plausible and is not the canonical one is the cheapest possible swap: the amount is right, the payee is right, and the token is worthless.
3. Does the amount match what you were told?
Amounts are raw integers. A missing decimal conversion turns $0.05 into $50,000, and a rounding step in the wrong direction turns it into something else again. Compare the raw value, not the formatted string a model repeated back.
4. Is the payee the seller?
This is the one that gets skipped. payTo is just an address. If it changed since the last call, nothing in the protocol says so. A caller-supplied allowlist is a weak check. A seller-signed manifest fetched from a pinned origin is a stronger one, because it does not come from inside the 402 it is describing.
5. Is the resource the URL you called?
The challenge names the resource it is for. A payment signed for one URL and replayed against another is a valid signature on the wrong intent. If the resource is missing or names a different host, that is a finding, not a formatting detail.
6. How long does the authorization live?
maxTimeoutSeconds is the window between signing and settlement. A generous window is convenient for the seller and a longer exposure for the payer. It also decides how long a leaked authorization stays usable.
Ten seconds, no wallet
/inspect is free, needs no account, and never asks for a key. Paste an endpoint URL, or a challenge you already hold:
POST /inspect
{
"url": "https://vex402.online/verify",
"method": "POST"
}
It fetches the 402 once, reads the PAYMENT-REQUIRED header or the JSON body, and runs the same structural preflight an agent runs before signing. On our own /verify, the answer starts like this:
{
"verdict": "PASS",
"sign_allowed": true,
"challenge": {
"x402Version": 2,
"acceptCount": 2,
"accepts": [
{
"network": "eip155:84532",
"token": "USDC",
"amount": "50000",
"priceUsd": 0.05,
"payTo": "0xAeEF086DD4e436c69d6d0F684b4c9F4332df9cb",
"resource": "https://vex402.online/verify",
"maxTimeoutSeconds": 300
}
]
},
"checked": ["scheme", "network", "asset", "amount", "payee", "resource_url", "resource", "timeout"]
}
Read the verdict last. Read checked and notChecked first — they tell you what the answer is actually about.
What a failure looks like
The useful output is not "unsafe". It is a named field. Ask the inspector to compare the challenge against what you meant — the payee you expect, the asset you allow, the host you called, a ceiling on the amount — and a mismatch comes back as BLOCK with a reason you can disagree with:
payee_not_payout_wallet— the recipient is not on your allowlist.asset_not_in_policy— the token is not one you accept.resource_not_bound— the challenge does not name the URL you called, or names another host.amount_over_max— the raw amount exceeds your cap.
A named reason is the difference between a gate and a mascot. You can argue with a named reason, log it, and add a case to a test. You cannot argue with a green check.
What it will not tell you
On our own endpoint, notChecked currently has thirteen entries. The ones that matter most:
- whether the seller is honest, or the recipient is sanctioned;
- whether the facilitator will actually settle;
- whether the payee address is owned by the seller;
- whether this payment was already made under the same idempotency key;
- whether the tool output you are about to act on contains a prompt injection.
A PASS means the structural checks passed at that block. It does not mean the price is fair, and it does not mean the seller is who they claim to be. Those are different questions with different tools.
The one rule
Do not sign until you have a fresh receipt for the exact intent, and you have read notChecked. A receipt is not a guarantee. It is a record of what was checked, against which bytes, at which block, expiring at a stated time — which is exactly what you need to tell a false PASS from a bad day.
Check your own endpoint
If you run a paid x402 endpoint, paste its URL into /inspect. If it returns CAUTION or BLOCK on a field you did not expect, that is worth knowing before a buyer finds it instead. The check is free and the result is not published anywhere.
The ask
Bring an endpoint you are unsure about.
Send three: one you expect to pass, one you are unsure about, one you think should be blocked. I will run all three and reply with the raw verdict and the reason codes.
Next: Put a pre-signing gate in an MCP agent in 15 minutes. · All notes