# vet402 > Independent verification of the x402 agent-payment economy. vet402 buys from x402 endpoints, re-reads each payment on-chain, records what came back, checks it against the seller's output declaration when there is one, and publishes the results. It also scores payee wallets on Base, so an x402 API provider or a spending agent can check a counterparty before a payment settles. x402 is an HTTP 402 payment protocol for AI agents. An AI agent pays an x402 API with a stablecoin by answering HTTP 402, often in USDC. ## Questions ### What is x402? x402 is an HTTP 402 payment protocol for AI agents. A server answers 402 with payment terms, the caller pays on chain, often in USDC, and retries the request with proof of payment. https://vet402.com/x402 https://vet402.com/blog/what-is-x402 ### How do AI agents pay with stablecoins over x402? An AI agent pays an x402 API with a stablecoin by answering HTTP 402. The server returns payment terms that name an asset, often USDC, plus a network, an amount, and a recipient. The agent signs that transfer and retries the request with proof of payment. https://vet402.com/x402/stablecoin-payments ### How do you check an x402 seller before paying? Check an x402 seller before paying by reading the purchases vet402 has made from that seller and the decision those purchases support. The decision names the terms of the last purchase whose delivery vet402 confirmed. If the 402 in hand names a different recipient, asset, network, or scheme, or a higher amount, that offer is different from the one that was delivered. The amount is in 6-decimal ledger units: multiply it by 10^12 on BNB Chain and by 10 on Stellar before comparing. https://vet402.com/x402/check-a-seller ### Which chains does vet402 measure for x402 and MPP payments? vet402 measures Base (USDC over x402), Solana (USDC over x402), Tempo (USDC.e over MPP, the Machine Payments Protocol), XRPL (RLUSD over x402), Arc (USDC over x402), Celo (USDC over x402), Stellar (USDC over x402), Arbitrum One (USDC over x402), BNB Chain (USD1 over x402), and Avalanche C-Chain (USDC over x402). A count appears when that ledger read has a row for the chain. An empty read shows no counts. https://vet402.com/x402/chains https://vet402.com/x402/chains/base https://vet402.com/x402/chains/solana https://vet402.com/x402/chains/tempo https://vet402.com/x402/chains/xrpl https://vet402.com/x402/chains/arc https://vet402.com/x402/chains/celo https://vet402.com/x402/chains/stellar https://vet402.com/x402/chains/arbitrum-one https://vet402.com/x402/chains/bnb-chain https://vet402.com/x402/chains/avalanche-c-chain Under x402's exact scheme a settled payment is final, and proof of payment exists on-chain. A buyer still has no way to see, before paying, what a seller delivered. vet402 answers that with records of real purchases. Registries can be written for cents and directory metrics can be manufactured, so vet402 does not take either at face value. It measures, states which level of verification a result came from, and says "unverified" when it has not measured. Nothing on the site is presented as an estimate. Formerly named "Vouch"; renamed to vet402 in August 2026. The production URL is `vet402.com`. The GitHub repository is `kzmttkc/vet402` (the older `kzmttkc/agent-trust` URL still redirects there; cite the new one). Issued API keys and webhook headers keep the `vouch_` / `Vouch-` prefixes for backward compatibility — the old name appearing there is deliberate, not stale documentation. ## Verification levels Every word used below is defined in one sentence each at https://vet402.com/observatory/methodology#vocabulary, and the same definitions are published as `DefinedTermSet` structured data on that page and in https://vet402.com/llms-full.txt. This is the published methodology. A result is labelled by the level that produced it and never moves up a level: an L0 probe cannot report settlement, and an L3 opinion is never folded into an L0–L2 fact. L0, L1 and L2 verdicts ship live in the observatory (see "Implemented and live" below): L0 and L1 are full measurements; L2 is a deliberately minimal structural check — parses the response as JSON and confirms the seller's own declared required keys are present, nothing deeper — described exactly as such on https://vet402.com/observatory/methodology. L3 is not built and no opinion is published anywhere on the site. - **L0 Liveness** — does the endpoint answer correctly? Probe, no purchase. Output: pass / fail / unverified. - **L1 Settle-through** — does the payment settle, and does a non-empty 2xx come back? Real purchase. Output: n of m settled, n delivered, latency. settled = the transfer re-read on-chain; delivered = settled AND the paid request answered 2xx other than 202 Accepted, with a non-empty body. - **L2 Conformance** — does the response match the seller's own declaration? Purchase plus machine diff. Output: match / mismatch / no_declaration / not_checked. Decision and facts documents store conform, mismatch, undeclared, or not_checked: conform is written when the re-read L2 value (l2_reading) of the latest delivery is match, mismatch is written when that re-read value is mismatch (an older mismatch row with no recorded reason is re-read first, and a cut body reads not_checked), and in the other cases the decision word is not_checked when the current declaration names output (a required key or an example property) or when the purchase row of the latest delivery recorded a declaration and its re-read value is not_checked, and undeclared when neither holds; the latest delivery is read at any age, so a mismatch holds until a later delivery replaces it. - **L3 Quality** — is the content any good? Not built. No L3 opinion is published. What the API returns today is a different, older thing: a 0–100 trust or payee score banded ALLOW / WARN / BLOCK. It predates the levels and stays available to API and SDK callers during the transition; observatory verdicts replace it as they ship, and a score is never reported as an L0–L2 result. The front page states this relationship in §2.1. Scoring is fail-closed: an input that could not be read is never reported as an input that was checked and found fine. Such a verdict is marked `degraded`, is not cached, and returns BLOCK to callers, while the public profile pages say "Not verifiable right now" instead of publishing a number. ## Primary - https://vet402.com/ — the memo: problem, verification levels, what is live, what is still being built - https://vet402.com/observatory: the L0 register. The catalog is re-fetched on the schedule in Freshness. Endpoints are probed on a rolling schedule, not as a sweep of the catalog on one day. A probe uses the HTTP method the listing declares when the listing declares GET, POST, HEAD, or DELETE, and GET when the listing declares no method or a method outside that set. Two failures in a row on that probe can be published as fail. The share of active endpoints with a probe from the last 7 days is coverage7d on https://vet402.com/api/v1/observatory/state (activeEndpoints, measuredLast7d, pct). pct is null when activeEndpoints is 0. A published verdict is pass, fail, withdrawn, or unverified. When a probe has run, the Last probed column shows that time. The L1 column sits between the verdict and Last probed. A row that has not been probed shows no probe time. - https://vet402.com/observatory/state — aggregate rates for the whole observed catalog, broken out by chain - https://vet402.com/observatory/methodology — full definitions for L0 Liveness, L1 Settle-through and L2 Conformance: what each level measures, what it cannot measure, and the publication gate that keeps one bad sample from branding an endpoint dead - https://vet402.com/docs/api — API reference, including copy-paste curl commands that need no key - https://vet402.com/connect: start as a buyer, a seller or both, in three steps, with curl, TypeScript, Python, MCP, no-code, Express, Hono or Next.js. The single `vet402` package has the buyer and seller sides in one install: `npm install vet402`. - https://vet402.com/docs/mcp: the hosted MCP server at https://vet402.com/mcp. It returns what vet402 recorded when it paid x402 listings, is read only, needs no key, and costs nothing to call. - `GET /api/v1/check?url=` — the same answer as MCP `check_x402_seller`: what vet402 recorded when it paid an x402 URL (`recommendation`, `delivery`, the five latest purchases, `verified_terms`). Key-less; shares the per-IP rate limit with `/api/v1/resolve`. The CDN may serve a response up to 60 seconds old, and up to five more minutes while it refreshes in the background. Optional `method=` narrows the HTTP method like `/api/v1/resolve`. `url` must be https (http is 400 `invalid_url`). - `GET /api/v1/diagnose?url=` reads one unpaid 402 before anyone pays. No key and no wallet. vet402 returns ALLOW, WARN, or BLOCK, the cheapest payable accept, and one fix line per check. 20 requests a minute per IP. The fetch stops at 10 seconds and 64 KB. Private addresses are refused. A completed read may be cached for 60 seconds, and a shared cache may keep serving it for five more minutes while it refreshes. A listed URL also points at `GET /api/v1/check`. - https://vet402.com/accuracy — public accuracy ledger: past verdicts, outcomes, and misfire rate - https://vet402.com/leaderboard — register of recently verified subjects, ranked - https://vet402.com/payee — verify a payee, or look one up - https://vet402.com/corrections — every correction issued to a published result, and what does not count as one - https://vet402.com/operator-log — public, append-only record of every global operator override (network-wide blacklist), with the address, stated reason, and date; customer-private lists never appear here - https://vet402.com/faq — x402, ERC-8004, and how scoring works - https://vet402.com/x402/stablecoin-payments: how an AI agent pays an x402 API with a stablecoin, often USDC. - https://vet402.com/x402/check-a-seller: how to check an x402 seller before paying. - https://vet402.com/x402/chains: purchase results by chain, from the same ledger as the observatory. - [State of x402: November 2026](https://vet402.com/x402/report/2026-11): delivery after payment across vet402's purchases, by chain, as of 2026-11-09 (UTC). - https://vet402.com/signup — get an API key (free tier: 1,000 lookups / month) - https://vet402.com/blog — notes on agent-to-agent payments, x402, and verification - https://vet402.com/blog/rss.xml — the same posts as RSS - https://vet402.com/llms-full.txt — full FAQ and blog text, generated from the same modules the HTML uses - https://vet402.com/openapi.yaml — OpenAPI 3.1 of every public endpoint Public per-subject pages: `https://vet402.com/payee/{address}`, `https://vet402.com/agent/{agentId}`, and `https://vet402.com/observatory/e/{id}` (one endpoint's full L0/L1/L2 history). ## API — no key required These are open paths, rate-limited per IP. Nothing below needs an account. Every response on the JSON read paths and the CSV exports carries `RateLimit-Limit`, the ceiling for that path. `RateLimit-Remaining` and `RateLimit-Reset` are per-caller, so they are sent only on responses a shared cache does not replay to someone else — chiefly the `429`, which also carries `Retry-After`. A cached `200` deliberately omits them rather than handing you a counter that belongs to whoever populated the cache. A path under `/api/` that matches no route answers `404` as JSON (`{"error":"not_found","path":...}`), never as an HTML page. - `POST /api/v1/payment-proof` reads one seller PAYMENT-RESPONSE header (base64 JSON with success, transaction, network and payer) or a network plus a transaction hash. vet402 reads that transaction again on Base, Celo, Arbitrum One, Avalanche C-Chain, BNB Chain, Solana, Arc, Tempo, XRPL and Stellar and returns found, network, tx, block, from, to, asset, amount in atomic units, status, explorer and as_of. A chain outside that set comes back as unsupported_network. Keyless. 20 requests a minute per IP. The chain read stops at 8 seconds. This route does not pay and does not sign. - `GET /api/v1/accuracy` — the accuracy ledger as JSON. `slo.l1_probe_error_rate_pct` is the share of all L1 attempts in the last 7 days whose purchase run did not complete inside vet402 (`request_error` / `in_flight`, counts in `slo.l1_7d`); it is not the held share of the ledger export (`slo.l1_7d.held` of `slo.l1_7d.signed`) and not the "vet402's side" column of /sellers, which classifies each listed Base listing by its latest attempt of any date. Aggregate counts, and the same numbers /accuracy renders **with the same caveats attached**: the `interpretation` object carries the notes that qualify each rate — that a benchmark "detection" counts BLOCK *or* WARN and how many known-bad addresses stopped at WARN, that a 0% false-positive rate means "none were blocked" rather than "all were passed" and how many known-good addresses only reached WARN, and that a rate below the minimum sample is `null` rather than a number. Reading the JSON alone is enough; you are not being asked to parse the HTML to learn what a figure means - `GET /api/v1/payees/verify?wallet={address}&name={name}` — returns the exact message a payee must sign. Read-only, writes nothing. The message opens with `vet402.com — verified payee registration` and carries a `domain: vet402.com` line, so a signer can tell in the wallet's own signing view which site is asking; it also states the 10-minute validity and that the signature moves no funds. Fetch it rather than constructing it — signatures over the pre-2026-09-05 wording stopped verifying on 2026-09-21 - `POST /api/v1/payees/verify` — publish a verified-payee page and badge by posting that signed message. Free, signature required - `GET /api/v1/agents/verify` / `POST /api/v1/agents/verify` — the same claim flow for an ERC-8004 agent identity - `GET /api/v1/agents/{agentId}/passport` — machine-readable agent passport - `GET /api/badge/{address}.svg` — SVG badge for a payee wallet (states only whether a signed claim exists; carries no score, because a cached score on a third-party page would outlive its freshness window) - `GET /api/badge/agent/{agentId}.svg` — the same badge for an agent - `GET /api/badge/endpoint/{id}.svg` — receipt badge for one x402 endpoint, stating its measured settlement (paid attempts settled / paid attempts, minus the attempts on vet402's side, which the badge names as `vet402 side N`), facts only - `GET /api/transparency/operator-overrides` — the machine-readable twin of /operator-log: every global operator blacklist act with address, action, reason, and date; customer-private lists never appear - `GET /api/demo/score` — one fixed, publicly registered agent, scored live. Returns `live: false` rather than a stale or invented number when it cannot compute one, and `degraded: true` when the verdict was computed with an input it could not read. Freshness is explicit as `scoredAt` + `cacheExpiresAt`, the same pair the passport publishes — a cached value is up to five minutes old and says so - `GET /api/health` — service status Product spec §7.3 / §9.1 (2026-09-02) — object ids and measurement records, no key, per-IP limits stated on each: - `GET /api/v1/resolve?q=` — reverse lookup: whatever you hold in, the canonical Resource / Endpoint / Payee / Settlement ids out. `resource_id` = sha256(method + " " + canonical_url). Returns identifiers only, never a recommendation. 60/min - `GET /api/v1/resources/{resourceId}` — one Resource (sha256 hex) with its payees and links to `/decision`, `/facts` and the observatory page. 120/min - `GET /api/v1/endpoints/{endpointId}` — one Endpoint by `endpoint_id` (sha256 of origin + path prefix) or its observatory uuid. 120/min - `GET /api/v1/endpoints/{endpointId}/payees` — every `payee_id` (chain:address) declared under that endpoint. 120/min - `GET /api/v1/payees/{address}/endpoints` — every endpoint that declares that payee as payTo; a bare 0x address is read as Base, a bare base58 address as Solana. 120/min - `GET /api/v1/observatory/endpoints/{id}/facts` — the L0–L2 seller facts for one endpoint (liveness, settle-through with `n_probe_error` disclosed separately, conformance, availability, offer stability, 30-day settlements raw / real / test / measurement). Contains no score and no recommendation by design. 120/min - `GET /api/v1/census/summary?chain=&window=7d|30d` — settlement census: `settlements_raw` and `settlements_real` (self_deal, circular, test, and measurement excluded) always together, never merged, with attribution and source breakdowns and the definition text in the body. 60/min, cached up to 20 minutes (see Freshness) - `GET /api/v1/observatory/corrections?endpoint=&reason=&limit=&cursor=` — the correction log as JSON: every published verdict that later changed (`dispute_remeasure`, `settlement_backfill`, `reverify`, `path_template`) with `before` / `after`. No code path deletes or edits its rows, and since 2026-09-29 a ledger status change and its correction row are written in one database statement; the table is not write-protected against vet402 itself. Every row can be read (since 2026-09-29): at most 500 rows a page, `page.nextCursor` passed back as `cursor` returns the next older page (null on the last page), and `total` counts the rows matching `endpoint` and `reason` whatever the cursor — `?reason=settlement_backfill` gives the "Ledger status changes" count on /corrections. For a `purchase` row, `subject_id` is the `purchase_id` column of the ledger export. `settlement_path` names the path a `settlement_backfill` row took, worked out from `before` / `after` when the row is read: `verified_settled`, `claim_refuted`, `seller_named_tx_promoted` (the seller named the transaction in its payment response though its receipt did not say success — the export keeps `settlement_source=seller_claim` for it), `vet402_index_link`, `late_link_withdrawn`, `seller_named_tx_declined`, `other`. 60/min Verification proves control of a wallet or an agent identity by signature. It is not an endorsement, and the score is computed independently of it. ## API — API key required Send `Authorization: Bearer `. The decision route below also answers without a key (10/min per IP), and `/api/v1/resolve` needs none. Quotas and burst limits: https://vet402.com/docs/api#rate-limits - `GET /api/v1/resources/{resourceId}/decision?role=payer|payee&payer=&caller_dialect=v1|v2&allow_without_l1=` — product spec §8.3 / §9.1, the canonical integration since 2026-09-02: the pre-payment (`role=payer`) or pre-service (`role=payee`, requires `payer`) decision. `facts` (SellerFacts or BuyerFacts) and `recommendation` (ALLOW / WARN / BLOCK) travel in the same document with `reason_codes`, `freshness`, `evidence` and `rules_version`; the transitional `score` is left out unless you pass `include_score=1`, and then carries `superseded_by: "recommendation"`; it is not the basis of the recommendation. Every reason code, with its meaning, what it means for the payer and whether the seller can fix it: https://vet402.com/docs/api#reason-codes (the same list is `DecisionReasonCode` in the OpenAPI file). Rules 2026-11-13.1 (`rules_version`). Each paid attempt (one L1 purchase row) is sorted by one function, the same one /sellers, /api/v1/sellers/export.csv and this decision read: whether money moved, whether it delivered, and whose side a failure is on. Money moved when the payment settled on-chain, or when a settle_failed row carries a transaction vet402 verified; it did not move when vet402 signed nothing or the transaction the seller named was not found; otherwise it is not yet known. The outcome is one of: delivered (settled on-chain, then a 2xx other than 202 Accepted, with a non-empty body); pending (not yet known whether money moved: a receipt awaiting on-chain verification, a 2xx naming a transaction, or a signed attempt that failed less than 90 minutes ago while vet402 links late settlements; the ledger status is left as recorded); seller (the seller's side: vet402 can show from the row that the failure was not its own, and such a failure, of any kind, was seen at the listing on 2 or more different UTC days); vet402 (vet402's side: its wallet was short, it did not send the declared input, or one of its own limits or errors); unsorted (not sorted: held for vet402's own request shape, no charge taken, a paid answer with no result in it, seen on one UTC day so far, or vet402 cannot show the failure was not its own); not_bought (vet402 did not sign a payment, so it is not a purchase result). An attempt counts for or against the seller only when it delivered or is on the seller's side; every other signed attempt is left out with an `l1_not_counted_`* code (`l1_not_counted_held` counts held rows except seller_fixable_input, plus a receipt awaiting on-chain verification whose held_reason is empty). A settled 400 or 422 whose paid request carried every declared input and whose bodyHead parses as JSON with a structured input validation error (FastAPI/pydantic detail[].loc, zod issues[].path, or errors[].field|path|param with in or location on body or query, not free text, with every cited location on the request input, not payment, headers, cookies or authentication) is counted on the seller's side once seen on 2 different UTC days. In the decision it counts as a seller-side attempt (`l1_latest_failed` or `l1_never_delivered`, WARN) but never as `l1_paid_not_delivered` and never toward a BLOCK. /api/v1/sellers/export.csv follows /sellers. The ledger export.csv does not change. L1: after the last delivery in the 30-day window, an attempt that moved money and did not deliver adds `l1_paid_not_delivered`; it is a BLOCK only when two or more of them are on the seller's side (seen on 2 different UTC days), and a WARN otherwise, including when /sellers leaves them not sorted. A failure where no money moved is at most a WARN (`l1_never_delivered` when nothing was ever delivered). When no result came back and it is not yet known whether money moved (an empty 2xx with no settlement linked, a receipt still awaiting on-chain verification, or a signed attempt that failed less than 90 minutes ago), `l1_empty_2xx_settlement_unknown` makes it a WARN, never an ALLOW, until it settles. `l1_latest_failed` (something delivered, but the latest counted attempt did not) is a WARN. ALLOW needs a delivery within 30 days (`l1_basis`.fresh_days); otherwise `l1_stale` and a WARN, also the word when the only delivery is older than the window or every signed attempt is (`l1_not_attempted` means none was ever signed). `l1_basis` carries the counts, the last attempt, signed attempt and delivery, and the days since each. L0: `l0_fail` (two measured failures in a row) is a BLOCK. `l0_unverified` (not probed yet, no probe in the last 30 days, a URL with a path parameter vet402 cannot fill, a probe that could not complete, or one failure so far) is a WARN with `degraded: true`, next to `l0_unverified_; unverified is not a failure. L2: `l2_mismatch` is a BLOCK when the evidence names missing keys (`mismatch_kind missing_keys`), otherwise `l2_mismatch_unexplained` and a WARN. L2 reads the latest delivery at any age, so a mismatch holds until a later delivery replaces it. A listing that declares an output schema but whose latest delivery vet402 has not checked against it (no delivery, a body over 256 KiB or cut off) is `l2_not_checked`, a WARN; `l2_undeclared` means neither the catalog nor the purchase row of the latest delivery gives an output declaration to check against. `l2_conform_no_required_keys` next to `l2_conform` means the declaration marks no key as required, so vet402 checked that the body is a JSON object or array, not which keys it carries. verified_terms.amount is in 6-decimal ledger units: multiply it by 10^12 on BNB Chain and by 10 on Stellar before comparing it with a 402. Every code, its effect and whether the seller can fix it: https://vet402.com/docs/api#reason-codes. With `role=payee`, `facts.short_interval_payment_rate` is the share of gaps of 60 s or shorter between a payer's settled payments to the same resource. It describes payment timing and does not change the recommendation, and settled payments do not show whether a payment was a retry. `retry_burst_rate` is its former name, with the same value. `verified_terms` (since 2026-09-29, role=payer) carries the terms vet402 actually paid on the last purchase whose delivery it confirmed — `pay_to`, `asset`, `amount` (vet402's 6-decimal ledger units, not always the asset's own base units: multiply by 10^12 on BNB Chain and by 10 on Stellar before comparing it with a 402), `decimals` (always 6), `network`, `scheme`, `protocol`, `verified_at` — or null when nothing was ever delivered, and null on XRPL until the issuer is recorded (a currency code alone cannot tell RLUSD from a look-alike). 0x addresses are lowercase. Before you pay, compare it with the 402 you received: if the 402's payTo, asset, network or scheme differ, or its amount is higher, do not pay. An ALLOW is the fact that these terms delivered, not a guarantee for a different recipient or a higher price. Limit of the method: vet402 buys with a fixed, published User-Agent, so a seller could answer vet402 differently from other buyers; other buyers' settlements show that they paid, not that they received, so the decision cannot detect this. Send `Idempotency-Key` to retry without spending a second rate-limit unit. Key-less at 10/min per IP since 2026-09-07 (same body; 429 `rate_limited` when spent). Your own policy (role=payer, since 2026-09-07): add `amount_usd`, `max_per_tx_usd` (default 1), `min_l1_deliveries` and/or `require_vet402_allow` (default true — a WARN refuses with `payee_recommendation_not_allow`, as the SDK's default does; `false` waives the WARN and needs `min_l1_deliveries` ≥ 1, else 400 `invalid_policy`) and the same document gains `caller_policy` — your rule applied server-side in the SDK's own words (`verdict` ALLOW | REFUSE, `reason_codes` `price_above_ceiling` / `evidence_unavailable` / `payee_recommendation_block` / `payee_recommendation_not_allow` / `insufficient_delivery_evidence`, `not_evaluated` naming what the server did not check, always `min_subgraph_receipts`). It never rewrites `recommendation`; without those queries the body is unchanged The older score endpoints below need the same key. They return the transitional 0–100 score described at the top of this file (deprecated; the decision document above is the current integration) and the operational calls around it. Since 2026-09-29 each score response says so itself: `deprecated: true`, a `deprecation` object naming the decision endpoint to use instead, and the `Deprecation` / `Link` headers. The score's value is unchanged, and it rates a wallet or agent as a whole, so it can read ALLOW where the decision for one endpoint paid to that wallet reads WARN or BLOCK; decide with the decision endpoint: - `GET /api/v1/payees/{address}/score` — the buyer-side question: should this payee be paid? - `GET /api/v1/wallets/{address}/score` — trust score by wallet address (the path x402 middleware uses) - `GET /api/v1/agents/{agentId}/score` — trust score by ERC-8004 agent ID (optional `?wallet=` verifies the registered wallet; optional `?chain=` selects an enabled chain, default Base) - `POST /api/v1/scores/batch` — score up to 25 agents in one request - `GET /api/v1/agents/{agentId}/history` — score history snapshots (paid plans) - `POST /api/v1/payments/x402` — attest an x402 payment settlement after verification (idempotent on txHash) - `POST /api/v1/events/{trustEventId}/outcome` — report what actually happened after a verdict; this is what the public accuracy ledger is computed from - `GET|POST /api/v1/watchlist`, `DELETE /api/v1/watchlist/{id}` — watch an agent or wallet; verdict changes arrive as a `watch.verdict_changed` webhook - `GET|POST /api/v1/webhooks`, `DELETE /api/v1/webhooks/{id}` — webhook subscriptions ## Open data — no key, and quotable The reads below need no authentication and are published under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). That licence covers /api/v1/observatory/state, /api/v1/observatory/history, /api/v1/observatory/export.csv, /api/v1/observatory/l0/export.csv, /api/v1/sellers/export.csv, and the figures rendered on /impact. Reuse, redistribute, chart or republish them, commercially or otherwise, provided the source is named. The code is MIT. The data licence is separate and is in LICENSE-DATA in the repository. - `GET /api/v1/observatory/state` — the aggregate snapshot. Carries `license`, `licenseUrl`, `retrievedAt` and `cite` in the body. Top-level totals include testnets; `byChain` is mainnet-only (`byChainScope`), so `sum(byChain)` can be below `totalEndpoints`. `publishedPass` counts endpoints on record whose latest L0 probe passed, including delisted endpoints, so it can exceed `activeEndpoints`; `publishedPassActive` is the part on active records, and `publishedPassActiveProbeOlderThan7d` the part of that last probed more than 7 days ago. `l1.endpointsSettled` (endpoints with a settled row, active or not) is `l1.endpointsSettledSellerReceipt` (at least one transaction the seller named in its receipt) plus `l1.endpointsSettledIndexOnly` (every settled transaction found by vet402's own settlements index, or named in a Circle Gateway batch (settlement_source=circle_gateway); no seller receipt). `adoption` (since 2026-11-08) is use by others, each figure with its period, read time and source: `sdkDownloads` (npm's last-month window for @vet402/sdk) and `keyedDecisionCalls` (the monthly values of /api/v1/usage/monthly for key owners outside vet402). A figure that cannot be published is left out. - `GET /api/v1/observatory/history` — the daily series per chain. - `GET /api/v1/observatory/export.csv?days=90` — the L1 purchase ledger, one row per attempt that reached a decision. Without `days` the window is the last 90 days (`days` takes 1 to 366). The ledger starts at 2026-08-14T09:54:31Z, so from 2026-11-12T09:54:31Z the default window no longer reaches its first rows: use `?days=366` for the whole ledger. Paid attempts are the rows with status settled, settle_failed, delivered_no_receipt, settle_claimed, settle_claimed_unverifiable or settle_claim_refuted (their count is `l1.attempts`); the other rows stopped before signing, with `spent_units` 0 and a blank `network`. A settled Circle Gateway row has a blank `tx_hash`, and its batch transaction is kept beside the row. Columns are only ever appended. `held_reason` says why a row is held (vet402's hold) rather than counted against the seller; it is empty on a row awaiting on-chain verification (`settle_claimed`), which is a different state (counted as `l1.awaitingReread` on `/api/v1/observatory/state`, not in `l1.inconclusive`). `request_body` says what the paid request carried: `declared` (the body the seller's own 402 declares, since 2026-09-17), `empty` (`{}`) or `none` (no body, recorded since 2026-09-20); blank means no record, not `empty`. `request_body_sha256` is the SHA-256 of the bytes sent on `declared` rows since 2026-09-20; the body itself is not republished. `settlement_source` says who named the transaction: `seller_claim` (the seller's settlement receipt), `vet402_index` (no receipt came back and vet402's own settlements index found the transfer), or `circle_gateway` (a Circle Gateway batch transaction kept beside the row). This value is absent while the Arc Gateway lane flag is off. `request_query` says which URL the paid request went to: `declared` (the query arguments the seller's own 402 declares, appended to the listed URL as declared; recorded on the row since 2026-09-20 and published as a column since 2026-09-21, on the networks in vet402's per-network allow-list), `empty` (the seller declared none) or `refused` (a declaration was there and vet402's rules did not use it). A declared name the listed URL already carries is dropped on its own and the other pairs are still appended, so a collision yields `refused` only when nothing is left to append. Blank means no record — a network the allow-list does not name, a Tempo row, a row that ended before a paid request, or a row before 2026-09-20 — and the column alone does not separate those. `request_query_sha256` is the SHA-256 of the appended pairs as one form-urlencoded string on `declared` rows; the query string itself is not republished, and the hash is for matching rather than a way of hiding it — the names and values are the seller's own and the 402 that answered the unpaid request is where they were read from. `spent_units` is the amount vet402 signed for on the attempt (what it put at stake), not an amount shown to have moved: a `settle_failed` row with no transaction still carries the price there. `confirmed_units` (since 2026-09-29) is the amount vet402 re-read on-chain as transferred: `spent_units` on `settled` rows and `0` on every other row, including `settle_claimed` rows still awaiting the re-read; `0` means no confirmed transfer, not a transfer shown not to have happened. `purchase_id` (since 2026-09-29) is the purchase's id, the `subject_id` of its rows in `/api/v1/observatory/corrections`. `l2_reading` (since 2026-09-29) is `l2_schema` read again with today's rules, the value the record page and the decision use; `l2_schema` keeps the value recorded at the time. `scripts/declared-body-before-after.mjs` in the repository recomputes the before/after 2xx rate of the declared body from this CSV alone. Licence, retrieval time, row count and window are in the `x-vet402-*` and `Link` response headers, because a CSV has nowhere to put a comment. - `GET /api/v1/observatory/l0/export.csv` — the latest public L0 verdict per endpoint (since 2026-09-29): one row per endpoint on record, active or not, excluding endpoints paying vet402's own addresses — the data behind the L0 counts of `/api/v1/observatory/state`. Columns: `endpoint_id`, `resource_key`, `network`, `chain`, `network_class` (`mainnet` | `testnet` | `unclassified`), `listed`, `published_verdict` (`pass` | `fail` | `withdrawn` | `unverified`; `withdrawn` means the newest 2 probes failed on a route absent from a complete catalog fetch, left out of the public L0 fail count), `latest_probe_verdict`, `last_probed_at`, `latest_probe_older_than_7d`. Counting `published_verdict=pass` gives `publishedPass`; `network_class=mainnet` rows grouped by `chain` give `byChain`. 6/min, cached up to 45 minutes (see Freshness); definitions in `x-vet402-column-notes`, retrieval time in `x-vet402-retrieved-at` - `GET /api/v1/sellers/export.csv` — the /sellers classification (since 2026-09-29): one row per active Base listing (records opened for a seller's re-test request included), classified by its latest purchase row with the same function /sellers uses, so counting rows by `outcome` (`delivered` | `pending` | `seller` | `vet402` | `unsorted` | `not_bought` | `not_tried`) gives the page's totals. Also `fix_mode`, `side_label`, `confirmed_seller`, `held_reason`, the latest row's time, status, network, HTTP status and `purchase_id`, `in_ledger_export`, and `attribution_review` (`under_review` on seller rows). Served noindex, like the page, while its attribution is under review. 6/min, cached up to 45 minutes (see Freshness) Cite as: KIZUNA Creation. vet402 observatory. Dataset, retrieved YYYY-MM-DD. https://vet402.com/api/v1/observatory/state — the retrieval date is not optional; every one of these numbers moves. Method, denominators and what each status means: https://vet402.com/observatory/methodology Every response that carries a score or a published rate carries a `disclaimer` string in the payload, so the caveat travels with the number rather than living only on the web page. Full machine-readable schema (OpenAPI 3.1, covering every public endpoint listed above, key-less and keyed, with `https://vet402.com` as the only production server): https://vet402.com/openapi.yaml — the same file is in the repository at https://github.com/kzmttkc/vet402/blob/main/docs/openapi.yaml, but cite the served URL. ## Packages On npm, all from the same repository: `@vet402/sdk` (spend guard), `@vet402/middleware` (x402 request gate), `@vet402/mcp-server` (MCP tool). The SDK and the middleware both default to fail-closed — only an ALLOW passes, and a WARN, a BLOCK, a degraded verdict, or a partially measured one is denied unless the caller explicitly opts out. ## Implemented and live - Address control verified: prove control of a wallet by signature, get a public page and an SVG badge - Drop-in x402 middleware, REST API, and MCP tool - Public accuracy ledger, published whether or not the numbers flatter us - The x402 Observatory: L0 liveness probes on a rolling schedule over the public discovery catalog, which have not reached each listing (coverage7d and the L0 export say which), multi-chain (see /observatory/state for the breakdown), with delisting alerts for claimed sellers. L1 settle-through: real purchases of that chain's pinned asset (USDC on Base, Arc, Celo, Solana, Stellar, Arbitrum One and Avalanche C-Chain, USDC.e on Tempo, RLUSD on XRPL, USD1 on BNB Chain) on the chains whose payer lane is switched on (the chains reached so far, with their counts, are the `l1.byChain` rows of https://vet402.com/api/v1/observatory/state), budget-capped, one purchase per endpoint per sweep window, recording each settlement and each refusal. L2 is a minimal structural check of the response against the seller's own declared schema ## Being built (not measurements yet) - Writing verification records to the ERC-8004 Validation Registry. Not done yet because the registry is written in one direction: an agent's owner names a validator and opens the request, and the validator answers it. A validator cannot open a request about someone else's agent (`validationRequest` reverts with `Not authorized`, which is what vet402's fourteen attempts between 2026-08-21 and 2026-09-03 did). vet402 can answer the first request the day an agent owner sends one; none has named vet402 so far. The same account is §5 of https://vet402.com/#status ## Use cases - x402 API providers deciding whether to accept a payment from an unfamiliar agent wallet - Spending agents checking a counterparty before initiating a machine-to-machine payment - Payees and agents publishing a signature-proven claim plus a badge, so counterparties can check them - Marketplaces wanting a reputation signal without building their own scoring pipeline ## Chain Base (ERC-8004 agent identity / reputation) is the default and the chain the scoring API measures on. The agent-score endpoint accepts `?chain=` to select another enabled chain; an unknown or disabled chain is a 400 with the live list, never a silent fallback to a different chain. The observatory is a separate system and is not Base-only: L0 probing runs on a rolling schedule over the public x402 discovery catalog and has not reached each listing or chain yet, and https://vet402.com/observatory/state reports the current per-chain breakdown. L1 purchases run on the chains whose payer lane is switched on. The chains they have actually reached, with their counts, are the `l1.byChain` rows of https://vet402.com/api/v1/observatory/state, and that list is the one to read rather than any list written out here. Settlement is re-read on-chain with a chain-specific binding back to the signature vet402 holds: on Base, Arc, Celo, BNB Chain, Arbitrum One and Avalanche C-Chain the EIP-3009 authorization nonce, on Solana a memo vet402 wrote itself, on Tempo the indexed memo of a TIP-20 `TransferWithMemo`, on XRPL the hash of the signed blob. The settlement asset is USDC on Base, Arc, Celo, Solana, Stellar, Arbitrum One and Avalanche C-Chain, USDC.e on Tempo, RLUSD on XRPL, and USD1 on BNB Chain. Stellar is re-read for payer, payee, amount and asset, and is published as amount and payee. A purchase on a chain with no re-reader stays at `settle_claimed`. It is never silently paid on a substitute chain. ## Note on domain The production URL is `vet402.com`, and it is the only canonical one. `agent-trust-tawny.vercel.app` is our own former deployment URL: it now issues a permanent (308) redirect to `vet402.com` and should not be cited, indexed, or linked as a source. `agent-trust.vercel.app` is a different thing again — an unrelated third-party service, not affiliated with vet402. ## Corrections If a published score or verification result about a wallet you control is wrong, there is a free, key-less correction route open to anyone, customer or not — see section 8 of https://vet402.com/legal/terms#corrections Corrections that are issued are published at https://vet402.com/corrections, and as JSON at https://vet402.com/api/v1/observatory/corrections. Read the count from there rather than from this file: it is not zero (the first corrections were published on 2026-09-04), and a number written here goes stale the next time we correct something. ## Citation - You may cite the content on this site (front page, API docs, FAQ, accuracy ledger, blog) as long as you credit the source with the corresponding vet402.com URL. - The same statement is published for human readers in section 4 of https://vet402.com/accuracy — this file is not the only place it exists. - Figures on the accuracy ledger are rolling 90-day aggregates; cite them with the retrieval date, or quote the `generatedAt` timestamp from `GET /api/v1/accuracy`. - Content current as of 2026-10-26. The measurements it points at are not: read them from the endpoints above, with the schedule in Freshness. ## Freshness Every number on this site moves, so it is published with the schedule that moves it rather than as a timeless fact. - Catalog sync (what is listed, what was delisted): the Bazaar catalog is read in runs scheduled roughly two hours apart, at 00:05 UTC, 02:05 UTC, 04:05 UTC, 06:05 UTC, 08:05 UTC, 10:05 UTC, 12:05 UTC, 14:05 UTC, 16:05 UTC, 18:05 UTC, 20:05 UTC and 22:05 UTC. A run can start later within its scheduled hour. Each run continues from the page where the previous run stopped, so one full read of the Bazaar catalog takes several runs. A Bazaar listing is not marked delisted at present, and that includes a listing that is also in the Circle x402 discovery. The MPP directory is fetched once a day, at 01:30 UTC. A listing that leaves the MPP directory is not judged delisted until the next complete 01:30 UTC fetch. The Circle x402 discovery is fetched at 01:30 UTC. A listing that leaves the Circle x402 discovery is not judged delisted until the next complete fetch of that catalog. - L0 probes: scheduled at 10:30 UTC, and the operator adds runs. Further runs at 00:30 UTC, 02:30 UTC, 06:30 UTC, 14:30 UTC, 18:30 UTC and 22:30 UTC probe listings with no L0 probe in the last 7 days first. The daily metrics rollup: 10:30 UTC. - L1 purchases: several runs a day. The scheduled run is 12:00 UTC; the operator adds runs at 00:00, 06:00 and 18:00 UTC, and further runs at 03:30, 09:30, 15:30 and 21:30 UTC. Read the time of each attempt from the ledger (`/api/v1/observatory/export.csv`) rather than from this list. On-chain settlement re-read: daily, 14:00 UTC. Most `settle_claimed` rows move to `settled` (or `settle_claim_refuted`) at the first re-read after the attempt, but a row stays at `settle_claimed` while the chain read cannot settle it either way, so some rows wait far longer than a day. Read the current count, the counts older than 1 and 7 days and the oldest attempt from `l1.awaitingReread`, `l1.awaitingRereadOlderThan1d`, `l1.awaitingRereadOlderThan7d` and `l1.awaitingRereadOldestAttemptAt` on `/api/v1/observatory/state` rather than assuming a day. - Caches: the longest a copy you receive can lag the database, per surface. A shared-cache copy is served fresh for `s-maxage` and, with `stale-while-revalidate`, for that much longer while a fresh one is computed, so the most it can lag is the sum of the two. The `Age` response header says how long the copy you received sat in the cache. The `Cache-Control` values below are what each route sets: the CDN removes `s-maxage` and `stale-while-revalidate` from the copy you receive and keeps `max-age`, so the header you see can read just `public`. A page and the JSON can therefore show different numbers for a while after a run — compare their retrieval times rather than assume either is newer. - HTML pages that print observatory or /sellers aggregates (/, /observatory, /observatory/state, /sellers): rendered on every request, reading the aggregates through a 5-minute data cache (`PUBLIC_READ_REVALIDATE`, 300 s). A read after the window is served the older copy once while the fresh one is computed, so after a quiet spell one page view can be older than 5 minutes. - `GET /api/v1/resources/{resourceId}/decision`: no `Cache-Control`; each server instance reuses a decision it computed for up to 5 minutes (`DECISION_CACHE_TTL_MS`), so a copy can be up to 5 minutes old. - `GET /api/v1/observatory/state`: `Cache-Control: public, s-maxage=900, stale-while-revalidate=1800`. A copy can be up to 45 minutes old. On a miss the aggregates come from the same 5-minute data cache as the HTML pages, so a copy can be older by that much, or more once after a quiet spell. `retrievedAt` in the body is when the aggregates were read. - `GET /api/v1/observatory/decisions`: `Cache-Control: public, s-maxage=900, stale-while-revalidate=1800`. A copy can be up to 45 minutes old. - `GET /api/v1/observatory/l0/export.csv`: `Cache-Control: public, s-maxage=900, stale-while-revalidate=1800`. A copy can be up to 45 minutes old. - `GET /api/v1/sellers/export.csv`: `Cache-Control: public, s-maxage=900, stale-while-revalidate=1800`. A copy can be up to 45 minutes old. - `GET /api/v1/accuracy`: `Cache-Control: public, s-maxage=600, stale-while-revalidate=1200`. A copy can be up to 30 minutes old. - `GET /api/v1/observatory/endpoints/{id}/purchases`: `Cache-Control: public, s-maxage=600, stale-while-revalidate=1200`. A copy can be up to 30 minutes old. - `GET /api/v1/observatory/export.csv`, `/history`, `/anchors`, `/traceable-by-chain`, `/backtest`, `/concentration`: `Cache-Control: public, s-maxage=3600, stale-while-revalidate=7200`. A copy can be up to 3 hours old. - `GET /api/v1/census/summary`: `Cache-Control: public, max-age=300, s-maxage=300, stale-while-revalidate=900`. A copy can be up to 20 minutes old. - key-less object reads (`/api/v1/resolve`, `/resources/{id}`, `/endpoints/{id}`, `/endpoints/{id}/payees`, `/payees/{address}/endpoints`, `/observatory/endpoints/{id}/facts`, `/observatory/corrections`): `Cache-Control: public, max-age=60, s-maxage=60, stale-while-revalidate=300`. A copy can be up to 6 minutes old. - `/llms.txt` and `/llms-full.txt`: `Cache-Control: public, max-age=3600`. A copy can be up to 1 hour old. - `retrievedAt` in the JSON (`generatedAt` on `/api/v1/accuracy`, the `x-vet402-retrieved-at` header on the CSV) is the time vet402 read the numbers from its database, not the time you asked. It travels inside the cached copy, so it stays true whichever copy you were served, and it is the date to cite. A measurement quoted without its retrieval date is not a measurement. Take the date from `retrievedAt` in the JSON, from the `x-vet402-retrieved-at` header on the CSV, or from the day you fetched the page. ## Legal - https://vet402.com/legal/terms - https://vet402.com/legal/privacy - https://vet402.com/legal/notice ## Contact - Site: https://vet402.com - X: https://x.com/vet402_com - GitHub: https://github.com/kzmttkc/vet402