Which side a failure is on is still under review, and the review has no set date. Rows on the seller's side are marked “attribution under review” below. A card with a computed time gives the earliest time vet402 can buy that listing again. If an attribution turns out wrong, the correction is published on /corrections.

Independent MeasurementSeller: purchase results on BaseRead from the database 2026-11-12 12:48 UTC. Refreshed after a view, so the first view after a quiet period can be older.

vet402Sellers · What to fix first · Methodology

agent.pocket.network: x402 purchase results on Base, latest attempt 2026-11-10

124 Base listings. Latest result about the seller at each listing: 31 delivered · 1 failed on the seller's side · 9 with no such result among the attempts shown · 83 with no Base purchase. This counts, for each listing, the newest Base purchase that delivered or the newest Base failure on the seller's side. Attempts on vet402's side, not bought, not sorted, or awaiting on-chain verification are skipped.

By the latest attempt at each listing, whatever it was: 31 delivered · 1 failed on the seller's side · 0 on vet402's side · 8 not sorted (vet402 cannot show the failure was not its own) · 1 not bought (vet402 did not pay) · 83 with no Base purchase.

Latest attempt: 2026-11-10 03:32 UTC. This page read the ledger at 2026-11-12 12:48 UTC and reuses that read for up to 5 min. The first view after a quiet period can show an older read.

Paste this badge on your page. It shows what vet402 received when it paid agent.pocket.network, and links to this record.

[![vet402 record for agent.pocket.network](https://vet402.com/api/badge/host/agent.pocket.network.svg)](https://vet402.com/sellers/agent.pocket.network)

<a href="https://vet402.com/sellers/agent.pocket.network"><img src="https://vet402.com/api/badge/host/agent.pocket.network.svg" alt="vet402 record for agent.pocket.network" height="38"></a>

1.Your listings

agent.pocket.network/v1/counterpartyPOST
On 2026-11-10 03:32 UTC, vet402 signed a payment and the paid request answered HTTP 400. This row is not counted against the seller (not sorted: no charge). The next purchase by vet402 is not before 2026-11-16 03:32 UTC, with no booked time. After that it depends on the daily budget and the order of demand.
Latest attempt
2026-11-10 03:32 UTC
Result
Refused, and no payment was taken
Whose side
not sorted: no charge
Decision API now: asking… · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-12 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 04:40 UTC (within 120 hours of the last).
What vet402 saw: 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.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xa747…6e5b · validBefore not recorded.Answer to the paid request: HTTP 400 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 400 · no tx · held as unsettled_4xx (the paid request got a 4xx with no settlement receipt and no transaction)In export.csv?days=4: the row with attempted_at 2026-11-10T03:32:26Z and resource_key agent.pocket.network/v1/counterparty.
After a fixNext purchase by vet402: Not before 2026-11-16 03:32 UTC (a listing is bought at most once every 6 days). After that it depends on the daily budget and the order of demand, so this is the earliest date, not a booking.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/counterparty": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/counterparty": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/counterparty": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/counterparty": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/treasury-capital-scorePOST

On 2026-11-10 03:32 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-11-16 03:32 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-11-10 03:32 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: asking… · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 13:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 13:40 UTC (within 120 hours of the last).

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xfee7…7e64 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=4: the row with attempted_at 2026-11-10T03:32:25Z and resource_key agent.pocket.network/v1/treasury-capital-score.

After a fixNext purchase by vet402: Not before 2026-11-16 03:32 UTC (a listing is bought at most once every 6 days). After that it depends on the daily budget and the order of demand, so this is the earliest date, not a booking.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/treasury-capital-score": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/treasury-capital-score": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/treasury-capital-score": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/treasury-capital-score": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/named-entity-recognitionPOST

On 2026-11-10 00:02 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-11-16 00:02 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-11-10 00:02 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 13:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 13:40 UTC (within 120 hours of the last).

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x03d9…fdbb · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=4: the row with attempted_at 2026-11-10T00:02:15Z and resource_key agent.pocket.network/v1/named-entity-recognition.

After a fixNext purchase by vet402: Not before 2026-11-16 00:02 UTC (a listing is bought at most once every 6 days). After that it depends on the daily budget and the order of demand, so this is the earliest date, not a booking.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/named-entity-recognition": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/named-entity-recognition": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/named-entity-recognition": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/named-entity-recognition": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/pump-checkPOST

On 2026-11-07 09:32 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-11-13 09:32 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-11-07 09:32 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 22:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 22:40 UTC (within 120 hours of the last).

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xa835…bc1c · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=7: the row with attempted_at 2026-11-07T09:32:08Z and resource_key agent.pocket.network/v1/pump-check.

After a fixNext purchase by vet402: Not before 2026-11-13 09:32 UTC (a listing is bought at most once every 6 days). After that it depends on the daily budget and the order of demand, so this is the earliest date, not a booking.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pump-check": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/pump-check": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pump-check": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/pump-check": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/prompt-injection-detectPOST
Latest attempt
2026-11-05 18:02 UTC
Result
delivered
Whose side
no failure (delivered)
Decision API now: · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 13:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 13:40 UTC (within 120 hours of the last).
What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xd270…2c13 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.The latest purchase delivered. An earlier attempt listed below did not.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x3b4d4abb…d723In export.csv?days=8: the row with attempted_at 2026-11-05T18:02:25Z and resource_key agent.pocket.network/v1/prompt-injection-detect.
After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-11 18:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/prompt-injection-detect": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/prompt-injection-detect": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/prompt-injection-detect": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/prompt-injection-detect": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
Earlier attempts
1. 2026-10-27 18:02 UTC · Server error on the paid request · not sorted: one failure so farsettle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no tx
  What vet402 recorded
  vet402 signed the payment and the paid request got a 5xx.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x9019…8094 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.
  Dispute this purchase
2. 2026-10-20 09:31 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x35f1c837…f2c2
  What vet402 recorded
  Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xa2e1…ce5c · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.
  Dispute this purchase
agent.pocket.network/v1/agentsearch-web-search-v1POST
Latest attempt
2026-11-05 15:32 UTC
Result
delivered
Whose side
no failure (delivered)
Decision API now: · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 04:40 UTC (within 120 hours of the last).
What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x6ca2…325b · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xf8361919…a45aIn export.csv?days=8: the row with attempted_at 2026-11-05T15:32:29Z and resource_key agent.pocket.network/v1/agentsearch-web-search-v1.
After a fixNext purchase by vet402: Not before 2026-12-05 15:32 UTC (this listing has 3 or more settled purchases, so it is bought at most once every 30 days). After that it depends on the daily budget and the order of demand, so this is the earliest date, not a booking.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/agentsearch-web-search-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/agentsearch-web-search-v1": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/agentsearch-web-search-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/agentsearch-web-search-v1": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
Earlier attempts
1. 2026-10-27 21:32 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x5926aa15…be46
  What vet402 recorded
  Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xc707…d82d · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.
  Dispute this purchase
2. 2026-10-20 09:31 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x86e48d09…3ecc
  What vet402 recorded
  Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x733e…ad74 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.
  Dispute this purchase

agent.pocket.network/v1/kavaPOST

Latest attempt: 2026-11-05 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 16:40 UTC (within 120 hours of the last).

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x572d…f9a6 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xc2d320f4…f3bbIn export.csv?days=9: the row with attempted_at 2026-11-05T03:32:20Z and resource_key agent.pocket.network/v1/kava.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-11 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/kava": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/kava": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/kava": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/kava": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/pii-redactionPOST

Latest attempt: 2026-11-05 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x9b87…8d4e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xcd0d47f6…4221In export.csv?days=9: the row with attempted_at 2026-11-05T03:32:16Z and resource_key agent.pocket.network/v1/pii-redaction.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pii-redaction": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/pii-redaction": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pii-redaction": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/pii-redaction": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/basePOST

Latest attempt: 2026-11-03 20:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x41db…425e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x75613229…4716In export.csv?days=10: the row with attempted_at 2026-11-03T20:32:15Z and resource_key agent.pocket.network/v1/base.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-09 20:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/base": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/base": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/base": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/base": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/solanaPOST

Latest attempt: 2026-11-03 12:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-12 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 04:40 UTC (within 120 hours of the last).

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x79e5…66fc · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x4293133a…1893In export.csv?days=11: the row with attempted_at 2026-11-03T12:02:37Z and resource_key agent.pocket.network/v1/solana.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-09 12:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/solana": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/solana": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/solana": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/solana": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/meadowPOST
On 2026-11-01 21:32 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is on the seller's side (attribution under review), because such a failure (a failure vet402 can show was not its own) happened at this listing on two or more different UTC days, and the kind of failure on this row was seen on 2026-10-26 and 2026-11-01. Check the route's logs, and the next purchase by vet402 is not before 2026-11-07 21:32 UTC, with no booked time. After that it depends on the daily budget and the order of demand.
Latest attempt
2026-11-01 21:32 UTC
Result
Server error on the paid request
Whose side
seller's side attribution under review
Decision API now: · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 04:40 UTC (within 120 hours of the last).
What vet402 saw: vet402 signed the payment and the paid request got a 5xx.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x84bc…c952 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: Check the route's logs: the handler or its upstream failed on the paid request. (a server change)Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=12: the row with attempted_at 2026-11-01T21:32:29Z and resource_key agent.pocket.network/v1/meadow.
After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 21:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/meadow": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/meadow": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/meadow": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/meadow": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
Earlier attempts
1. 2026-10-26 12:02 UTC · Server error on the paid request · seller's side attribution under reviewsettle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no tx
  What vet402 recorded
  vet402 signed the payment and the paid request got a 5xx.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x1d10…ef79 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.
  Dispute this purchase

agent.pocket.network/v1/sec-edgar-xbrlPOST

Latest attempt: 2026-11-01 09:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 22:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 22:40 UTC (within 120 hours of the last).

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x7f9f…ce48 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x05ed764e…95b7In export.csv?days=13: the row with attempted_at 2026-11-01T09:32:10Z and resource_key agent.pocket.network/v1/sec-edgar-xbrl.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 09:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sec-edgar-xbrl": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/sec-edgar-xbrl": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sec-edgar-xbrl": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/sec-edgar-xbrl": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/package-advisoriesPOST
On 2026-11-01 00:02 UTC, vet402 signed a payment and the paid request answered HTTP 400. This row is not counted against the seller (not sorted: no charge). The next purchase by vet402 is not before 2026-11-07 00:02 UTC, with no booked time. After that it depends on the daily budget and the order of demand.
Latest attempt
2026-11-01 00:02 UTC
Result
Refused, and no payment was taken
Whose side
not sorted: no charge
Decision API now: · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 13:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 13:40 UTC (within 120 hours of the last).
What vet402 saw: 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.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x8acd…0034 · validBefore not recorded.Answer to the paid request: HTTP 400 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 400 · no tx · held as unsettled_4xx (the paid request got a 4xx with no settlement receipt and no transaction)In export.csv?days=13: the row with attempted_at 2026-11-01T00:02:31Z and resource_key agent.pocket.network/v1/package-advisories.
After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 00:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/package-advisories": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/package-advisories": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/package-advisories": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/package-advisories": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/federal-registerPOST

Latest attempt: 2026-11-01 00:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xf9a0…15c3 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x8869d4ef…ca81In export.csv?days=13: the row with attempted_at 2026-11-01T00:02:28Z and resource_key agent.pocket.network/v1/federal-register.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 00:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/federal-register": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/federal-register": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/federal-register": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/federal-register": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/rate-benchmarksPOST

Latest attempt: 2026-10-31 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 16:40 UTC (within 120 hours of the last).

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x39f6…971b · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xf0f58a0e…7ae4In export.csv?days=14: the row with attempted_at 2026-10-31T03:32:16Z and resource_key agent.pocket.network/v1/rate-benchmarks.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/rate-benchmarks": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/rate-benchmarks": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/rate-benchmarks": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/rate-benchmarks": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/us-code-cfrPOST

Latest attempt: 2026-10-30 09:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x0b2b…c5d8 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x3445b3e9…14edIn export.csv?days=15: the row with attempted_at 2026-10-30T09:32:30Z and resource_key agent.pocket.network/v1/us-code-cfr.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-05 09:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/us-code-cfr": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/us-code-cfr": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/us-code-cfr": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/us-code-cfr": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/kr-apt-trades-v1POST

Latest attempt: 2026-10-30 09:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x703e…2e4f · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xffaf6090…3ff8In export.csv?days=15: the row with attempted_at 2026-10-30T09:32:20Z and resource_key agent.pocket.network/v1/kr-apt-trades-v1.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/kr-apt-trades-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/kr-apt-trades-v1": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/kr-apt-trades-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/kr-apt-trades-v1": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/rerankingPOST

Latest attempt: 2026-10-30 09:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xc0bc…ded0 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xd8d93cd5…8aeaIn export.csv?days=15: the row with attempted_at 2026-10-30T09:32:03Z and resource_key agent.pocket.network/v1/reranking.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/reranking": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/reranking": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/reranking": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/reranking": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/sentiment-classificationPOST

Latest attempt: 2026-10-30 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 04:40 UTC (within 120 hours of the last).

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x55c9…581e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x331760ae…832fIn export.csv?days=15: the row with attempted_at 2026-10-30T03:32:19Z and resource_key agent.pocket.network/v1/sentiment-classification.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-05 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sentiment-classification": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/sentiment-classification": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sentiment-classification": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/sentiment-classification": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/token-price-oraclesPOST

Latest attempt: 2026-10-30 00:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x119a…6684 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xdec61a80…1360In export.csv?days=15: the row with attempted_at 2026-10-30T00:02:19Z and resource_key agent.pocket.network/v1/token-price-oracles.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-05 00:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/token-price-oracles": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/token-price-oracles": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/token-price-oracles": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/token-price-oracles": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/clinical-trialsPOST

Latest attempt: 2026-10-30 00:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x89d2…8043 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x9d4dd260…d354In export.csv?days=15: the row with attempted_at 2026-10-30T00:02:04Z and resource_key agent.pocket.network/v1/clinical-trials.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/clinical-trials": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/clinical-trials": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/clinical-trials": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/clinical-trials": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/name-resolutionPOST

Latest attempt: 2026-10-29 00:01 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xc9cf…9ee7 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xb295b2cf…1610In export.csv?days=16: the row with attempted_at 2026-10-29T00:01:56Z and resource_key agent.pocket.network/v1/name-resolution.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-04 00:01 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/name-resolution": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/name-resolution": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/name-resolution": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/name-resolution": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/literature-searchPOST

Latest attempt: 2026-10-29 00:01 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xe8ea…7cba · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x83e8e732…48bdIn export.csv?days=16: the row with attempted_at 2026-10-29T00:01:52Z and resource_key agent.pocket.network/v1/literature-search.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/literature-search": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/literature-search": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/literature-search": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/literature-search": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/agentsearch-web-render-v1POST

Latest attempt: 2026-10-28 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xbe20…2f08 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x79ad93b3…8703In export.csv?days=17: the row with attempted_at 2026-10-28T03:32:07Z and resource_key agent.pocket.network/v1/agentsearch-web-render-v1.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-03 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/agentsearch-web-render-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/agentsearch-web-render-v1": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/agentsearch-web-render-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/agentsearch-web-render-v1": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/text-embeddingsPOST

Latest attempt: 2026-10-24 06:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xde17…d34e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x06283655…df7eIn export.csv?days=21: the row with attempted_at 2026-10-24T06:02:03Z and resource_key agent.pocket.network/v1/text-embeddings.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-30 06:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/text-embeddings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/text-embeddings": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/text-embeddings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/text-embeddings": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/meme-watchPOST

On 2026-10-24 06:02 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-10-30 06:02 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-10-24 06:02 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: · the full answer

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xf157…2fdf · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=21: the row with attempted_at 2026-10-24T06:02:01Z and resource_key agent.pocket.network/v1/meme-watch.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/meme-watch": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/meme-watch": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/meme-watch": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/meme-watch": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/suiPOST

On 2026-10-24 06:01 UTC, the unpaid request answered HTTP 503 instead of a 402, so vet402 did not sign a payment. This is not a purchase result, so it is not counted against the seller. If HTTP 503 is unexpected, check the route's logs, and the next purchase by vet402 is not before 2026-10-30 06:01 UTC (it needs a passing L0 check first, and the latest one reads fail), with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-10-24 06:01 UTC
Result: Not bought: server error before payment
Whose side: not bought: vet402 did not pay

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): fail (no_402) at 2026-11-10 13:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 13:40 UTC (within 120 hours of the last).

What vet402 saw: The unpaid request got a 5xx, so there was no 402 to pay and vet402 did not pay.Last result about the seller: none among the attempts shown. The latest attempt was not a purchase (vet402 did not pay). There has been no attempt since.The 402 vet402 saw: The unpaid request got HTTP 503, not a 402.What to fix: This page does not count it as the seller's fault: vet402 did not pay, so this is not a purchase result.Recorded (attempt, vet402 did not pay, not an L1 result): no_402 (the unpaid request did not get a 402, so nothing was paid) · HTTP — (unpaid answer 503) · no txIn export.csv?days=21: the row with attempted_at 2026-10-24T06:01:45Z and resource_key agent.pocket.network/v1/sui.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-30 06:01 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date. It is picked only while its latest L0 check passes; the latest one reads fail.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/sui": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/sui": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/sui": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/sui": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/sec-holdingsPOST

Latest attempt: 2026-10-24 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x8b62…bc31 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xa8807b7e…cd55In export.csv?days=21: the row with attempted_at 2026-10-24T03:32:24Z and resource_key agent.pocket.network/v1/sec-holdings.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-30 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sec-holdings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/sec-holdings": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sec-holdings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/sec-holdings": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/address-standardizationPOST

Latest attempt: 2026-10-23 09:31 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xe5b6…3081 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xc46c5ecf…1212In export.csv?days=22: the row with attempted_at 2026-10-23T09:31:21Z and resource_key agent.pocket.network/v1/address-standardization.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-29 09:31 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/address-standardization": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/address-standardization": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/address-standardization": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/address-standardization": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/enforcement-actionsPOST

Latest attempt: 2026-10-23 06:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x35da…e128 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x52ab6dcd…ea2bIn export.csv?days=22: the row with attempted_at 2026-10-23T06:02:14Z and resource_key agent.pocket.network/v1/enforcement-actions.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-29 06:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/enforcement-actions": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/enforcement-actions": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/enforcement-actions": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/enforcement-actions": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/routing-isochronesPOST

Latest attempt: 2026-10-22 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x268a…d601 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x1cc19eda…40a6In export.csv?days=23: the row with attempted_at 2026-10-22T03:32:26Z and resource_key agent.pocket.network/v1/routing-isochrones.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-28 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/routing-isochrones": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/routing-isochrones": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/routing-isochrones": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/routing-isochrones": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/fantomPOST

Latest attempt: 2026-10-21 03:33 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x3825…2822 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x0b24152f…448cIn export.csv?days=24: the row with attempted_at 2026-10-21T03:33:16Z and resource_key agent.pocket.network/v1/fantom.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-27 03:33 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/fantom": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/fantom": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/fantom": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/fantom": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/sanctions-watchlist-screenPOST

Latest attempt: 2026-10-21 03:33 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x5b06…94df · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x4fe48403…b658In export.csv?days=24: the row with attempted_at 2026-10-21T03:33:11Z and resource_key agent.pocket.network/v1/sanctions-watchlist-screen.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sanctions-watchlist-screen": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/sanctions-watchlist-screen": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sanctions-watchlist-screen": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/sanctions-watchlist-screen": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/fund-etf-holdingsPOST

Latest attempt: 2026-10-21 00:02 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xb605…51cd · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x4b9be282…25d8In export.csv?days=24: the row with attempted_at 2026-10-21T00:02:05Z and resource_key agent.pocket.network/v1/fund-etf-holdings.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-27 00:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/fund-etf-holdings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/fund-etf-holdings": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/fund-etf-holdings": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/fund-etf-holdings": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/sonicPOST

Latest attempt: 2026-10-20 15:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xf71b…3d82 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xa7cbca0a…761aIn export.csv?days=24: the row with attempted_at 2026-10-20T15:32:20Z and resource_key agent.pocket.network/v1/sonic.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-26 15:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sonic": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/sonic": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/sonic": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/sonic": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

Earlier attempts

2026-10-13 23:02 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x9008a04a…077b
What vet402 recorded
Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x557b…f8ae · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.
Dispute this purchase

agent.pocket.network/v1/us-macroPOST

Latest attempt: 2026-10-20 09:31 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x2289…9d93 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xb0cb63a8…6997In export.csv?days=25: the row with attempted_at 2026-10-20T09:31:52Z and resource_key agent.pocket.network/v1/us-macro.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-26 09:31 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/us-macro": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/us-macro": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/us-macro": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/us-macro": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/ethPOST

Latest attempt: 2026-10-19 03:32 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x1247…6b67 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xbec988aa…5ccfIn export.csv?days=26: the row with attempted_at 2026-10-19T03:32:25Z and resource_key agent.pocket.network/v1/eth.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-25 03:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/eth": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/eth": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/eth": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/eth": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/ocr-document-parsingPOST

On 2026-10-17 15:32 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-10-23 15:32 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-10-17 15:32 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: · the full answer

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x052a…1f47 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=27: the row with attempted_at 2026-10-17T15:32:18Z and resource_key agent.pocket.network/v1/ocr-document-parsing.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-23 15:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/ocr-document-parsing": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/ocr-document-parsing": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/ocr-document-parsing": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/ocr-document-parsing": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/taint-checkPOST

On 2026-10-16 12:02 UTC, vet402 signed a payment and the paid request answered HTTP 502. This row is not on the seller's side yet, because that needs such a failure (a failure vet402 can show was not its own) at this listing on two different UTC days. If the failure is real, check the route's logs, and the next purchase by vet402 is not before 2026-10-22 12:02 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

Latest attempt: 2026-10-16 12:02 UTC
Result: Server error on the paid request
Whose side: not sorted: one failure so far

Decision API now: · the full answer

What vet402 saw: vet402 signed the payment and the paid request got a 5xx.Last result about the seller: none among the attempts shown. The latest attempt is not sorted. There has been no attempt since.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xeb1a…c1eb · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.What to fix: 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.Recorded (L1 attempt, vet402 signed a payment, not settled on-chain): settle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no txIn export.csv?days=29: the row with attempted_at 2026-10-16T12:02:00Z and resource_key agent.pocket.network/v1/taint-check.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-22 12:02 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/taint-check": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/taint-check": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/taint-check": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/taint-check": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/pocketPOST
Latest attempt
2026-10-09 20:32 UTC
Result
delivered
Whose side
no failure (delivered)
Decision API now: · the full answer
Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 22:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 22:40 UTC (within 120 hours of the last).
What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0x7da1…217e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.The latest purchase delivered. An earlier attempt listed below did not.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x111970f5…6b2dIn export.csv?days=35: the row with attempted_at 2026-10-09T20:32:26Z and resource_key agent.pocket.network/v1/pocket.
After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-15 20:32 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.
Fix code for Express, Next.js, Hono and FastAPI
Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.
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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pocket": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/pocket": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/pocket": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/pocket": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

@app.middleware("http")
async def x402_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)
```
Earlier attempts
1. 2026-10-02 18:02 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xce1e2913…e141
  What vet402 recorded
  Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xfd2f…27bd · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.
  Dispute this purchase
2. 2026-09-22 00:02 UTC · No record of the input vet402 sent · not sorted: vet402 unprovensettle_failed (vet402 signed a payment and got no settlement receipt back) · HTTP 502 · no tx
  What vet402 recorded
  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.The 402 terms vet402 signed: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query not recorded. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xa2bc…d241 · validBefore not recorded.Answer to the paid request: HTTP 502 · Content-Type application/json; charset=utf-8 · no PAYMENT-RESPONSE recorded.Not shown for this row: vet402 has no record of the input it sent.
  Dispute this purchase

agent.pocket.network/v1/zksync-eraPOST

Latest attempt: 2026-10-08 03:31 UTC
Result: delivered
Whose side: no failure (delivered)

Decision API now: · the full answer

What vet402 saw: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.005 USDC · payTo 0xf732…b829. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 60. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xf732…b829 · nonce 0xbae9…177d · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json; charset=utf-8 · PAYMENT-RESPONSE: success true, names a transaction.Recorded (L1 paid purchase): settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x99edf2a0…b4a5In export.csv?days=37: the row with attempted_at 2026-10-08T03:31:54Z and resource_key agent.pocket.network/v1/zksync-era.

After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-10-14 03:31 UTC (a listing is bought at most once every 6 days). When it does depends on the daily budget and the order of demand, so there is no booked date.Email me when this result changes Dispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/zksync-era": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", new ExactEvmScheme())

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

export const POST = withX402(
  handler,
  {
    "/v1/zksync-era": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", asset: "<...>" },
        network: "eip155:8453",
      },
    },
  },
  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("eip155:8453", new ExactEvmScheme())

app.use(
  paymentMiddleware(
    {
      "POST /v1/zksync-era": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", asset: "<...>" },
          network: "eip155:8453",
        },
      },
    },
    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("eip155:8453", ExactEvmServerScheme())

routes = {
    "POST /v1/zksync-era": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "eip155:8453",
        },
    },
}

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

agent.pocket.network/v1/agent-trustPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 00:32 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 00:32 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/agent-trust": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/agent-trust": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/agent-trust": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/agent-trust": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/agentsearch-web-extract-v1POST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 18:31 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 18:31 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/agentsearch-web-extract-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/agentsearch-web-extract-v1": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/agentsearch-web-extract-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/agentsearch-web-extract-v1": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/akashPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 14:32 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 14:32 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/akash": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/akash": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/akash": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/akash": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/arb-onePOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 14:31 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 14:31 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/arb-one": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/arb-one": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/arb-one": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/arb-one": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/avaxPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/avax": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/avax": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/avax": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/avax": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/backtest-reconcile-v1POST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/backtest-reconcile-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/backtest-reconcile-v1": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/backtest-reconcile-v1": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/backtest-reconcile-v1": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/barcode-toolsPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): fail (no_402) at 2026-11-11 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 04:40 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/barcode-tools": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/barcode-tools": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/barcode-tools": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/barcode-tools": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/beraPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 18:30 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 18:30 UTC (within 120 hours of the last).

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/bera": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/bera": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/bera": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/bera": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

agent.pocket.network/v1/blastPOST

Latest attempt: not tried on Base yet
Result: not tried on Base yet
Whose side: not tried on Base yet

Decision API now: · the full answer

No Base purchase is on this listing.

After a fixEmail me when this result changes Dispute this recordA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.

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

Paste one snippet for the stack you run. vet402 fills payTo, the atomic amount, the CAIP-2 network, and the path from this listing. A value the listing does not have stays <...>.

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(
    {
      "POST /v1/blast": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 POST = withX402(
  handler,
  {
    "/v1/blast": {
      accepts: {
        scheme: "exact",
        payTo: "<...>",
        price: { amount: "5000", 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(
    {
      "POST /v1/blast": {
        accepts: {
          scheme: "exact",
          payTo: "<...>",
          price: { amount: "5000", 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 = {
    "POST /v1/blast": {
        "accepts": {
            "scheme": "exact",
            "payTo": "<...>",
            "price": {"amount": "5000", "asset": "<...>"},
            "network": "<...>",
        },
    },
}

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

2.How to read this

Each listing shows its latest Base attempt and up to four earlier Base attempts. Result and Whose side follow that Base attempt. A purchase on another chain is listed under Other chains, with the chain name, time, status, HTTP status, and a transaction link when one was recorded. The record page shows that purchase in the Payment chain column. A row where vet402 signed a payment and sent the paid request is an L1 result: “Recorded (L1 paid purchase)” when the payment settled on-chain, and “signed, not settled on-chain” when it did not. A row where vet402 did not sign is marked “not bought” and is not an L1 result. The listing's record page also shows the L0 state (“Published state”), which checks that an unpaid request gets a valid 402, so a listing can pass L0 and still fail here. Whose side puts a failure on the seller's side when the row shows vet402 was not at fault: it signed on the listing's terms, its wallet held the price, it sent the declared input, and the seller answered explicitly or had its declared time. Even then, one such failure is “not sorted: one failure so far”: a failure goes on the seller's side only when the same listing has one on two different days (UTC), and those rows are marked “attribution under review” while that review runs. The review has no set date. A row that cannot show all of that is “not sorted”, and so is a held row (held_reason in the export), a failure where no payment was taken (“no charge”), and a payment that settled before the seller refused an input vet402 had not sent. “Signed payment” and “Answer to the paid request” show what the row recorded, and nothing else: the answer's body and header values are not published. The maxTimeoutSeconds on a row is the listing's value today; a declared price or address on a not-bought row is the value recorded at the time of the attempt. The transaction link opens the settlement on Basescan when the purchase is on Base. “Decision API now” is what the decision API (GET /api/v1/resources/{id}/decision?role=payer, no key) answers for the listing when you open this page; your browser asks it for the first 2 listings, and for the others when you ask. It reads the same sorting as this page: a failure counts against the seller only when this page puts it on the seller's side. A paid attempt that took payment and did not deliver is a WARN, and two or more of them on the seller's side since the last delivery are the only way a failed purchase makes it a BLOCK; a listing whose failures this page leaves not sorted gets at most a WARN from them. An L0 check that is unverified (not probed yet, or not measurable) is a WARN, not a BLOCK. The codes that decided the answer come first, each with the meaning from the reason-code table (reason codes). “After a fix” gives the earliest date vet402's regular sweep can buy the listing again, where the rules let it be worked out, and the links to be told of a change or to dispute a row. Listings removed from the Bazaar, and listings whose catalog network is not Base, are not on this page. The fix-first page groups the same results across sellers (methodology).

3.Think a row is wrong?

Use “Dispute this purchase” on the row: it opens Dispute this record on the listing's record page with the purchase time filled in. The time filled in is the latest Base attempt when that listing has a Base purchase. Say what you saw instead. The row is not deleted on dispute; a correction is published with the same weight.