api.fadeandco.workers.dev: x402 purchase results on Base, latest attempt 2026-11-12 on Arc

136 Base listings. Latest result about the seller at each listing: 10 delivered · 1 failed on the seller's side · 1 with no such result among the attempts shown · 124 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.

Also bought on other chains: 38 listings (Celo 24, Arc 10, Avalanche C-Chain 2, Stellar 1, XRPL 1). Each card lists them under Other chains.

By the latest attempt at each listing, whatever it was: 10 delivered · 1 failed on the seller's side · 0 on vet402's side · 1 not bought (vet402 did not pay) · 124 with no Base purchase.

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

[![vet402 record for api.fadeandco.workers.dev](https://vet402.com/api/badge/host/api.fadeandco.workers.dev.svg)](https://vet402.com/sellers/api.fadeandco.workers.dev)

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

1.Your listings

1. api.fadeandco.workers.dev/api/dev/nba-statsGET

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Arc, 2026-11-12 12:01 UTC, settled, HTTP 200 transaction

   Decision API now: asking… · 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).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-12-12 12:01 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 changesDispute 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(
       {
         "GET /api/dev/nba-stats": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/dev/nba-stats": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/dev/nba-stats": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/dev/nba-stats": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

2. api.fadeandco.workers.dev/api/agent-intel/cross-chain-bridge-liquidityGET

   Latest Base attempt

   2026-11-06 06:00 UTC

   Result

   delivered

   Whose side

   no failure (delivered)

   Other chains

   Celo, 2026-11-12 12:01 UTC, settled, HTTP 200 transaction

   Decision API now: asking… · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x0c3c…6c6a · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x3bbf804c…4f03In export.csv?days=8: the row with attempted_at 2026-11-06T06:00:59Z and resource_key api.fadeandco.workers.dev/api/agent-intel/cross-chain-bridge-liquidity.

   After a fixNext purchase by vet402: Not before 2026-12-12 12:01 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 changesDispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.The time filled in for the dispute is the latest Base attempt.

   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(
       {
         "GET /api/agent-intel/cross-chain-bridge-liquidity": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/agent-intel/cross-chain-bridge-liquidity": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/agent-intel/cross-chain-bridge-liquidity": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/agent-intel/cross-chain-bridge-liquidity": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "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-31 03:30 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x5cff0662…5871
      What vet402 recorded

      Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0xd2da…5e5d · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
      Dispute this purchase
3. api.fadeandco.workers.dev/api/agent-intel/dex-depth-slippage-calculatorGET

   Latest Base attempt

   2026-11-06 03:31 UTC

   Result

   delivered

   Whose side

   no failure (delivered)

   Other chains

   Celo, 2026-11-12 12:00 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x5085…ccfc · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x4762bf9f…8d7dIn export.csv?days=8: the row with attempted_at 2026-11-06T03:31:28Z and resource_key api.fadeandco.workers.dev/api/agent-intel/dex-depth-slippage-calculator.

   After a fixNext purchase by vet402: Not before 2026-12-12 12:00 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 changesDispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.The time filled in for the dispute is the latest Base attempt.

   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(
       {
         "GET /api/agent-intel/dex-depth-slippage-calculator": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/agent-intel/dex-depth-slippage-calculator": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/agent-intel/dex-depth-slippage-calculator": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/agent-intel/dex-depth-slippage-calculator": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "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-31 00:00 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x18e742b3…0734
      What vet402 recorded

      Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x0790…524b · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
      Dispute this purchase
4. api.fadeandco.workers.dev/api/agent-intel/viral-trending-radarGET

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Arc, 2026-11-12 06:01 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · the full answer
   Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 04:41 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 04:41 UTC (within 120 hours of the last).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-12-12 06:01 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 changesDispute 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(
       {
         "GET /api/agent-intel/viral-trending-radar": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/agent-intel/viral-trending-radar": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/agent-intel/viral-trending-radar": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/agent-intel/viral-trending-radar": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

5. api.fadeandco.workers.dev/api/dev/pinnacle-oddsGET

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Celo, 2026-11-12 03:30 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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 fixNext purchase by vet402: Not before 2026-11-18 03:30 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 changesDispute 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(
       {
         "GET /api/dev/pinnacle-odds": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/dev/pinnacle-odds": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/dev/pinnacle-odds": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/dev/pinnacle-odds": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

6. api.fadeandco.workers.dev/api/dev/action-networkGET

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Celo, 2026-11-10 12:01 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-11-16 12:01 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 changesDispute 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(
       {
         "GET /api/dev/action-network": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/dev/action-network": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/dev/action-network": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/dev/action-network": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

7. api.fadeandco.workers.dev/api/agent-intel/highres-qr-code-generatorPOST

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Arc, 2026-11-10 00:01 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-12-10 00:01 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 changesDispute 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 /api/agent-intel/highres-qr-code-generator": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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,
     {
       "/api/agent-intel/highres-qr-code-generator": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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 /api/agent-intel/highres-qr-code-generator": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 /api/agent-intel/highres-qr-code-generator": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

8. api.fadeandco.workers.dev/api/agent-intel/subdomain-takeover-monitorGET

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Celo, 2026-11-10 00:00 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-11-16 00:00 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 changesDispute 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(
       {
         "GET /api/agent-intel/subdomain-takeover-monitor": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 GET = withX402(
     handler,
     {
       "/api/agent-intel/subdomain-takeover-monitor": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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(
       {
         "GET /api/agent-intel/subdomain-takeover-monitor": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 = {
       "GET /api/agent-intel/subdomain-takeover-monitor": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

9. api.fadeandco.workers.dev/api/agent-intel/reader-markdown-extractPOST

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Other chains

   Arc, 2026-11-09 21:31 UTC, settled, HTTP 200 transaction

   Decision API now: ask for this listing · 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).
   No Base purchase is on this listing.

   After a fixNext purchase by vet402: Not before 2026-12-09 21:31 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 changesDispute 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 /api/agent-intel/reader-markdown-extract": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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,
     {
       "/api/agent-intel/reader-markdown-extract": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "2000", 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 /api/agent-intel/reader-markdown-extract": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "2000", 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 /api/agent-intel/reader-markdown-extract": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "2000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

10. api.fadeandco.workers.dev/api/agent-intel/agent-json-schema-guardPOST

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-09 18:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-12-09 18:01 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 changesDispute 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 /api/agent-intel/agent-json-schema-guard": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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,
      {
        "/api/agent-intel/agent-json-schema-guard": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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 /api/agent-intel/agent-json-schema-guard": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 /api/agent-intel/agent-json-schema-guard": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

11. api.fadeandco.workers.dev/api/agent-intel/known-scams-blacklist-dbGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-09 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-12-09 15:31 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 changesDispute 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(
        {
          "GET /api/agent-intel/known-scams-blacklist-db": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/known-scams-blacklist-db": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/known-scams-blacklist-db": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/known-scams-blacklist-db": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

12. api.fadeandco.workers.dev/api/agent-intel/ssl-certificate-transparencyGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-09 00:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-12-09 00:01 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 changesDispute 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(
        {
          "GET /api/agent-intel/ssl-certificate-transparency": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/ssl-certificate-transparency": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/ssl-certificate-transparency": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/ssl-certificate-transparency": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

13. api.fadeandco.workers.dev/api/agent-intel/onchain-mvrv-valuationGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-08 21:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-14 21:31 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 changesDispute 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(
        {
          "GET /api/agent-intel/onchain-mvrv-valuation": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/onchain-mvrv-valuation": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/onchain-mvrv-valuation": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/onchain-mvrv-valuation": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

14. api.fadeandco.workers.dev/api/agent-intel/typosquat-phishing-domain-radarGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-08 21:30 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-14 21:30 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 changesDispute 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(
        {
          "GET /api/agent-intel/typosquat-phishing-domain-radar": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/typosquat-phishing-domain-radar": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/typosquat-phishing-domain-radar": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/typosquat-phishing-domain-radar": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

15. api.fadeandco.workers.dev/api/agent-intel/crosschain-gas-priority-feeGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-08 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-12-08 15:31 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 changesDispute 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(
        {
          "GET /api/agent-intel/crosschain-gas-priority-fee": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/crosschain-gas-priority-fee": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/crosschain-gas-priority-fee": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/crosschain-gas-priority-fee": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

16. api.fadeandco.workers.dev/api/agent-intel/x402-endpoint-health-vettingGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-08 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-12-08 15:31 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 changesDispute 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(
        {
          "GET /api/agent-intel/x402-endpoint-health-vetting": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/x402-endpoint-health-vetting": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/x402-endpoint-health-vetting": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/x402-endpoint-health-vetting": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

17. api.fadeandco.workers.dev/api/agent-intel/html-dom-to-clean-markdownPOST

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Arc, 2026-11-08 00:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-14 00:01 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 changesDispute 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 /api/agent-intel/html-dom-to-clean-markdown": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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,
      {
        "/api/agent-intel/html-dom-to-clean-markdown": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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 /api/agent-intel/html-dom-to-clean-markdown": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 /api/agent-intel/html-dom-to-clean-markdown": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

18. api.fadeandco.workers.dev/api/agent-intel/ofac-sanctions-preflightGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-07 18:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-13 18:01 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 changesDispute 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(
        {
          "GET /api/agent-intel/ofac-sanctions-preflight": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/ofac-sanctions-preflight": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/ofac-sanctions-preflight": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/ofac-sanctions-preflight": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

19. api.fadeandco.workers.dev/api/agent-intel/gleif-corporate-lei-registryGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-07 18:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-13 18:01 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 changesDispute 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(
        {
          "GET /api/agent-intel/gleif-corporate-lei-registry": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/gleif-corporate-lei-registry": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/gleif-corporate-lei-registry": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/gleif-corporate-lei-registry": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

20. api.fadeandco.workers.dev/api/agent-intel/ip-fraud-reputation-scoreGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    XRPL, 2026-11-07 09:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-13 09:31 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 changesDispute 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(
        {
          "GET /api/agent-intel/ip-fraud-reputation-score": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/ip-fraud-reputation-score": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/ip-fraud-reputation-score": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/ip-fraud-reputation-score": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

21. api.fadeandco.workers.dev/api/agent-intel/hallucination-claim-checkerPOST

    Latest Base attempt

    2026-10-31 06:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Other chains

    Celo, 2026-11-06 21:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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.003 USDC · payTo 0xb849…eafa. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0xd6ae…816e · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x72f7247c…6d9fIn export.csv?days=14: the row with attempted_at 2026-10-31T06:01:17Z and resource_key api.fadeandco.workers.dev/api/agent-intel/hallucination-claim-checker.

    After a fixNext purchase by vet402: Not before 2026-11-12 21:31 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 changesDispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.The time filled in for the dispute is the latest Base attempt.

    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 /api/agent-intel/hallucination-claim-checker": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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,
      {
        "/api/agent-intel/hallucination-claim-checker": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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 /api/agent-intel/hallucination-claim-checker": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 /api/agent-intel/hallucination-claim-checker": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "asset": "<...>"},
                "network": "eip155:8453",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

22. api.fadeandco.workers.dev/api/agent-intel/anti-whale-limit-detectorGET

    On 2026-11-06 21:30 UTC, vet402 signed a payment and the paid request answered HTTP 503. 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-31 and 2026-11-06. Check the route's logs, and the next purchase by vet402 is not before 2026-11-12 21:30 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

    Latest attempt

    2026-11-06 21:30 UTC

    Result

    Server error on the paid request

    Whose side

    seller's side attribution under review

    Decision API now: ask for this listing · 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).
    What vet402 saw: vet402 signed the payment and the paid request got a 5xx.The 402 terms vet402 signed: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x3137…ca49 · validBefore not recorded.Answer to the paid request: HTTP 503 · Content-Type application/json · 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 503 · no txIn export.csv?days=7: the row with attempted_at 2026-11-06T21:30:45Z and resource_key api.fadeandco.workers.dev/api/agent-intel/anti-whale-limit-detector.

    After a fixNext purchase by vet402: Not before 2026-11-12 21:30 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 changesDispute 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(
        {
          "GET /api/agent-intel/anti-whale-limit-detector": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/anti-whale-limit-detector": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/anti-whale-limit-detector": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/anti-whale-limit-detector": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "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-31 00:01 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 503 · no tx
       What vet402 recorded

       vet402 signed the payment and the paid request got a 5xx.The 402 terms vet402 signed: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x190f…dea4 · validBefore not recorded.Answer to the paid request: HTTP 503 · Content-Type application/json · no PAYMENT-RESPONSE recorded.
       Dispute this purchase
23. api.fadeandco.workers.dev/api/dev/espn-nhl-scoreboardGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Stellar, 2026-11-06 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-10 04:41 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-15 04:41 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: Not before 2026-11-12 15:31 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 changesDispute 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(
        {
          "GET /api/dev/espn-nhl-scoreboard": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/dev/espn-nhl-scoreboard": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/dev/espn-nhl-scoreboard": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/dev/espn-nhl-scoreboard": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

24. api.fadeandco.workers.dev/api/dev/espn-standingsGET

    Latest Base attempt

    2026-10-31 00:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Other chains

    Celo, 2026-11-06 12:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x7ca5…6fa7 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x410fd035…ada8In export.csv?days=14: the row with attempted_at 2026-10-31T00:01:37Z and resource_key api.fadeandco.workers.dev/api/dev/espn-standings.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 12: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 changesDispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.The time filled in for the dispute is the latest Base attempt.

    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(
        {
          "GET /api/dev/espn-standings": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/dev/espn-standings": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/dev/espn-standings": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/dev/espn-standings": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "eip155:8453",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

25. api.fadeandco.workers.dev/api/agent-intel/whale-transaction-monitorGET

    Latest attempt

    2026-11-06 12:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0x7fde…dca6 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0xdb2f207d…c698In export.csv?days=8: the row with attempted_at 2026-11-06T12:01:24Z and resource_key api.fadeandco.workers.dev/api/agent-intel/whale-transaction-monitor.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 12: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 changesDispute 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(
        {
          "GET /api/agent-intel/whale-transaction-monitor": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/whale-transaction-monitor": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/whale-transaction-monitor": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/whale-transaction-monitor": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "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-31 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 0xf7abe85b…29c6
       What vet402 recorded

       Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0xc267…e9a7 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
       Dispute this purchase
26. api.fadeandco.workers.dev/api/agent-intel/cex-exchange-reserve-flowsGET

    Latest attempt

    2026-11-06 12:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x64af…6d23 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x2e3c1757…aff4In export.csv?days=8: the row with attempted_at 2026-11-06T12:01:04Z and resource_key api.fadeandco.workers.dev/api/agent-intel/cex-exchange-reserve-flows.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 12: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 changesDispute 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(
        {
          "GET /api/agent-intel/cex-exchange-reserve-flows": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/cex-exchange-reserve-flows": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/cex-exchange-reserve-flows": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/cex-exchange-reserve-flows": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "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-31 09:30 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xa58cba26…0fa1
       What vet402 recorded

       Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x0409…f6b5 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
       Dispute this purchase
27. api.fadeandco.workers.dev/api/agent-intel/wallet-pnl-performance-auditGET

    Latest attempt

    2026-11-06 09:30 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0x0562…8d21 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0xee13c913…5e9cIn export.csv?days=8: the row with attempted_at 2026-11-06T09:30:58Z and resource_key api.fadeandco.workers.dev/api/agent-intel/wallet-pnl-performance-audit.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 09:30 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 changesDispute 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(
        {
          "GET /api/agent-intel/wallet-pnl-performance-audit": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/wallet-pnl-performance-audit": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/wallet-pnl-performance-audit": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/wallet-pnl-performance-audit": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "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-31 06:01 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xaf68e61b…0dec
       What vet402 recorded

       Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0xeb75…c9d3 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
       Dispute this purchase
28. api.fadeandco.workers.dev/api/agent-intel/wallet-forensic-profilerGET

    Latest attempt

    2026-11-06 09:30 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0x7e2a…7ff1 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0x8998d5eb…5aafIn export.csv?days=8: the row with attempted_at 2026-11-06T09:30:35Z and resource_key api.fadeandco.workers.dev/api/agent-intel/wallet-forensic-profiler.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 09:30 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 changesDispute 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(
        {
          "GET /api/agent-intel/wallet-forensic-profiler": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/wallet-forensic-profiler": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/wallet-forensic-profiler": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/wallet-forensic-profiler": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "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-31 06:01 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0xf9f90154…8779
       What vet402 recorded

       Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.003 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.003 USDC · payTo 0xb849…eafa · nonce 0x3cdb…632f · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
       Dispute this purchase
29. api.fadeandco.workers.dev/api/agent-intel/defi-yield-risk-optimizerGET

    Latest attempt

    2026-11-06 06:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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: Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0xda41…bdb6 · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0xbfed7191…8bbcIn export.csv?days=8: the row with attempted_at 2026-11-06T06:01:16Z and resource_key api.fadeandco.workers.dev/api/agent-intel/defi-yield-risk-optimizer.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 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.Email me when this result changesDispute 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(
        {
          "GET /api/agent-intel/defi-yield-risk-optimizer": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/defi-yield-risk-optimizer": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/defi-yield-risk-optimizer": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/defi-yield-risk-optimizer": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "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-31 03:31 UTC · delivered · no failure (delivered)settled (vet402 re-read the transfer on-chain in that chain's pinned settlement asset) · HTTP 200 · tx 0x4a45631e…5106
       What vet402 recorded

       Paid; vet402 confirmed the transfer on-chain and the paid request answered HTTP 200.The 402 terms vet402 paid: exact · 0.002 USDC · payTo 0xb849…eafa. Input sent: body none, query declared. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.002 USDC · payTo 0xb849…eafa · nonce 0x985b…5c1f · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · PAYMENT-RESPONSE: success true, names a transaction.
       Dispute this purchase
30. api.fadeandco.workers.dev/api/agent-intel/sec-edgar-filings-searchGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-06 00:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 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 changesDispute 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(
        {
          "GET /api/agent-intel/sec-edgar-filings-search": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/sec-edgar-filings-search": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/sec-edgar-filings-search": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/sec-edgar-filings-search": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

31. api.fadeandco.workers.dev/api/agent-intel/consumer-product-recallsGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-06 00:00 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-12 00:00 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 changesDispute 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(
        {
          "GET /api/agent-intel/consumer-product-recalls": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/consumer-product-recalls": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/consumer-product-recalls": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/consumer-product-recalls": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

32. api.fadeandco.workers.dev/api/dev/teamrankingsGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-05 09:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-11 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 changesDispute 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(
        {
          "GET /api/dev/teamrankings": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/dev/teamrankings": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/dev/teamrankings": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/dev/teamrankings": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

33. api.fadeandco.workers.dev/api/agent-intel/marine-weather-tide-forecastGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-04 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-10 15: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 changesDispute 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(
        {
          "GET /api/agent-intel/marine-weather-tide-forecast": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/marine-weather-tide-forecast": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/marine-weather-tide-forecast": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/marine-weather-tide-forecast": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

34. api.fadeandco.workers.dev/api/agent-intel/dnssec-trust-chain-validatorGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-04 15:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-10 15: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 changesDispute 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(
        {
          "GET /api/agent-intel/dnssec-trust-chain-validator": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/dnssec-trust-chain-validator": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/dnssec-trust-chain-validator": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/dnssec-trust-chain-validator": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

35. api.fadeandco.workers.dev/api/agent-intel/ecb-institutional-fx-ratesGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-03 23:01 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-09 23: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 changesDispute 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(
        {
          "GET /api/agent-intel/ecb-institutional-fx-rates": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/ecb-institutional-fx-rates": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/ecb-institutional-fx-rates": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/ecb-institutional-fx-rates": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

36. api.fadeandco.workers.dev/api/agent-intel/api-sla-liveness-benchmarkGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-03 23:00 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-09 23:00 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 changesDispute 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(
        {
          "GET /api/agent-intel/api-sla-liveness-benchmark": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/api-sla-liveness-benchmark": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/api-sla-liveness-benchmark": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/api-sla-liveness-benchmark": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

37. api.fadeandco.workers.dev/api/agent-intel/iban-routing-swift-resolverGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-03 20:30 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-09 20:30 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 changesDispute 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(
        {
          "GET /api/agent-intel/iban-routing-swift-resolver": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/iban-routing-swift-resolver": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/iban-routing-swift-resolver": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/iban-routing-swift-resolver": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

38. api.fadeandco.workers.dev/api/agent-intel/cors-security-misconfig-auditGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-01 09:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 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 changesDispute 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(
        {
          "GET /api/agent-intel/cors-security-misconfig-audit": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/cors-security-misconfig-audit": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/cors-security-misconfig-audit": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/cors-security-misconfig-audit": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

39. api.fadeandco.workers.dev/api/agent-intel/prompt-injection-firewallPOST

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-11-01 09:30 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-07 09:30 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 changesDispute 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 /api/agent-intel/prompt-injection-firewall": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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,
      {
        "/api/agent-intel/prompt-injection-firewall": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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 /api/agent-intel/prompt-injection-firewall": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 /api/agent-intel/prompt-injection-firewall": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

40. api.fadeandco.workers.dev/api/dev/dicks-sporting-goodsGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Avalanche C-Chain, 2026-10-31 21:31 UTC, settle_failed, HTTP 400

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 22:30 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 22:30 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 21: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 changesDispute 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(
        {
          "GET /api/dev/dicks-sporting-goods": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "20000", 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 GET = withX402(
      handler,
      {
        "/api/dev/dicks-sporting-goods": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "20000", 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(
        {
          "GET /api/dev/dicks-sporting-goods": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "20000", 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 = {
        "GET /api/dev/dicks-sporting-goods": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "20000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

41. api.fadeandco.workers.dev/api/dev/trustradiusGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Avalanche C-Chain, 2026-10-31 21:31 UTC, settle_failed, HTTP 400

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 22:30 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 22:30 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 21: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 changesDispute 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(
        {
          "GET /api/dev/trustradius": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "20000", 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 GET = withX402(
      handler,
      {
        "/api/dev/trustradius": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "20000", 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(
        {
          "GET /api/dev/trustradius": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "20000", 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 = {
        "GET /api/dev/trustradius": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "20000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

42. api.fadeandco.workers.dev/api/agent-intel/scam-phishing-message-filterPOST

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-10-31 09:31 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 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 changesDispute 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 /api/agent-intel/scam-phishing-message-filter": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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,
      {
        "/api/agent-intel/scam-phishing-message-filter": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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 /api/agent-intel/scam-phishing-message-filter": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 /api/agent-intel/scam-phishing-message-filter": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

43. api.fadeandco.workers.dev/api/agent-intel/global-postal-geocode-resolverGET

    On 2026-10-25 08:00 UTC, vet402 did not sign a payment (the 402's amount was not the listing's price). This is not a purchase result, so it is not counted against the seller. The next purchase by vet402 is not before 2026-11-06 09:30 UTC, with no booked time. After that it depends on the daily budget and the order of demand.

    Latest Base attempt

    2026-10-25 08:00 UTC

    Result

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

    Whose side

    not bought: vet402 did not pay

    Other chains

    Celo, 2026-10-31 09:30 UTC, settled, HTTP 200 transaction

    Decision API now: ask for this listing · 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: vet402 pays the price the listing declares. The amount in the 402 was a different number, so vet402 did not sign.Last result about the seller: none among the attempts shown. The latest Base attempt was not a purchase (vet402 did not pay).The 402 vet402 saw: The 402 offered: exact · eip155:8453 · amount 2000 · asset 0x8335…2913 · payTo 0xb849…eAfA · maxTimeoutSeconds 300; exact · solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp · amount 2000 · asset EPjFWd…Dt1v · payTo J8vnmB…RdhR · maxTimeoutSeconds 300; exact · eip155:5042 · amount 2000 · asset 0x3600…0000 · payTo 0xa475…9be3 · maxTimeoutSeconds 300; exact · eip155:137 · amount 2000 · asset 0x3c49…3359 · payTo 0xb849…eAfA · maxTimeoutSeconds 300. At the time, the listing declared price 0.001 · payTo 0xb849…eafa.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): price_mismatch (the 402's amount differed from the listing's price, so nothing was paid) · HTTP — · no txIn export.csv?days=20: the row with attempted_at 2026-10-25T08:00:25Z and resource_key api.fadeandco.workers.dev/api/agent-intel/global-postal-geocode-resolver.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 09:30 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 changesDispute this purchaseA dispute does not start a purchase. The signed dispute route runs one fresh L0 check, an unpaid request.The time filled in for the dispute is the latest Base attempt.

    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(
        {
          "GET /api/agent-intel/global-postal-geocode-resolver": {
            accepts: {
              scheme: "exact",
              payTo: "0xb8491f953e6860d3b5840b73c60883ff099ceafa",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/global-postal-geocode-resolver": {
          accepts: {
            scheme: "exact",
            payTo: "0xb8491f953e6860d3b5840b73c60883ff099ceafa",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/global-postal-geocode-resolver": {
            accepts: {
              scheme: "exact",
              payTo: "0xb8491f953e6860d3b5840b73c60883ff099ceafa",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/global-postal-geocode-resolver": {
            "accepts": {
                "scheme": "exact",
                "payTo": "0xb8491f953e6860d3b5840b73c60883ff099ceafa",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

44. api.fadeandco.workers.dev/api/agent-intel/deep-researchPOST

    Latest attempt

    2026-10-31 00:01 UTC

    Result

    delivered

    Whose side

    no failure (delivered)

    Decision API now: ask for this listing · 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 0xb849…eafa. Input sent: body declared, query empty. The listing's maxTimeoutSeconds is 300. vet402 waits 20 seconds for the paid answer.Signed payment: scheme exact · 0.005 USDC · payTo 0xb849…eafa · nonce 0xf46c…6d0a · validBefore not recorded.Answer to the paid request: HTTP 200 · Content-Type application/json · 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 0xb8e6a101…6b5bIn export.csv?days=14: the row with attempted_at 2026-10-31T00:01:01Z and resource_key api.fadeandco.workers.dev/api/agent-intel/deep-research.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-06 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 changesDispute 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 /api/agent-intel/deep-research": {
            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,
      {
        "/api/agent-intel/deep-research": {
          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 /api/agent-intel/deep-research": {
            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 /api/agent-intel/deep-research": {
            "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)

45. api.fadeandco.workers.dev/api/agent-intel/citation-verifierPOST

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Other chains

    Celo, 2026-10-26 20:01 UTC, settle_failed, HTTP 402

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 02:30 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 02:30 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixNext purchase by vet402: The regular sweep can pick this listing again since 2026-11-01 20: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 changesDispute 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 /api/agent-intel/citation-verifier": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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,
      {
        "/api/agent-intel/citation-verifier": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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 /api/agent-intel/citation-verifier": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 /api/agent-intel/citation-verifier": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

46. api.fadeandco.workers.dev/api/agent-intel/bundle-sniper-detectorGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 14:30 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 14:30 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixEmail me when this result changesDispute 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(
        {
          "GET /api/agent-intel/bundle-sniper-detector": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/bundle-sniper-detector": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/bundle-sniper-detector": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/bundle-sniper-detector": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

47. api.fadeandco.workers.dev/api/agent-intel/bytecode-similarity-radarGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 02:31 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 02:31 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixEmail me when this result changesDispute 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(
        {
          "GET /api/agent-intel/bytecode-similarity-radar": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/bytecode-similarity-radar": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/bytecode-similarity-radar": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/bytecode-similarity-radar": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

48. api.fadeandco.workers.dev/api/agent-intel/deployer-rug-forensicsGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Decision API now: ask for this listing · the full answer
    Latest L0 check (the 402 to an unpaid request): pass at 2026-11-11 02:31 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 02:31 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixEmail me when this result changesDispute 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(
        {
          "GET /api/agent-intel/deployer-rug-forensics": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/deployer-rug-forensics": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "3000", 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(
        {
          "GET /api/agent-intel/deployer-rug-forensics": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "3000", 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 = {
        "GET /api/agent-intel/deployer-rug-forensics": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "3000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

49. api.fadeandco.workers.dev/api/agent-intel/domain-authority-credibilityGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Decision API now: ask for this listing · 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 changesDispute 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(
        {
          "GET /api/agent-intel/domain-authority-credibility": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/domain-authority-credibility": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/domain-authority-credibility": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/domain-authority-credibility": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

50. api.fadeandco.workers.dev/api/agent-intel/eu-vies-vat-batch-validatorGET

    Latest attempt

    not tried on Base yet

    Result

    not tried on Base yet

    Whose side

    not tried on Base yet

    Decision API now: ask for this listing · 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 changesDispute 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(
        {
          "GET /api/agent-intel/eu-vies-vat-batch-validator": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 GET = withX402(
      handler,
      {
        "/api/agent-intel/eu-vies-vat-batch-validator": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "2000", 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(
        {
          "GET /api/agent-intel/eu-vies-vat-batch-validator": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "2000", 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 = {
        "GET /api/agent-intel/eu-vies-vat-batch-validator": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "2000", "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.