deposit.now documentation

Open x402 funding rail

Agents fund any wallet — or provision a managed child — via one HTTP call

Introduction

deposit.now is an open x402 funding rail: call POST /api/deposit with either a target address or provision: true + label, pay 0.25% (min $0.001, max $0.25) via x402, and the platform forwards net USDC after settlement. Optional managed children are platform_managed in CDP (no key export in v1). Complements Coinbase CDP Fund/Send — does not replace it inside that stack.

  • Network: Base mainnet (eip155:8453) in production
  • Fee: 0.25% of net, $0.001 min, $0.25 max · status payment_received means paid, not delivered — check forwardStatus
  • Two modes: fund any EVM target, or provision a managed child + fund it
  • Machine contracts: llms.txt, openapi.json

Who needs what

deposit.now is an agent / API rail. You do not connect a browser wallet on this site to use the product. Credentials differ by role:

WhoNeedsDoes not need
Paying agentAny x402 client (e.g. @x402/fetch + viem), a wallet/signer, and USDC on Basedeposit.now API key, site account, browser "Connect wallet", or Coinbase AgentKit (optional only)
Target walletAn EVM address you already have, or provision: true + label for a managed childPrivate keys in the API response — managed children are platform-managed in CDP (no export in v1)
deposit.now platformCDP credentials + storage on the server (for receive + forward + optional receipts)Your payer private keys — never send those to deposit.now
Humans on the websiteDocs, OpenAPI, llms.txtWallet connect to call the API (agents call it in code)

Coinbase AgentKit / Agentic Wallet: not required for payers. Use them if you already run on CDP. Any x402-capable wallet works.

CDP Fund / Send:great inside Coinbase's stack. deposit.now is the open HTTP 402 deposit call when you want any target, optional managed child via provision, and optional public receipt without a deposit.now API key.

Managed children: custody is platform_managed. For a child that signs under your own key, generate an address yourself and pass target.

Auth model: payment is auth. Unpaid requests get HTTP 402; paid requests include the x402 payment proof — not Authorization: Bearer ….

Quickstart

  1. Install an x402 client (e.g. @x402/fetch + viem for JS).
  2. POST JSON — either { target, amount, memo? } or { provision: true, label, amount, memo? }
  3. Handle 402 — pay gross (amount + 0.25%, min $0.001, max $0.25) in USDC. Provision mode includes child.address.
  4. Retry with the same body + payment proof; read receiptId / receiptUrl from the 200 body.

Bare-bones flow

  1. 1. Agent calls POST /api/deposit with either { target: "0x…", amount: "50.00" } or { provision: true, label: "child-1", amount: "50.00" }
  2. 2. Server returns 402 + x402 payment request for 0.25% fee (min $0.001, max $0.25) (and child when provisioned).
  3. 3. Agent pays full gross via x402 to the platform Coinbase Agentic (CDP) wallet.
  4. 4. Backend confirms settlement → keeps fee → forwards net to target (or the managed child) via CDP.
  5. 5. Returns payment_received + receiptUrl. Check the receipt for forwardStatus and Basescan links — 200 does not mean the target already holds funds.

Endpoints

POST /api/deposit

Body: amount (required net USDC 0.01–100000) plus either target (EVM address) or provision: true with label (stable child id). Optional memo (max 256). Optional header Idempotency-Key for provision identity.

GET /api/deposit

Service metadata (also x402-protected when paid probes are used).

GET /api/discovery · GET /.well-known/x402

Machine-readable discovery manifest.

GET /receipt/:id

Public verifiable receipt page.

Code examples

JavaScript (@x402/fetch)

import { wrapFetchWithPayment } from '@x402/fetch';
import { x402Client } from '@x402/core/client';
import { ExactEvmScheme } from '@x402/evm/exact/client';
import { privateKeyToAccount } from 'viem/accounts';

const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY); // payer agent only
const client = new x402Client();
client.register('eip155:*', new ExactEvmScheme(signer));
const fetchWithPayment = wrapFetchWithPayment(fetch, client);

const res = await fetchWithPayment('https://deposit.now/api/deposit', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    provision: true,
    label: 'trading-agent-1',
    amount: '50.00',
    memo: 'Fund child trading agent',
  }),
});
console.log(await res.json());

EVM_PRIVATE_KEY is only for the paying agent client — never for the deposit.now server.

curl (probe 402)

curl -i -X POST https://deposit.now/api/deposit \
  -H 'Content-Type: application/json' \
  -d '{"provision":true,"label":"trading-agent-1","amount":"50.00","memo":"Fund child trading agent"}'
# → HTTP 402 + Payment-Required (pay 0.25%, max $0.25); includes child.address

Security

  • Platform hot wallet via Coinbase CDP / Agentic Wallet only — no raw platform private keys in app code.
  • Managed children are platform_managed in CDP — API never returns private keys.
  • Strict validation: EVM address + amount caps (0.01–100000 USDC); provision rate limits.
  • Rate limiting on /api/* (stricter on deposit and provision).
  • x402 facilitator verifies payment on-chain before success response.
  • Forward to target only after settlement; retries + settlement logs on failure.

FAQ

What is deposit.now?

deposit.now is an open x402 funding rail: agents pay 0.25% (min $0.001, max $0.25) over HTTP 402 and net USDC is forwarded to a target they specify, or to a managed child wallet created with provision:true + label. Complements Coinbase CDP Fund/Send; managed children are platform-managed in CDP with no key export in v1.

How does a deposit work?

POST /api/deposit with { target, amount } or { provision: true, label, amount }. Receive HTTP 402 for amount + 0.25% (min $0.001, max $0.25). Pay via x402. After settlement, the platform forwards net to target (or the provisioned child). Response status is payment_received; check receiptUrl for forwardStatus and Basescan links when available.

Can I fund any wallet or create a child?

Yes. Pass target for any EVM address you already have, or provision:true with a stable label to create/resolve a managed CDP child and fund it in the same call. Managed children are platform_managed (no private-key export in v1).

When should I use Coinbase Fund instead?

If your agents already use Coinbase Agentic or Server Wallets, CDP Fund/Send is usually the right tool. Use deposit.now for a protocol-shaped x402 deposit to any EVM target — or managed child provision — without a deposit.now API key.

Do I need AgentKit or a connect-wallet button?

No. Payers use any x402 client and their own wallet/signer. AgentKit is optional. This site does not require browser wallet connect — agents call the API in code. See .

Does 200 mean the target is funded?

No. payment_received means the x402 payment was accepted. Check receiptUrl for forwardStatus and tx links.

Where is the machine-readable guide?

/llms.txt and /llms-full.txt.