x402 API finder and Base reads

Four paid routes, each settled in USDC on Base through x402 with no account or API key. The finder returns paid x402 APIs for one task that answered a live payment challenge just now. The three Base reads return live public chain data. A call settles only when it produced a result.

How the finder works

• Candidates. Ontario keeps a copy of the Coinbase CDP Bazaar catalog with Base USDC listings that settled in the last 30 days. Each result reports candidate_source and index_as_of. When the copy is missing or older than 12 hours, the live Coinbase CDP Bazaar, Agentic Market and Ontario ready-catalog searches are used instead; when it has too few matches, those searches add their candidates after the index matches.
• Skipped before probing. Ontario's own paid routes, templated endpoints, hosts that opted out, and write or money-moving paths for every method, GET included: paths containing send-token, send-native, transfer, withdraw, swap, bridge, execute, invoice, order, mint, deposit or stake, and paths with a word such as pay, payment, payout, purchase, buy, checkout, sell, trade, send, tip, donate, charge, refund, claim, redeem, approve, burn, borrow, lend or repay. A host is compared without a trailing dot.
• Ranking. Task fit, price, and repeat buyers (Bazaar-reported calls beyond unique payers). Marketplace counters are reported by the marketplace and can be inflated or frozen.
• Probing. At most 8 probes per call and 2 per host, 3 s connect and read timeouts, at most 64 KB of a challenge body read, public HTTPS hosts only, no redirects followed. The call waits at most 6 s for all probes together; a probe still running then counts as probe_timeout. A GET candidate receives the listing's example query; a POST candidate receives the listing's example body. No payment header or signature is attached. An observation is reused for up to 10 minutes, so repeated calls in that window do not probe the same endpoint again.
• Kept. Only endpoints that answered with a valid Base USDC x402 challenge within the caller's max_usdc. A 429 answer counts as not live. Each result carries the live price, price_drift against the listing, payto_matches_listing when the listing publishes a Base payTo, and a ready-to-call request. Up to 5 results are returned.

OntarioProtocol-x402Finder/1.0 (+https://ontarioprotocol.com/docs/x402-api-finder; unpaid probe, no payment attached)

The task text and the live candidates' public names, endpoints and descriptions were sent to TypeSafe for a task-fit opinion. Jev can reorder live matches; it cannot add an endpoint or change a price, budget or network check.

Base reads

• Parameters. Only the parameters listed here are accepted. An unknown parameter (for example expectedTo or token), or a single-valued one given twice, is refused with 400 and nothing is charged.
• balances: address (required) and tokens (optional, comma-separated, up to 20 contracts). Returns ETH, plus every token on Ontario's 25-token Base list with a nonzero balance, plus every requested token, with symbol, decimals, raw and formatted amounts and the block read.
• tx-check: hash (required), expected_to and expected_amount in atomic units (optional). Returns status, block, timestamp, confirmations, ERC-20 Transfers (up to 100 listed; transfers_total gives the full count) and EIP-3009 authorizations decoded, and match flags for the expected payTo and amount, which cover every USDC transfer. If the RPC has not yet served the block of a brand-new receipt, timestamp is null with a timestamp_note. Receipts with 300 or more confirmations are cached for 10 minutes.
• gas: no input. Returns the base fee, priority-fee p25/p50/p90 over the last 20 blocks, slow/normal/fast maxFeePerGas and maxPriorityFeePerGas suggestions, L1 data-fee upper bounds and total-cost estimates for an ETH and an ERC-20 transfer.
• Source. Batched JSON-RPC with a 2 s budget per RPC, failing over across the operator's own Base RPC when one is configured and then https://mainnet.base.org, https://base-rpc.publicnode.com, https://base.drpc.org. RPC requests carry OntarioProtocol-BaseReads/1.0 (+https://ontarioprotocol.com). Only public chain data is read and nothing beyond the request is stored.

Limits

• The finder checks the HTTP 402 layer only. It never calls a provider's paid response, so a live challenge shows the endpoint is up and payable now, not that its paid answer is correct, safe or fit for the task.
• Results are recommendations, not a safety guarantee. Provider calls are paid separately, under the caller's own spend policy.
• Base reads cover Base mainnet only. Balances carry no prices or USD values, and tokens outside the list and the requested contracts are not discovered.
• Gas values are estimates, not inclusion guarantees.
• Public Base RPCs are rate-limited. When an RPC lags, tx-check can briefly report a new transaction as not found; that call returns 404 and is not charged.
• After the facilitator verified a payment, requests that end without a confirmed settlement (no match, not found, RPC unavailable, settlement refused, or a result delivered while settlement is unconfirmed) are capped at 20 per payer wallet and 3 per payment authorization per 10 minutes; above a cap the route returns 429 and nothing is charged.

curl -si "https://ontarioprotocol.com/api/x402/base/gas" \
  | awk 'tolower($1)=="payment-required:" {print $2}' | tr -d '\r' \
  | base64 --decode | jq '.accepts[0] | {amount, network, asset, payTo}'

import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
import { registerExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const USDC_BASE = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
const MAX_ATOMIC = 10_000n; // 0.01 USDC

const client = new x402Client();
registerExactEvmScheme(client, { signer: privateKeyToAccount(process.env.EVM_PRIVATE_KEY) });
client.registerPolicy((_version, requirements) =>
  requirements.filter((r) =>
    r.network === "eip155:8453" &&
    r.asset.toLowerCase() === USDC_BASE &&
    BigInt(r.amount) <= MAX_ATOMIC));

const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const response = await fetchWithPayment(
  "https://ontarioprotocol.com/api/x402/find-api?task=" + encodeURIComponent("web search for an AI agent"));
console.log(response.status, await response.json());