> ## 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.

# 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](/gateway/nanopayments/concepts/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:
[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?](/gateway/nanopayments/concepts/x402): the payment handshake
  behind these steps.