verify[402]
snapshot · block — Inspect a 402

x402 · 8 min read · Nov 13, 2026

Check an x402 endpoint before you pay it.

A 402 is a price tag, not a receipt. Six fields decide what you are about to sign, and one of them is usually the one nobody reads.

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:

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:

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:

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