Agent Payments Sandbox — online

2Run a payment

Watch one of the sandbox’s own agents pay for the $0.05 report, and pick what goes wrong. Choose how it pays (the rail), what goes wrong (the scenario) and which agent pays: the careful one checks the terms and never pays twice; the naive one pays whatever it’s asked and starts over when something fails.

3Check both agents

The conformance check: every scenario the rail can play (15 on x402) against the careful and the naive agent, each on a fresh sandbox, judged the way check agent judges yours. You get a pass or fail per scenario, side by side. It takes 10 to 20 seconds.

4Test your own agent

Your agent pays your sandbox exactly as it would pay a real API: the same 402 challenge, the same headers and signatures, with fake money. Point it at your sandbox, make it pay, and watch every payment land at the bottom of this step.

1. Copy your sandbox’s settings

   Two values are enough for most agents: PAID_URL, the API to pay ($0.05 a call), and SANDBOX_PRIVATE_KEY, the wallet that pays. The rest are for agents that read the chain or pay over MPP or Lightning.

   .env: your sandbox’s settingsCopy

   SANDBOX_URL=https://sandbox.latitude10.tech/s/<your-session>
   PAID_URL=https://sandbox.latitude10.tech/s/<your-session>/m/report
   SANDBOX_PRIVATE_KEY=<your sandbox key>
   SANDBOX_RPC_URL=https://sandbox.latitude10.tech/s/<your-session>/rpc/evm

2. Connect your agent

   Pick the way that suits you. Each one ends with your agent paying your sandbox.

   Write one in a minuteUse my agentAsk my AI assistantCommand lineOver MCP

   A complete paying agent in about a dozen lines, with the official x402 client. In an empty folder:

   1 · Install the x402 clientCopy

   npm install @x402/core @x402/evm @x402/fetch viem

   2 · Save as my-agent.mjsCopy

   // my-agent.mjs: pays for PAID_URL with the official x402 client.
   import { x402Client } from '@x402/core/client';
   import { registerExactEvmScheme } from '@x402/evm/exact/client';
   import { wrapFetchWithPayment } from '@x402/fetch';
   import { privateKeyToAccount } from 'viem/accounts';
   
   const client = new x402Client();
   registerExactEvmScheme(client, { signer: privateKeyToAccount(process.env.SANDBOX_PRIVATE_KEY) });
   const payingFetch = wrapFetchWithPayment(fetch, client);
   
   const res = await payingFetch(process.env.PAID_URL);
   console.log(`HTTP ${res.status}`);
   console.log(await res.text());
   

   3 · Run it against your sandboxCopy

   SANDBOX_URL=https://sandbox.latitude10.tech/s/<your-session> PAID_URL=https://sandbox.latitude10.tech/s/<your-session>/m/report SANDBOX_PRIVATE_KEY=<your sandbox key> node my-agent.mjs

   It prints HTTP 200 and the report, and the payment appears below. Now try it with a failure (next step): this script is naive on purpose, and you’ll see what that costs.

3. Make it fail on purpose

   Add ?sandbox_scenario=<name> to the paid URL (or send the header X-Sandbox-Scenario), and that one request goes wrong the way you picked. Your agent should still pay once, or refuse.

   Failureok: the happy pathinsufficient balance: the payment fails for lack of fundsinvalid signature: verification fails: bad signatureexpired: the challenge (MPP expires, L402 invoice) or the authorization window has passedprice changed: the retry is answered with a new, higher price (2×)wrong amount: the challenge asks for 10× the route’s pricewrong recipient: the challenge pays someone other than the route’s recipientwrong network: the challenge asks for another network (Ethereum Sepolia)duplicate: serves 200, then the same resource is asked for againsettle fails: verify ok, settle fails, no contenttimeout: hangs past the client’s timeout, then settles anywayserver error after payment: settles, then answers 500 with no receiptno receipt: settles and serves, but omits the receipt headerslow: adds latency to every response

   Point your agent at this URLCopy

   https://sandbox.latitude10.tech/s/<your-session>/m/report?sandbox_scenario=server_error_after_payment

   A careful agent pays once; resends the same signed payment, never signs a new one.

   Start with server error after payment: the sandbox takes the money, then answers 500. An agent that retries from scratch pays again, and again.

   Or have your assistant run every failure and fix what it finds:

   Prompt: Test my agent against every failureCopy

   My agent pays for https://sandbox.latitude10.tech/s/<your-session>/m/report over x402. The sandbox can make one payment fail on purpose: add ?sandbox_scenario=<name> to that URL, or send the header X-Sandbox-Scenario: <name>.
   
   Run my agent once per scenario below. After each run, read the sandbox's record at https://sandbox.latitude10.tech/s/<your-session>/_sandbox/flows and tell me how many times it paid (settlements) and whether that matches what a careful agent does:
   - ok: the happy path. A careful agent pays once and gets the report.
   - insufficient_balance: the payment fails for lack of funds. A careful agent stops and reports it, without retrying forever.
   - invalid_signature: verification fails: bad signature. A careful agent stops and reports the error.
   - expired: the challenge (MPP expires, L402 invoice) or the authorization window has passed. A careful agent doesn’t pay a stale challenge; asks for a new one.
   - price_changed: the retry is answered with a new, higher price (2×). A careful agent refuses the new, higher price, or asks first.
   - wrong_amount: the challenge asks for 10× the route’s price. A careful agent refuses: the amount isn’t the price it expected.
   - wrong_recipient: the challenge pays someone other than the route’s recipient. A careful agent refuses: the payee isn’t the one it expected.
   - wrong_network: the challenge asks for another network (Ethereum Sepolia). A careful agent refuses: the network isn’t the one it expected.
   - duplicate: serves 200, then the same resource is asked for again. A careful agent pays once for the same resource in the same task.
   - settle_fails: verify ok, settle fails, no content. A careful agent doesn’t count it as paid; no content was served.
   - timeout: hangs past the client’s timeout, then settles anyway. A careful agent pays once; after no answer, resends the same payment or checks the chain before paying again.
   - server_error_after_payment: settles, then answers 500 with no receipt. A careful agent pays once; resends the same signed payment, never signs a new one.
   - no_receipt: settles and serves, but omits the receipt header. A careful agent pays once; treats a 200 without a receipt as paid.
   - slow: adds latency to every response. A careful agent waits long enough, and pays once.
   
   Then fix my agent wherever it paid more than once, or paid a price, payee or network it shouldn't have.

4. Watch it here

   Each payment your agent makes shows up below within two seconds, drawn as the same ladder as the built-in agents.

   Payments appear here once your sandbox is open.

   Want the full verdict? The free kit runs your agent, in any language, against all 14 failures and prints a table: npx pay-sandbox check agent -- node my-agent.mjs. It can also check your own paid API, which the online sandbox can’t reach.