> ## Documentation Index
> Fetch the complete documentation index at: https://developers.circle.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Before reading these docs, install the relevant Circle Skill to get pre-loaded context — skills are LLM-optimized and cover architecture decisions, correct flows, and common pitfalls. In Claude Code: run /plugin marketplace add circlefin/skills then /plugin install circle-skills@circle. With Vercel Skills CLI: run npx skills add circlefin/skills. Available skills: use-usdc https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-usdc/SKILL.md (balances, transfers, approvals on EVM and Solana); EURC has no skill — see https://developers.circle.com/stablecoins/what-is-eurc.md; bridge-stablecoin https://github.com/circlefin/skills/blob/master/plugins/circle/skills/bridge-stablecoin/SKILL.md (crosschain transfers via CCTP, USDC, EURC, and third-party assets); use-arc https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-arc/SKILL.md (Arc chain config, contract deployment, USDC bridging — Arc docs: https://docs.arc.io/llms.txt); use-circle-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-circle-wallets/SKILL.md (choose wallet type); use-developer-controlled-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-developer-controlled-wallets/SKILL.md (custodial wallets for payouts and treasury); use-user-controlled-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-user-controlled-wallets/SKILL.md (embedded wallets with Web2 login); use-modular-wallets https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-modular-wallets/SKILL.md (smart contract wallets with passkeys and ERC-4337); use-gateway https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-gateway/SKILL.md (unified USDC balance, nanopayments); use-smart-contract-platform https://github.com/circlefin/skills/blob/master/plugins/circle/skills/use-smart-contract-platform/SKILL.md (deploy, interact, monitor contracts). Pair any skill with the Circle MCP server for live SDK signatures, contract addresses, and chain IDs: {"mcpServers":{"circle":{"url":"https://api.circle.com/v1/codegen/mcp"}}}.
> Read the product overview first. Each product has an overview explaining when and why to use it. Read it before quickstarts.
> Pick the right wallet type. Developer-controlled (you hold keys), user-controlled (end user holds keys via PIN/social login), or modular (smart contract wallets with passkeys). See https://developers.circle.com/wallets.md.
> Use CCTP V2 for crosschain transfers. CCTP natively transfers USDC and EURC via burn-and-mint, and supports permissionless wrapping of third-party assets via lock-and-mint. V1 is legacy; always use V2 unless V1 is specified or the chain requires it (Noble, Sui, and Aptos still require V1). Migration guide: https://developers.circle.com/cctp/migration-from-v1-to-v2.md.
> Use Bridge Kit for frontend bridging. Wraps CCTP with a simpler SDK for user-facing apps. Use CCTP directly for backend transfers.
> Gas Station vs Paymaster. Gas Station sponsors gas for Circle Wallet transactions. Paymaster lets users pay gas in USDC. Different use cases — read both overviews.
> Gateway Nanopayments for sub-cent payments. Gasless USDC micropayments down to $0.000001 via x402 and batched settlement. For pay-per-request APIs, AI agent payments, streaming.
> Look up USDC addresses per chain. Never hardcode — use https://developers.circle.com/stablecoins/usdc-contract-addresses.md.
> Prefer SDKs over raw API calls. Node.js and Python SDKs handle auth, retries, and errors.
> API key required. Bearer token in Authorization header. Testnet and mainnet use separate keys and may use different base URLs depending on the product.
> Set up webhooks when available. Most operations are async. Webhooks deliver transaction confirmations and state changes.
> When calling list endpoints, paginate using pageSize and pageAfter until no nextPageAfter cursor is returned—stopping at the first page silently misses records.
> Building an AI agent? Start with the Agent Stack—Circle CLI, agent wallets, and nanopayments built for autonomous use cases: https://developers.circle.com/agent-stack.md.

# How-to: Become a seller

> Monetize your API by charging AI agents per request in USDC, with no API keys and no invoices.

Make your API charge AI agents per request in USDC over
[x402](/x402-facilitators/x402): your endpoint returns `402 Payment Required`
when a request is unpaid, and serves the resource when a valid payment is
attached. There are no API keys to issue, no invoices to send, and no accounts
to manage. Follow these steps to take an Express API from zero to paid and ready
to [list in the Agent Marketplace](/agent-stack/agent-marketplace/get-listed).

<Tip>
  The `accept-agent-payments` [Circle Skill](/ai/skills) scaffolds these steps
  directly in your codebase. Install it in your AI IDE with `circle skill
      install --tool claude-code --name accept-agent-payments` (or see the other
  install options on the [skills page](/ai/skills)), then ask your agent to add
  agent payments to your service.
</Tip>

## Prerequisites

Before you begin, ensure that you've:

* Obtained an EVM wallet address to receive USDC. Buyers pay to this address,
  and only you control it. If you don't have one, create an
  [agent wallet](/agent-stack/agent-wallets/quickstart) with Circle CLI.
* Built an HTTP API that you can add payment middleware to.
* Installed [Node.js](https://nodejs.org/) v22.6+.
* Chosen a price per request (for example, `$0.01`; sub-cent prices work too).

## Steps

### Step 1. Install the SDK

```shell theme={null}
npm install @circle-fin/x402-batching @x402/core @x402/evm viem express
```

### Step 2. Return 402 and settle payments

Add the Gateway middleware and put a price on a route. Set `sellerAddress` to
your payout wallet address; buyers see it as the `payTo` address in the price
list your endpoint returns:

```ts server.ts theme={null}
import express from "express";
import { createGatewayMiddleware } from "@circle-fin/x402-batching/server";

const app = express();

const gateway = createGatewayMiddleware({
  sellerAddress: "0xYOUR_WALLET_ADDRESS", // your payout wallet
  facilitatorUrl: "https://gateway-api-testnet.circle.com", // testnet
});

app.get("/premium-data", gateway.require("$0.01"), (req, res) => {
  res.json({ data: "Your paid content" });
});

app.listen(3000);
```

`gateway.require("$0.01")` returns `402 Payment Required` with the payment
options for unpaid requests, and settles valid payments with Gateway before your
handler runs. Full walkthrough:
[Gateway Nanopayments seller quickstart](/gateway-nanopayments/quickstarts/seller).

### Step 3. Accept vanilla x402 too

The preceding middleware accepts
[Gateway nanopayments](/agent-stack/agent-nanopayments): gasless, sub-cent
payments settled offchain in batches. To also accept onchain x402 payments and
reach buyers on non-Circle x402 stacks, run an `x402ResourceServer` with an x402
facilitator alongside the Gateway scheme:

```ts theme={null}
import { x402ResourceServer } from "@x402/express";
import { HTTPFacilitatorClient } from "@x402/core/server";
import {
  BatchFacilitatorClient,
  GatewayEvmScheme,
} from "@circle-fin/x402-batching/server";

const server = new x402ResourceServer([
  new HTTPFacilitatorClient({ url: "https://facilitator.example.com" }),
  new BatchFacilitatorClient(),
]);

server.register("eip155:*", new GatewayEvmScheme());
await server.initialize();
```

`GatewayEvmScheme` extends the standard onchain scheme, so your `402` responses
offer both rails in one `accepts` array and buyers pick whichever they have
funded. Details:
[Add nanopayments to an x402 seller](/gateway-nanopayments/howtos/x402-seller).

<Tip>
  Supporting both rails maximizes the buyers who can transact with you, the same
  way a merchant accepts more than one card network. For the same reason, accept
  payment on more than one blockchain (for example, Base and Polygon PoS): a
  buyer can only pay from a blockchain where you accept it.
</Tip>

### Step 4. Test the handshake

Send an unpaid request and confirm the `402`:

```shell theme={null}
curl -i http://localhost:3000/premium-data
```

You should see `402 Payment Required` with a `PAYMENT-REQUIRED` header that
carries the payment options. Then pay it end to end with the
[buyer quickstart](/gateway-nanopayments/quickstarts/buyer) client or the Circle
CLI
[pay for a service](/agent-stack/agent-nanopayments/operations/pay-for-service)
flow.

### Step 5. Check earnings and withdraw

Gateway payments accumulate in your Gateway balance and batch-settle onchain.
Check and withdraw with `GatewayClient`:

```ts theme={null}
import { GatewayClient } from "@circle-fin/x402-batching/client";

const client = new GatewayClient({
  chain: "arcTestnet",
  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
});

const balances = await client.getBalances();
console.log(`Available: ${balances.gateway.formattedAvailable} USDC`);

await client.withdraw("50");
```

## See also

* [How-to: Get listed](/agent-stack/agent-marketplace/get-listed): put your live
  endpoint in the marketplace catalog.
* [Seller integration tools](/agent-stack/agent-nanopayments/seller-integration-tools):
  third-party platforms that run the payment layer for you if you are not on
  Express.
* [What is x402?](/x402-facilitators/x402): the payment handshake behind these
  steps.