Independent MeasurementWhat to fix first (Base)Read from the database 2026-11-12 16:23 UTC. Refreshed after a view, so the first view after a quiet period can be older.

vet402Sellers · What to fix first · Methodology

What to fix first, as of 2026-11-12

The Base listings whose latest purchase did not deliver (1,757 of 7,885 that vet402 paid for), grouped by what went wrong. 10 more are awaiting on-chain verification and are not counted here. A failure is on the seller's side when the row shows vet402 was not at fault (the rules); a row that cannot show it is not sorted. Seller-side groups come first, the fix that reaches the most sellers at the top; effort is 1 for a listing or config change, 2 for a server change, 3 when it depends on the facilitator. Listings vet402 tried but did not pay for (151) are listed last and are not purchase results. Each seller links to its own page.

1.On the seller's side

Attribution under review. Which side a failed purchase is on is still under review. Seller-side counts and vet402-side counts are a working classification, not a finished finding about a seller.

1. Server error on the paid request

9 sellers · 10 listings · seller's side · effort 2: a server change

Fix: Check the route's logs: the handler or its upstream failed on the paid request.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 signed the payment and the paid request got a 5xx.

From the ledger status: settle_failed 6, settled 4

2.On vet402's side: nothing for sellers to fix

2. vet402 did not send the declared query

73 sellers · 147 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 did not send the query the listing declares. Before 2026-09-27 23:27:16 UTC, vet402 did not add the query parameters the seller's 402 declares to paid requests on Base, and this listing declares them (example values, or required names). The seller refused the request with 400 or 422. The same miss covers a signed paid request with no record of the query sent on XRPL before 2026-09-21 06:00:30 UTC, on Solana before 2026-10-01 12:00:20 UTC, on Arc, Celo, Stellar and BNB Chain before 2026-10-19 04:05:17 UTC, and on Arbitrum One and Avalanche C-Chain before 2026-11-02 04:55:29 UTC. A row at or after that time on its chain is not this miss.

From the ledger status: settle_failed 147

61 more sellers

3. vet402's wallet was out of USDC

38 sellers · 57 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: Between 2026-09-13 00:00 and 2026-09-15 23:49 UTC, vet402's Base payer wallet had run out of USDC. The seller refused a payment that had nothing behind it (402 or 5xx).

From the ledger status: settle_failed 57

26 more sellers

4. vet402 did not send the declared request body

37 sellers · 79 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: Before 2026-09-16 23:25:55 UTC, vet402 sent an empty JSON body on paid POST requests, even when the listing declares a body. The seller refused it with 400, 415 or 422, and the payment did not settle (a payment that settled is under "Charged, then refused an input vet402 had not sent").

From the ledger status: settle_failed 79

25 more sellers

5. vet402's own limits

34 sellers · 65 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 did not pay: the price was over its per-purchase ceiling, its budget for the day was used up, its operator halted spending, or the 402 named vet402's own receiving address.

From the ledger status: over_cap 65

22 more sellers

6. vet402's own run did not finish

14 sellers · 18 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402's request did not complete on its side (its run was cut off, or a step failed inside vet402).

From the ledger status: request_error 18

2 more sellers

scopeapi.dev 1
tanod.dev 1

7. vet402's wallet held less USDC than the price

13 sellers · 16 listings · vet402's side

Nothing for the seller to fix.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: When vet402 signed, its payer wallet held less USDC than the price, by the wallet's balance rebuilt from its own USDC transfers on-chain. The payment had nothing behind it, so the failure is on vet402's side.

From the ledger status: settle_failed 16

1 more sellers

www.x402scan.com 1

3.Not counted against either side

8. Refused, and no payment was taken
245 sellers · 550 listings · not sorted: no charge
This page does not count it as the seller's fault. If the request was meant to succeed, declare the input in the listing (body or query) with example values that work as written.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.
Express
```
import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
Next.js (app router)
```
import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)
```
Hono
```
import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
FastAPI
```
from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
What happened: vet402 signed the payment and the paid request got a 4xx other than 402, with no settlement receipt and no transaction on the row. No money moved, and vet402 cannot rule out that its own request was the problem (held_reason unsettled_4xx), so this page does not count the row as the seller's fault. Since 2026-09-16 23:25:55 UTC vet402 sends the request body the seller's 402 declares (an empty JSON body when it declares none), and since 2026-09-27 23:27:16 UTC it adds the query parameters the seller's 402 declares on Base.
From the ledger status: settle_failed 550
- api.sirenic.eu 52
- api.relaystation.ai 40
- api.strale.io 38
- api.x402node.dev 35
- blockrun.ai 25
- pay.brianbooms.com 18
- api.loyalspark.online 14
- stableenrich.dev 11
- stablesocial.dev 11
- api.marketintelligenceapi.com 5
- ausca.com 5
- rubric-protocol.com 5
233 more sellers
9. A signed payment got 402 again, on a request that differed from the unpaid one
180 sellers · 210 listings · not sorted: vet402 unproven
This page does not count it as the seller's fault.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.
Express
```
import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
Next.js (app router)
```
import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)
```
Hono
```
import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
FastAPI
```
from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
What happened: vet402 took the payment terms from the 402 to its unpaid request, then sent the paid request with the body or query the listing declares, which the unpaid request did not carry. The seller answered 402 again (for example "No matching payment requirements"). The terms for the paid request may not be the ones vet402 paid, so this page does not count the row as the seller's fault.
From the ledger status: settle_failed 210
168 more sellers
10. Server error on the paid request
101 sellers · 122 listings · not sorted: one failure so far
This page does not count it as the seller's fault. vet402 puts a failure on the seller's side only after it sees one at this listing on two different days (UTC). If this one is real: Check the route's logs: the handler or its upstream failed on the paid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.
Express
```
import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
Next.js (app router)
```
import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)
```
Hono
```
import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
FastAPI
```
from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
What happened: vet402 signed the payment and the paid request got a 5xx.
From the ledger status: settle_failed 97, settled 25
89 more sellers
11. vet402 stopped waiting with no answer on the row
86 sellers · 108 listings · not sorted: vet402 stopped waiting
This page does not count it as the seller's fault.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.
Express
```
import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
Next.js (app router)
```
import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)
```
Hono
```
import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)
```
FastAPI
```
from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
What happened: vet402 waited the time recorded on the row for the paid answer (20 seconds when the row does not record one). The listing allows longer than that wait (its maxTimeoutSeconds), or does not say how long, or the row names a transaction for the purchase. This page does not place that transaction before or after the end of the wait, and does not count the row as the seller's fault.
From the ledger status: settled 76, settle_failed 32
74 more sellers

12. No record of the input vet402 sent

81 sellers · 110 listings · not sorted: vet402 unproven

This page does not count it as the seller's fault.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: This purchase is from before vet402 recorded the body and the query it sent on each paid request (the query on Base since 2026-09-27 23:27:16 UTC), so it cannot show that it sent the input the listing declares. This page does not count the row as the seller's fault.

From the ledger status: settle_failed 74, settled 36

69 more sellers

13. Payment settled, then the input was rejected

40 sellers · 97 listings · not sorted (held)

This page does not count it as the seller's fault. Checking the input before settling avoids taking a payment for a refused request, and declaring the input with example values that work as written lets vet402 send a valid one.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The payment settled on-chain, and then the paid request got 400, 404, 415 or 422. vet402 holds this row (held_reason settled_4xx): its own request may have been the problem, so this page does not count the row as the seller's fault.

From the ledger status: settled 97

28 more sellers

14. Charged, then refused an input vet402 had not sent

27 sellers · 29 listings · not sorted: charged, then rejected an input vet402 had not sent

This page does not count it as the seller's fault. Checking the input before settling avoids taking a payment for a request you refuse.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The payment settled on-chain, and then the paid request got 400, 415 or 422. At the time vet402 did not send the input this listing declares: the request body before 2026-09-16 23:25:55 UTC, the query on Base before 2026-09-27 23:27:16 UTC, or the query on XRPL before 2026-09-21 06:00:30 UTC, on Solana before 2026-10-01 12:00:20 UTC, on Arc, Celo, Stellar and BNB Chain before 2026-10-19 04:05:17 UTC, and on Arbitrum One and Avalanche C-Chain before 2026-11-02 04:55:29 UTC. Both facts stand: the seller took the payment, and the request lacked the declared input. This page counts the row against neither side.

From the ledger status: settled 29

15 more sellers

15. Paid, and the answer held no result yet

24 sellers · 47 listings · not sorted: paid, no result in the answer

This page does not count it as the seller's fault. If the result can be ready at once, return it with a 200 to the paid request.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The payment settled on-chain, and the paid request got 202 Accepted (the work was queued, for example with a status such as processing or settlement_pending_reconciliation) or a 2xx with an empty body. vet402 does not fetch a result later, so this is not counted as delivered.

From the ledger status: settled 47

12 more sellers

16. Payment settled, then the request was refused

22 sellers · 37 listings · not sorted (held)

This page does not count it as the seller's fault. If the paid request should have been served, let the x402 payment be enough for it.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The payment settled on-chain, and then the paid request got another 4xx (for example 401, 403, 405 or 429). vet402 holds this row (held_reason settled_4xx), so this page does not count it as the seller's fault.

From the ledger status: settled 37

10 more sellers

17. Answered without taking payment

17 sellers · 31 listings · not sorted: no charge

This page does not count it as the seller's fault. If the route is meant to charge, settle the payment and return the PAYMENT-RESPONSE header with the 2xx.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The paid request got a 2xx with no settlement receipt, and vet402 has not linked a matching transfer on-chain to it (it links a transfer that lands from 2 minutes before to 30 minutes after the attempt, then verifies it). vet402 has not identified a charge for this call, so this page does not count the row as the seller's fault; if a matching transfer is found later, the row is re-sorted.

From the ledger status: delivered_no_receipt 31

5 more sellers

18. vet402 did not send the declared input

8 sellers · 10 listings · not sorted: vet402 unproven

This page does not count it as the seller's fault.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The listing declares input that vet402 did not send on the paid request (a header, a path parameter, or a declared query it did not use). The answer was not a refusal of the input (400 or 422), so vet402 cannot say whether the missing input caused the failure. This page does not count the row as the seller's fault.

From the ledger status: settle_failed 7, settled 3

19. A signed payment got 402 again

6 sellers · 8 listings · not sorted: one failure so far

This page does not count it as the seller's fault. vet402 puts a failure on the seller's side only after it sees one at this listing on two different days (UTC). If this one is real: Check the route's verify and settle step, and return the facilitator's error as errorReason.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 sent a signed payment and the server answered 402 again.

From the ledger status: settle_failed 8

20. The declared input is an example domain

2 sellers · 3 listings · not sorted: example input

This page does not count it as the seller's fault. If the example is meant to be sent as it is, nothing to fix; otherwise, declare an example value your endpoint accepts.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The input this listing declares holds an example domain (example.com, example.org, example.net, or a name under .example), and vet402 sends the values the listing declares. A request built from a placeholder can fail for that reason alone, so vet402 cannot show its input was a valid one. This page does not count the row as the seller's fault.

From the ledger status: settle_failed 3

21. vet402 cannot show its wallet held the price

1 seller · 1 listing · not sorted: vet402 unproven

This page does not count it as the seller's fault.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: This purchase is from before vet402 checked its wallet's balance before signing (2026-09-16 23:25:55 UTC), and the balance rebuilt from the wallet's on-chain transfers does not show that it held the price at the time. This page does not count the row as the seller's fault.

From the ledger status: settle_failed 1

api.linkedpanda.com 1

22. Not grouped yet

1 seller · 1 listing · not sorted yet

See the recorded status and HTTP code on the seller page.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: A combination of status and HTTP code this page does not group yet.

From the ledger status: settle_failed 1

base-token-check.vercel.app 1

23. The receipt's transaction does not show the payment

1 seller · 1 listing · not sorted: one failure so far

This page does not count it as the seller's fault. vet402 puts a failure on the seller's side only after it sees one at this listing on two different days (UTC). If this one is real: Check which transaction your facilitator returns; it must be the transfer for this payment.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 re-read the transaction named in the receipt on-chain and did not find the expected USDC transfer to the declared payee.

From the ledger status: settle_claim_refuted 1

money-reactor.makar52nn2016.workers.dev 1

4.Not bought: vet402 did not pay

24. Not bought: the 402's amount was not the listing's price

25 sellers · 38 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 pays the price the listing declares. The amount in the 402 was a different number, so vet402 did not sign.

From the ledger status: price_mismatch 38

13 more sellers

25. Not bought: server error before payment

22 sellers · 53 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got a 5xx, so there was no 402 to pay and vet402 did not pay.

From the ledger status: no_402 53

10 more sellers

26. Not bought: no payment option vet402 can sign

16 sellers · 28 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 signs the exact scheme for USDC on Base mainnet and no other. The 402 offered none of those (for example a different scheme such as upto, another asset or another network), so vet402 did not pay. This is a limit of vet402's buyer.

From the ledger status: no_eligible_accept 28

4 more sellers

27. Not bought: the 402 named another receiving address

10 sellers · 17 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: vet402 pays the receiving address the listing declares. The payTo in the 402 was a different address, so vet402 did not sign.

From the ledger status: payto_mismatch 17

28. Not bought: the listed URL answered 404 or 410

3 sellers · 7 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got 404 or 410, so there was no 402 to pay and vet402 did not pay.

From the ledger status: no_402 7

29. Not bought: no 402 to the unpaid request

3 sellers · 3 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got a status other than 402 (for example 400 or 422; the unpaid request does not carry the declared input), so vet402 did not pay.

From the ledger status: no_402 3

30. Not bought: answered without a 402

2 sellers · 2 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got a 2xx instead of 402, so there was nothing to pay and vet402 did not pay.

From the ledger status: no_402 2

31. Not bought: the unpaid request got 429

1 seller · 2 listings · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got 429 Too Many Requests, so vet402 did not pay.

From the ledger status: no_402 2

money-reactor.makar52nn2016.workers.dev 2

32. Not bought: the unpaid request got 401 or 403

1 seller · 1 listing · not bought: vet402 did not pay

This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.

Fix code for Express, Next.js, Hono and FastAPI

Paste one snippet for the stack you run. This page groups listings, so vet402 leaves payTo, the atomic amount, the CAIP-2 network, and the path as <...>. The seller page fills them from that listing.

Express

import { paymentMiddleware, x402ResourceServer } from "@x402/express"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

Next.js (app router)

import { withX402, x402ResourceServer } from "@x402/next"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"
import { NextRequest, NextResponse } from "next/server"

const server = new x402ResourceServer(new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })).register("<...>", new ExactEvmScheme())

const handler = async (request: NextRequest) => {
  return NextResponse.json({ ok: true })
}

export const <...> = withX402(
  handler,
  {
    "<...>": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "<...>", asset: "<...>" },
        network: "<...>",
      },
    },
  },
  server,
)

Hono

import { paymentMiddleware, x402ResourceServer } from "@x402/hono"
import { ExactEvmScheme } from "@x402/evm/exact/server"
import { HTTPFacilitatorClient } from "@x402/core/server"

const facilitatorClient = new HTTPFacilitatorClient({ url: "https://x402.org/facilitator" })
const server = new x402ResourceServer(facilitatorClient).register("<...>", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "<...>": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "<...>", asset: "<...>" },
          network: "<...>",
        },
      },
    },
    server,
  ),
)

FastAPI

from fastapi import FastAPI
from x402 import x402ResourceServer
from x402.http import HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware
from x402.mechanisms.evm.exact import ExactEvmServerScheme

app = FastAPI()
facilitator = HTTPFacilitatorClient()
server = x402ResourceServer(facilitator)
server.register("<...>", ExactEvmServerScheme())

routes = {
    "<...>": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "<...>", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)

What happened: The unpaid request got 401 or 403 instead of 402, so vet402 did not pay.

From the ledger status: no_402 1

api.duoleads.com 1

A count is one listing's latest purchase, not a rating: one attempt can fail for reasons on either side. The groups come from the status and HTTP code vet402 recorded (methodology · export.csv).

What to fix first, as of 2026-11-12

1.On the seller's side

1. Server error on the paid request

2.On vet402's side: nothing for sellers to fix

2. vet402 did not send the declared query

3. vet402's wallet was out of USDC

4. vet402 did not send the declared request body

5. vet402's own limits

6. vet402's own run did not finish

7. vet402's wallet held less USDC than the price

3.Not counted against either side

8. Refused, and no payment was taken

9. A signed payment got 402 again, on a request that differed from the unpaid one

10. Server error on the paid request

11. vet402 stopped waiting with no answer on the row

12. No record of the input vet402 sent

13. Payment settled, then the input was rejected

14. Charged, then refused an input vet402 had not sent

15. Paid, and the answer held no result yet

16. Payment settled, then the request was refused

17. Answered without taking payment

18. vet402 did not send the declared input

19. A signed payment got 402 again

20. The declared input is an example domain

21. vet402 cannot show its wallet held the price

22. Not grouped yet

23. The receipt's transaction does not show the payment

4.Not bought: vet402 did not pay

24. Not bought: the 402's amount was not the listing's price

25. Not bought: server error before payment

26. Not bought: no payment option vet402 can sign

27. Not bought: the 402 named another receiving address

28. Not bought: the listed URL answered 404 or 410

29. Not bought: no 402 to the unpaid request

30. Not bought: answered without a 402

31. Not bought: the unpaid request got 429

32. Not bought: the unpaid request got 401 or 403