centralcity.ai: x402 purchase results on Base, latest attempt 2026-11-06

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

By the latest attempt at each listing, whatever it was: 1 delivered · 0 failed on the seller's side · 0 on vet402's side · 101 with no Base purchase.

Latest attempt: 2026-11-06 06:01 UTC. This page read the ledger at 2026-11-12 18:56 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 centralcity.ai](https://vet402.com/api/badge/host/centralcity.ai.svg)](https://vet402.com/sellers/centralcity.ai)

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

Rows marked census or retest were bought to give this seller a row of its own, to buy again after a failure on vet402's side, or to read again a listing whose latest delivery missed declared keys.

1.Your listings

1. centralcity.ai/api/public/x402/off_i6bmlezs7p4o223sPOST

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Decision API now: asking… · 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 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(
       {
         "POST /api/public/x402/off_i6bmlezs7p4o223s": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_i6bmlezs7p4o223s": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_i6bmlezs7p4o223s": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_i6bmlezs7p4o223s": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

2. centralcity.ai/api/public/x402/off_ii5tqhzpcepsikfqPOST

   Latest attempt

   not tried on Base yet

   Result

   not tried on Base yet

   Whose side

   not tried on Base yet

   Decision API now: asking… · the full answer
   Latest L0 check (the 402 to an unpaid request): pass at 2026-11-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
       {
         "POST /api/public/x402/off_ii5tqhzpcepsikfq": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_ii5tqhzpcepsikfq": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_ii5tqhzpcepsikfq": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_ii5tqhzpcepsikfq": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

3. centralcity.ai/api/public/x402/off_j3dnb4c7y3kqw2ivPOST

   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): unverified (rate_limited) at 2026-11-12 16:40 UTC. Unverified is not a failure. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
       {
         "POST /api/public/x402/off_j3dnb4c7y3kqw2iv": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_j3dnb4c7y3kqw2iv": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_j3dnb4c7y3kqw2iv": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_j3dnb4c7y3kqw2iv": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

4. centralcity.ai/api/public/x402/off_j7lqjismjc4weirmPOST

   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-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 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(
       {
         "POST /api/public/x402/off_j7lqjismjc4weirm": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_j7lqjismjc4weirm": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_j7lqjismjc4weirm": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_j7lqjismjc4weirm": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

5. centralcity.ai/api/public/x402/off_jiqmmndgrseexdhaPOST

   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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
       {
         "POST /api/public/x402/off_jiqmmndgrseexdha": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_jiqmmndgrseexdha": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_jiqmmndgrseexdha": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_jiqmmndgrseexdha": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

6. centralcity.ai/api/public/x402/off_jwxolozsezpepjqtPOST

   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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
       {
         "POST /api/public/x402/off_jwxolozsezpepjqt": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_jwxolozsezpepjqt": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_jwxolozsezpepjqt": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_jwxolozsezpepjqt": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

7. centralcity.ai/api/public/x402/off_lyo56v2wjprf7yvkPOST

   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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
       {
         "POST /api/public/x402/off_lyo56v2wjprf7yvk": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_lyo56v2wjprf7yvk": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_lyo56v2wjprf7yvk": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_lyo56v2wjprf7yvk": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

8. centralcity.ai/api/public/x402/off_mkdyxiovyajmhexmPOST

   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-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 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(
       {
         "POST /api/public/x402/off_mkdyxiovyajmhexm": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_mkdyxiovyajmhexm": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_mkdyxiovyajmhexm": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_mkdyxiovyajmhexm": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

9. centralcity.ai/api/public/x402/off_mnmsr62f3hxxv4eaPOST

   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-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 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(
       {
         "POST /api/public/x402/off_mnmsr62f3hxxv4ea": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_mnmsr62f3hxxv4ea": {
         accepts: {
           scheme: "exact",
           payTo: "<...>",
           price: { amount: "50000", 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/public/x402/off_mnmsr62f3hxxv4ea": {
           accepts: {
             scheme: "exact",
             payTo: "<...>",
             price: { amount: "50000", 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/public/x402/off_mnmsr62f3hxxv4ea": {
           "accepts": {
               "scheme": "exact",
               "payTo": "<...>",
               "price": {"amount": "50000", "asset": "<...>"},
               "network": "<...>",
           },
       },
   }
   
   @app.middleware("http")
   async def x402_middleware(request, call_next):
       return await payment_middleware(routes, server)(request, call_next)

10. centralcity.ai/api/public/x402/off_nmmegmfvun6cb4a7POST

    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-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 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(
        {
          "POST /api/public/x402/off_nmmegmfvun6cb4a7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_nmmegmfvun6cb4a7": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_nmmegmfvun6cb4a7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_nmmegmfvun6cb4a7": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

11. centralcity.ai/api/public/x402/off_o4st6ljpmnu55uf5POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_o4st6ljpmnu55uf5": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_o4st6ljpmnu55uf5": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_o4st6ljpmnu55uf5": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_o4st6ljpmnu55uf5": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

12. centralcity.ai/api/public/x402/off_opwnhfa2z6pcq4nyPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_opwnhfa2z6pcq4ny": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_opwnhfa2z6pcq4ny": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_opwnhfa2z6pcq4ny": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_opwnhfa2z6pcq4ny": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

13. centralcity.ai/api/public/x402/off_pcoojvpfj7ebutavPOST

    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-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 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(
        {
          "POST /api/public/x402/off_pcoojvpfj7ebutav": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pcoojvpfj7ebutav": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_pcoojvpfj7ebutav": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pcoojvpfj7ebutav": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

14. centralcity.ai/api/public/x402/off_pqnidpd6mbpql7ubPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_pqnidpd6mbpql7ub": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pqnidpd6mbpql7ub": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_pqnidpd6mbpql7ub": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pqnidpd6mbpql7ub": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

15. centralcity.ai/api/public/x402/off_pwdkt7sjzk4zgd5lPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_pwdkt7sjzk4zgd5l": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pwdkt7sjzk4zgd5l": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_pwdkt7sjzk4zgd5l": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pwdkt7sjzk4zgd5l": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

16. centralcity.ai/api/public/x402/off_pxeey2kmsbwtqvl5POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_pxeey2kmsbwtqvl5": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pxeey2kmsbwtqvl5": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_pxeey2kmsbwtqvl5": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_pxeey2kmsbwtqvl5": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

17. centralcity.ai/api/public/x402/off_q2vh2anmjnh25giePOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_q2vh2anmjnh25gie": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_q2vh2anmjnh25gie": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_q2vh2anmjnh25gie": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_q2vh2anmjnh25gie": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

18. centralcity.ai/api/public/x402/off_qwz6wyyzsco3fzcgPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_qwz6wyyzsco3fzcg": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_qwz6wyyzsco3fzcg": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_qwz6wyyzsco3fzcg": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_qwz6wyyzsco3fzcg": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

19. centralcity.ai/api/public/x402/off_rbfzstadtbrcuuj6POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rbfzstadtbrcuuj6": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rbfzstadtbrcuuj6": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rbfzstadtbrcuuj6": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rbfzstadtbrcuuj6": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

20. centralcity.ai/api/public/x402/off_rc3fdapiv5he2koqPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rc3fdapiv5he2koq": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rc3fdapiv5he2koq": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rc3fdapiv5he2koq": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rc3fdapiv5he2koq": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

21. centralcity.ai/api/public/x402/off_rja7oggvq67ctuybPOST

    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): unverified (rate_limited) at 2026-11-12 16:40 UTC. Unverified is not a failure. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rja7oggvq67ctuyb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rja7oggvq67ctuyb": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rja7oggvq67ctuyb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rja7oggvq67ctuyb": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

22. centralcity.ai/api/public/x402/off_rkxfinzvukkyhxuxPOST

    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-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 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(
        {
          "POST /api/public/x402/off_rkxfinzvukkyhxux": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rkxfinzvukkyhxux": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rkxfinzvukkyhxux": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rkxfinzvukkyhxux": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

23. centralcity.ai/api/public/x402/off_rmf4pq74eofi2rmbPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rmf4pq74eofi2rmb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rmf4pq74eofi2rmb": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rmf4pq74eofi2rmb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rmf4pq74eofi2rmb": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

24. centralcity.ai/api/public/x402/off_rny6k3roihhy74g4POST

    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-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 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(
        {
          "POST /api/public/x402/off_rny6k3roihhy74g4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rny6k3roihhy74g4": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rny6k3roihhy74g4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rny6k3roihhy74g4": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

25. centralcity.ai/api/public/x402/off_rtu7yptpionf5y2kPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rtu7yptpionf5y2k": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rtu7yptpionf5y2k": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rtu7yptpionf5y2k": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rtu7yptpionf5y2k": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

26. centralcity.ai/api/public/x402/off_rusq4ijknusdlwssPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_rusq4ijknusdlwss": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rusq4ijknusdlwss": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_rusq4ijknusdlwss": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_rusq4ijknusdlwss": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

27. centralcity.ai/api/public/x402/off_sq57ide6cdcjanrbPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_sq57ide6cdcjanrb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_sq57ide6cdcjanrb": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_sq57ide6cdcjanrb": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_sq57ide6cdcjanrb": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

28. centralcity.ai/api/public/x402/off_sukajade7wo45zxxPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_sukajade7wo45zxx": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_sukajade7wo45zxx": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_sukajade7wo45zxx": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_sukajade7wo45zxx": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

29. centralcity.ai/api/public/x402/off_szkyih7n5ezu2uktPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_szkyih7n5ezu2ukt": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_szkyih7n5ezu2ukt": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_szkyih7n5ezu2ukt": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_szkyih7n5ezu2ukt": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

30. centralcity.ai/api/public/x402/off_tjmuhvwbnzaor7oaPOST

    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): unverified (rate_limited) at 2026-11-12 16:40 UTC. Unverified is not a failure. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_tjmuhvwbnzaor7oa": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_tjmuhvwbnzaor7oa": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_tjmuhvwbnzaor7oa": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_tjmuhvwbnzaor7oa": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

31. centralcity.ai/api/public/x402/off_tpbmk4s4vbpb4bewPOST

    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-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 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(
        {
          "POST /api/public/x402/off_tpbmk4s4vbpb4bew": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_tpbmk4s4vbpb4bew": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_tpbmk4s4vbpb4bew": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_tpbmk4s4vbpb4bew": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

32. centralcity.ai/api/public/x402/off_u3egltrcwhvnt53fPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_u3egltrcwhvnt53f": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_u3egltrcwhvnt53f": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_u3egltrcwhvnt53f": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_u3egltrcwhvnt53f": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

33. centralcity.ai/api/public/x402/off_urjl37p3x52ro5zrPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_urjl37p3x52ro5zr": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_urjl37p3x52ro5zr": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_urjl37p3x52ro5zr": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_urjl37p3x52ro5zr": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

34. centralcity.ai/api/public/x402/off_w6o6q4wfk6us2nh7POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_w6o6q4wfk6us2nh7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_w6o6q4wfk6us2nh7": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_w6o6q4wfk6us2nh7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_w6o6q4wfk6us2nh7": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

35. centralcity.ai/api/public/x402/off_x2jkqqwlaxndsttuPOST

    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-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 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(
        {
          "POST /api/public/x402/off_x2jkqqwlaxndsttu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_x2jkqqwlaxndsttu": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_x2jkqqwlaxndsttu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_x2jkqqwlaxndsttu": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

36. centralcity.ai/api/public/x402/off_x6feyybqy7ptrgiyPOST

    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:31 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 00: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(
        {
          "POST /api/public/x402/off_x6feyybqy7ptrgiy": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_x6feyybqy7ptrgiy": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_x6feyybqy7ptrgiy": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_x6feyybqy7ptrgiy": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

37. centralcity.ai/api/public/x402/off_xgxklvq352jhh4k4POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_xgxklvq352jhh4k4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xgxklvq352jhh4k4": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_xgxklvq352jhh4k4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xgxklvq352jhh4k4": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

38. centralcity.ai/api/public/x402/off_xhvyzr7an6xhrmuxPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_xhvyzr7an6xhrmux": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xhvyzr7an6xhrmux": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_xhvyzr7an6xhrmux": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xhvyzr7an6xhrmux": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

39. centralcity.ai/api/public/x402/off_xluhb2bqjsh3bpi7POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_xluhb2bqjsh3bpi7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xluhb2bqjsh3bpi7": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_xluhb2bqjsh3bpi7": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_xluhb2bqjsh3bpi7": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

40. centralcity.ai/api/public/x402/off_y24pang6hjb52272POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_y24pang6hjb52272": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_y24pang6hjb52272": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_y24pang6hjb52272": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_y24pang6hjb52272": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

41. centralcity.ai/api/public/x402/off_ygyfaoxvpd24ubvnPOST

    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-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 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(
        {
          "POST /api/public/x402/off_ygyfaoxvpd24ubvn": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_ygyfaoxvpd24ubvn": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_ygyfaoxvpd24ubvn": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_ygyfaoxvpd24ubvn": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

42. centralcity.ai/api/public/x402/off_yjgooxl2eqp4adlwPOST

    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 04:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-16 04:40 UTC (within 120 hours of the last).
    No Base purchase is on this listing.

    After a fixEmail me when this result 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(
        {
          "POST /api/public/x402/off_yjgooxl2eqp4adlw": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yjgooxl2eqp4adlw": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_yjgooxl2eqp4adlw": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yjgooxl2eqp4adlw": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

43. centralcity.ai/api/public/x402/off_yn5qtdn2prjtohs3POST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_yn5qtdn2prjtohs3": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yn5qtdn2prjtohs3": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_yn5qtdn2prjtohs3": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yn5qtdn2prjtohs3": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

44. centralcity.ai/api/public/x402/off_yqoqp4ulmmkkm3sfPOST

    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-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 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(
        {
          "POST /api/public/x402/off_yqoqp4ulmmkkm3sf": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yqoqp4ulmmkkm3sf": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_yqoqp4ulmmkkm3sf": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yqoqp4ulmmkkm3sf": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

45. centralcity.ai/api/public/x402/off_ytn7laayphp3fcquPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_ytn7laayphp3fcqu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_ytn7laayphp3fcqu": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_ytn7laayphp3fcqu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_ytn7laayphp3fcqu": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

46. centralcity.ai/api/public/x402/off_yxbehemhki5y45yuPOST

    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(
        {
          "POST /api/public/x402/off_yxbehemhki5y45yu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yxbehemhki5y45yu": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_yxbehemhki5y45yu": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_yxbehemhki5y45yu": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

47. centralcity.ai/api/public/x402/off_z3evcafxmbxi55n4POST

    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-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 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(
        {
          "POST /api/public/x402/off_z3evcafxmbxi55n4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_z3evcafxmbxi55n4": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_z3evcafxmbxi55n4": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_z3evcafxmbxi55n4": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

48. centralcity.ai/api/public/x402/off_z6bpqwovccbinzhdPOST

    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-12 16:40 UTC. Probes run oldest first, so there is no booked time. The next one usually comes by 2026-11-17 16:40 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(
        {
          "POST /api/public/x402/off_z6bpqwovccbinzhd": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_z6bpqwovccbinzhd": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_z6bpqwovccbinzhd": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_z6bpqwovccbinzhd": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

49. centralcity.ai/api/public/x402/off_zbvvuoylatee56kePOST

    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-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 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(
        {
          "POST /api/public/x402/off_zbvvuoylatee56ke": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_zbvvuoylatee56ke": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_zbvvuoylatee56ke": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_zbvvuoylatee56ke": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "asset": "<...>"},
                "network": "<...>",
            },
        },
    }
    
    @app.middleware("http")
    async def x402_middleware(request, call_next):
        return await payment_middleware(routes, server)(request, call_next)

50. centralcity.ai/api/public/x402/off_zkcuqkktadrbvwupPOST

    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-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 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(
        {
          "POST /api/public/x402/off_zkcuqkktadrbvwup": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_zkcuqkktadrbvwup": {
          accepts: {
            scheme: "exact",
            payTo: "<...>",
            price: { amount: "50000", 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/public/x402/off_zkcuqkktadrbvwup": {
            accepts: {
              scheme: "exact",
              payTo: "<...>",
              price: { amount: "50000", 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/public/x402/off_zkcuqkktadrbvwup": {
            "accepts": {
                "scheme": "exact",
                "payTo": "<...>",
                "price": {"amount": "50000", "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.