Quickstart for Buyers

Need help? Join the x402 Discord for the latest updates.

This guide walks you through how to use x402 to pay for services that require payment. By the end, you will be able to programmatically discover payment requirements, complete a payment, and access a paid resource.

On TypeScript, this guide uses the CDP SDK x402 primitives, which pay from a CDP-managed wallet with no private keys to store. On Go and Python, it uses the vanilla x402 packages with a wallet you manage.

The x402 helper packages for various languages greatly simplify your integration with x402. You’ll be able to automatically detect payment challenges, authorize payments onchain, and retry requests with minimal code. The packages will automatically trigger the following flow:

Makes the initial request (if using Fetch) or intercepts the initial request (if using Axios/HTTPX/Requests)
If a 402 response is received, parses the payment requirements from the PAYMENT-REQUIRED header
Creates a payment payload using the configured client and registered schemes
Retries the request with the PAYMENT-SIGNATURE header

Prerequisites

Before you begin, ensure you have:

A Coinbase Developer Platform account and API keys
Node.js and npm, Go, or Python and pip installed
A crypto wallet with USDC (on TypeScript, the CDP SDK provisions one for you; on Go/Python, use a CDP Wallet or any EVM-compatible wallet)
A service that requires payment via x402
For testnet: Base Sepolia ETH for gas and testnet USDC. Get funds from the CDP Faucet

Pre-configured examples are available in the repos: the CDP SDK x402 examples (TypeScript) and the x402 examples (Go, Python, and more).

1. Install dependencies

Node.js
Go
Python

Install the CDP SDK together with the x402 peer packages, plus one HTTP wrapper (@x402/fetch or @x402/axios):

npm install @coinbase/cdp-sdk @x402/core @x402/evm @x402/svm @x402/extensions dotenv
# then one of:
npm install @x402/fetch
# or
npm install @x402/axios axios

The @x402/* packages are optional peer dependencies of @coinbase/cdp-sdk, so you install them explicitly. See x402 in the CDP SDK for details.

Add the x402 Go module to your project:

go get github.com/x402-foundation/x402/go

Install the x402 package with your preferred HTTP client:

# For httpx (async) - recommended
pip install "x402[httpx]"

# For requests (sync)
pip install "x402[requests]"

# For Solana support, also add:
pip install "x402[svm]"

# To pay from a CDP-managed wallet, also add:
pip install cdp

2. Set up your wallet

Node.js
Go
Python

On TypeScript, the CDP SDK manages the paying wallet for you. Create an account at cdp.coinbase.com and store your API keys and wallet secret as environment variables:

# store in .env or using the command `export <name>="secret-info"`
CDP_API_KEY_ID=your-api-key-id
CDP_API_KEY_SECRET=your-api-key-secret
CDP_WALLET_SECRET=your-wallet-secret

CdpX402Client provisions and signs with a CDP-managed wallet automatically, so you never handle a private key.

Building with CDP Wallets in a user-facing app? Check out the X402 with CDP Wallets guide, which shows how to use the useX402 hook.

Use a standalone key loaded from your environment:

import (
    "crypto/ecdsa"
    "github.com/ethereum/go-ethereum/crypto"
)

// Load private key from environment
privateKey, _ := crypto.HexToECDSA(os.Getenv("EVM_PRIVATE_KEY"))

Create a wallet client using CDP’s Server Wallet (recommended) or a standalone library (eth-account for EVM).CDP Server Wallet (recommended). Store your API keys and wallet secret as environment variables, then instantiate the CDP client and create an account:

import asyncio
from cdp import CdpClient
from dotenv import load_dotenv

load_dotenv()

cdp = CdpClient()
account = await cdp.evm.create_account()

Standalone wallet. If you prefer to manage your own key:

import os
from eth_account import Account
from x402.mechanisms.evm import EthAccountSigner

account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
signer = EthAccountSigner(account)

For Solana, the CDP SDK (TypeScript) provisions a Solana wallet alongside the EVM wallet automatically. To sign Solana payments with your own key instead, use the language’s SVM signer (@solana/kit in TypeScript, or the x402[svm] extra in Python).

3. Make paid requests automatically

You can automatically handle 402 Payment Required responses and complete payment flows using the x402 helper packages.

Node.js
Go
Python (httpx)
Python (requests)

Create a CdpX402Client and pass it to either @x402/fetch, @x402/axios, or any other x402 wrapper.

CdpX402Client defaults to Base mainnet. To pay on Base Sepolia (testnet), either construct it with new CdpX402Client({ environment: "development" }) or set CDP_X402_CLIENT_ENVIRONMENT=development in your environment. The explicit config option takes precedence over the env var.

@x402/fetch
@x402/axios

wrapFetchWithPayment extends the native fetch API to handle 402 responses and payment headers for you. Full example here.

import "dotenv/config";
import { CdpX402Client } from "@coinbase/cdp-sdk/x402";
import { wrapFetchWithPayment, decodePaymentResponseHeader } from "@x402/fetch";

// Reads CDP_API_KEY_ID, CDP_API_KEY_SECRET, CDP_WALLET_SECRET from env.
const client = new CdpX402Client();

// Print the wallet address so you can fund it before paying.
const { evmAddress, svmAddress } = await client.getAddresses();
console.log("Fund this EVM address with USDC:", evmAddress);

const fetchWithPayment = wrapFetchWithPayment(globalThis.fetch, client);

const response = await fetchWithPayment("https://api.example.com/paid-endpoint");
const body = await response.json();
console.log(body);

const paymentResponse = decodePaymentResponseHeader(
  response.headers.get("payment-response") ?? "",
);
console.log(paymentResponse);

Features:

Provisions and signs with a CDP-managed wallet, so no private keys are needed
Automatically handles 402 Payment Required responses
Retries the request with proof of payment
Supports all standard fetch options

wrapAxiosWithPayment adds a payment interceptor to Axios, so your requests are retried with payment headers automatically. Full example here.

import "dotenv/config";
import axios from "axios";
import { CdpX402Client } from "@coinbase/cdp-sdk/x402";
import { wrapAxiosWithPayment, decodePaymentResponseHeader } from "@x402/axios";

const client = new CdpX402Client();

// Create an Axios instance with payment handling
const api = wrapAxiosWithPayment(
  axios.create({ baseURL: "https://api.example.com" }),
  client,
);

const response = await api.get("/paid-endpoint");
console.log(response.data);

const paymentResponse = decodePaymentResponseHeader(
  response.headers["payment-response"] ?? "",
);
console.log(paymentResponse);

Features:

Provisions and signs with a CDP-managed wallet, so no private keys are needed
Automatically handles 402 Payment Required responses
Retries requests with payment headers

Full example here

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "time"

    x402 "github.com/x402-foundation/x402/go"
    evm "github.com/x402-foundation/x402/go/mechanisms/evm/exact/client"
)

func main() {
    privateKey := os.Getenv("EVM_PRIVATE_KEY")
    url := "http://localhost:4021/weather"

    // Create x402 client and register EVM scheme
    client := x402.NewX402Client()
    evm.RegisterExactEvmScheme(client, &evm.Config{
        PrivateKey: privateKey,
    })

    // Wrap HTTP client with payment handling
    httpClient := x402.WrapHTTPClient(client)

    // Make request - payment is handled automatically
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := httpClient.Do(req)
    if err != nil {
        fmt.Printf("Request failed: %v\n", err)
        return
    }
    defer resp.Body.Close()

    // Read response
    var data map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&data)
    fmt.Printf("Response: %+v\n", data)

    // Check payment response header
    paymentHeader := resp.Header.Get("PAYMENT-RESPONSE")
    if paymentHeader != "" {
        fmt.Println("Payment settled successfully!")
    }
}

httpx provides async HTTP client support with automatic 402 payment handling.Full HTTPX example | Full Requests example

import asyncio
import os
from eth_account import Account

from x402 import x402Client
from x402.http import x402HTTPClient
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client


async def main() -> None:
    client = x402Client()
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    http_client = x402HTTPClient(client)

    async with x402HttpxClient(client) as http:
        response = await http.get("https://api.example.com/paid-endpoint")
        await response.aread()

        print(f"Response: {response.text}")

        if response.is_success:
            settle_response = http_client.get_payment_settle_response(
                lambda name: response.headers.get(name)
            )
            print(f"Payment settled: {settle_response}")


asyncio.run(main())

requests provides sync HTTP client support with automatic 402 payment handling.Full Requests example

import os
from eth_account import Account

from x402 import x402ClientSync
from x402.http import x402HTTPClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client


def main() -> None:
    client = x402ClientSync()
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    http_client = x402HTTPClientSync(client)

    with x402_requests(client) as session:
        response = session.get("https://api.example.com/paid-endpoint")

        print(f"Response: {response.text}")

        if response.ok:
            settle_response = http_client.get_payment_settle_response(
                lambda name: response.headers.get(name)
            )
            print(f"Payment settled: {settle_response}")


main()

Multi-Network Client Setup

Handle different networks from a single client.

TypeScript
Go
Python

CdpX402Client prescribes the Base network for its environment (Base mainnet by default, Base Sepolia with environment: "development"), registering exact + upto there. To pay on Solana or other EVM networks from the same client, add them via networkSchemes — one signer, no per-network setup. See Networks and RPC for details.

import { CdpX402Client } from "@coinbase/cdp-sdk/x402";
import { wrapFetchWithPayment } from "@x402/fetch";

const client = new CdpX402Client({
  environment: "production", // Base mainnet
  networkSchemes: [
    { network: "solana", scheme: { exact: true } },
    { network: "polygon", rpcUrl: "https://your-rpc-provider.example.com/polygon", scheme: { exact: true } },
  ],
});
const fetchWithPayment = wrapFetchWithPayment(fetch, client);

import (
    x402 "github.com/x402-foundation/x402/go"
    x402http "github.com/x402-foundation/x402/go/http"
    evm "github.com/x402-foundation/x402/go/mechanisms/evm/exact/client"
    svm "github.com/x402-foundation/x402/go/mechanisms/svm/exact/client"
    evmsigners "github.com/x402-foundation/x402/go/signers/evm"
    svmsigners "github.com/x402-foundation/x402/go/signers/svm"
)

// Create signers
evmSigner, _ := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))
svmSigner, _ := svmsigners.NewClientSignerFromPrivateKey(os.Getenv("SVM_PRIVATE_KEY"))

// Create client with multiple schemes
x402Client := x402.Newx402Client().
    Register("eip155:*", evm.NewExactEvmScheme(evmSigner)).
    Register("solana:*", svm.NewExactSvmScheme(svmSigner))

// Wrap HTTP client with payment handling
httpClient := x402http.WrapHTTPClientWithPayment(
    http.DefaultClient,
    x402http.Newx402HTTPClient(x402Client),
)

// Now handles both EVM and Solana networks automatically!

import asyncio
import os

from eth_account import Account

from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client
from x402.mechanisms.svm import KeypairSigner
from x402.mechanisms.svm.exact.register import register_exact_svm_client


async def main() -> None:
    client = x402Client()

    # Register EVM scheme
    account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
    register_exact_evm_client(client, EthAccountSigner(account))

    # Register SVM scheme
    svm_signer = KeypairSigner.from_base58(os.getenv("SVM_PRIVATE_KEY"))
    register_exact_svm_client(client, svm_signer)

    async with x402HttpxClient(client) as http:
        response = await http.get("https://api.example.com/paid-endpoint")
        print(f"Response: {response.text}")


asyncio.run(main())

Supporting the Upto Scheme

The upto scheme (usage-based billing) lets a service charge only for actual usage up to an authorized maximum. It is transparent to the buyer: the SDK handles the max-authorization signing automatically, and you are only charged the actual settled amount.

TypeScript
Go
Python

CdpX402Client with the default EOA wallet registers upto alongside exact on its prescribed Base network, with no extra setup. It selects the right scheme based on what the server advertises in its 402 response. Same client as payForApi.ts:

import { CdpX402Client } from "@coinbase/cdp-sdk/x402";

// EOA wallets register exact + upto on the environment's Base network.
const client = new CdpX402Client();

import (
    x402 "github.com/x402-foundation/x402/go"
    exactevm "github.com/x402-foundation/x402/go/mechanisms/evm/exact/client"
    uptoevm "github.com/x402-foundation/x402/go/mechanisms/evm/upto/client"
    evmsigners "github.com/x402-foundation/x402/go/signers/evm"
)

evmSigner, _ := evmsigners.NewClientSignerFromPrivateKey(os.Getenv("EVM_PRIVATE_KEY"))

x402Client := x402.Newx402Client().
    Register("eip155:*", exactevm.NewExactEvmScheme(evmSigner)).
    Register("eip155:*", uptoevm.NewUptoEvmScheme(evmSigner))

import os
from eth_account import Account

from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client
from x402.mechanisms.evm.upto import UptoEvmClientScheme

client = x402Client()
account = Account.from_key(os.getenv("EVM_PRIVATE_KEY"))
signer = EthAccountSigner(account)

register_exact_evm_client(client, signer)
client.register("eip155:*", UptoEvmClientScheme(signer))

The upto scheme is currently available on EVM networks only, in the TypeScript, Go, and Python SDKs. When registered, the SDK automatically selects the correct scheme based on what the server advertises in its 402 response.

Additional Client Configuration (TypeScript)

Optional configuration for CdpX402Client beyond the default setup in step 3.

Migrating from a self-managed key

If you already use @x402/core with your own private key, there are two ways to bring CDP into the mix. Keep managing your own key, but drop in CDP’s signer adapter instead of a CDP-managed wallet:

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

const client = new x402Client();
registerExactEvmScheme(client, { signer: privateKeyToAccount("0xYourPrivateKey") });

Or, keep your existing x402Client setup and slot a CDP-managed signer into it with fromCdpEvmAccount(), removing the private key without switching to CdpX402Client. Full example here:

import { CdpClient } from "@coinbase/cdp-sdk";
import { fromCdpEvmAccount } from "@coinbase/cdp-sdk/x402";
import { x402Client } from "@x402/core/client";
import { registerExactEvmScheme } from "@x402/evm/exact/client";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ name: "my-x402-signer" });

const client = new x402Client();
registerExactEvmScheme(client, { signer: fromCdpEvmAccount(account) });

Limiting spend for autonomous agents

Attach spend controls to CdpX402Client for per-payment and rolling caps, network/asset allowlists, and an approaching-limit callback that keeps an agent’s spending within a budget. Full example here:

const client = new CdpX402Client({
  spendControls: { maxAmountPerPayment: { atomic: 10_000n }, allowedNetworks: ["eip155:84532"] },
});

See Spend controls for the full option list and error handling.

4. Fund your wallet

Your wallet needs USDC before it can pay.

Node.js
Python

Print the CDP-managed wallet address with client.getAddresses() (shown in step 3), then fund it. On Base Sepolia (testnet):

CDP Faucet (portal): portal.cdp.coinbase.com → “Onchain Tools” → “Faucet”

Programmatically:

import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();
await cdp.evm.requestFaucet({ address: evmAddress, network: "base-sepolia", token: "usdc" });

The CDP faucet funds the same wallets the CDP x402 facilitator settles against, so no separate faucet is needed.

Fund your account’s address with USDC. On Base Sepolia (testnet), use the CDP Faucet or, for a CDP account, request it programmatically:

await cdp.evm.request_faucet(address=account.address, network="base-sepolia", token="usdc")

5. Discover Available Services (Optional)

Instead of hardcoding endpoints, you can use the x402 Bazaar to dynamically discover available services. This is especially powerful for building autonomous agents that can find and use new capabilities.

Node.js
Go
Python

Extend the CDP facilitator client with the Bazaar discovery extension using the CDP SDK:

import { createCdpFacilitatorClient } from "@coinbase/cdp-sdk/x402";
import { withBazaar } from "@x402/extensions/bazaar";

// Reads CDP_API_KEY_ID and CDP_API_KEY_SECRET from env.
const facilitator = withBazaar(createCdpFacilitatorClient());

// Discover all available x402 services
const { items } = await facilitator.extensions.bazaar.listResources({ type: "http" });

// Or search by natural language:
// const { resources } = await facilitator.extensions.bazaar.search({ query: "weather APIs" });

// Find services under $0.10 (USDC has 6 decimals)
const usdc = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
const affordable = items.filter(item =>
  item.accepts.some(r => r.asset === usdc && Number(r.maxAmountRequired) < 100_000),
);

import (
    "encoding/json"
    "net/http"
)

// Fetch available services
resp, _ := http.Get("https://api.cdp.coinbase.com/platform/v2/x402/discovery/resources")
defer resp.Body.Close()

var services struct {
    Items []map[string]interface{} `json:"items"`
}
json.NewDecoder(resp.Body).Decode(&services)

fmt.Printf("Found %d services\n", len(services.Items))

import asyncio
import httpx


async def main() -> None:
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.cdp.coinbase.com/platform/v2/x402/discovery/resources",
            params={"type": "http", "limit": 20},
        )
        services = response.json()

        # Filter services by criteria
        affordable_services = [
            item for item in services.get("items", [])
            if any(int(req.get("amount", 0)) < 100000 for req in item.get("accepts", []))
        ]

        print(f"Available services: {affordable_services}")


asyncio.run(main())

Learn more about service discovery in the x402 Bazaar documentation, including how to filter services, understand their schemas, and build agents that can autonomously discover new capabilities.

CDP facilitator: For semantic search, quality-ranked results, and rich filters (network, asset, scheme, price, extensions, and more) without an API key, use GET https://api.cdp.coinbase.com/platform/v2/x402/discovery/search as documented in CDP Bazaar: semantic search. The examples above use the paginated /discovery/resources list, which is still appropriate when you want to page through the raw catalog.

6. Integrate Base Builder Codes (Optional)

If you’re building on Base, integrate a Base Builder Code to get attributed for x402 transactions you drive. Paste this into Claude Code, Cursor, Codex, or any coding agent:

Follow https://docs.cdp.coinbase.com/x402/builder-code.skill.md to integrate Base Builder Codes into my x402 app.

For full setup details — getting your Builder Code, manual integration steps, and verifying attribution onchain — see the Builder Codes page.

7. Paying with Any ERC-20 Token via Permit2 (EVM)

Some endpoints accept payment in non-USDC ERC-20 tokens via Permit2. The official TypeScript (including the CDP SDK), Go, and Python client SDKs handle Permit2 automatically — no extra client code is needed. When a server advertises Permit2 as the transfer method (extra.assetTransferMethod: "permit2"), the client SDK creates the correct PermitWitnessTransferFrom payload instead of an EIP-3009 authorization.

Gas Sponsorship (Automatic)

If the server declares a gas sponsorship extension (EIP-2612 or ERC-20), the TypeScript, Go, and Python client SDKs handle the Permit2 approval automatically:

EIP-2612 gas sponsoring: The client signs an off-chain permit() message. The facilitator submits the approval on-chain — no gas cost to you.
ERC-20 gas sponsoring: The client signs an approve() transaction. The facilitator broadcasts it on-chain before settling — no gas cost to you.

No additional client setup is needed for either case. The SDK detects the server’s advertised extension and responds accordingly. With the CDP SDK, CdpX402Client activates these paths automatically when the CDP facilitator advertises them.

One-Time Manual Approval (Fallback)

If the server uses Permit2 without gas sponsorship extensions, you must perform a one-time approval of the payment token to the Permit2 contract (0x000000000022D473030F116dDEE9F6B43aC78BA3) before your first payment. This only needs to be done once per token.

Node.js
Python

import { erc20Abi } from "viem";
import { walletClient } from "./your-wallet-setup";

await walletClient.writeContract({
  address: "0xYourTokenAddress",
  abi: erc20Abi,
  functionName: "approve",
  args: [
    "0x000000000022D473030F116dDEE9F6B43aC78BA3", // Permit2 contract
    BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), // max approval
  ],
});

from web3 import Web3
from eth_account import Account

w3 = Web3(Web3.HTTPProvider("https://sepolia.base.org"))
account = Account.from_key("0xYourPrivateKey")

PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3"
MAX_UINT256 = 2**256 - 1

token = w3.eth.contract(
    address=Web3.to_checksum_address("0xYourTokenAddress"),
    abi=[{
        "type": "function",
        "name": "approve",
        "inputs": [
            {"name": "spender", "type": "address"},
            {"name": "amount", "type": "uint256"},
        ],
        "outputs": [{"type": "bool"}],
        "stateMutability": "nonpayable",
    }],
)

tx = token.functions.approve(PERMIT2_ADDRESS, MAX_UINT256).build_transaction({
    "from": account.address,
    "nonce": w3.eth.get_transaction_count(account.address),
})

signed = account.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(f"Approved Permit2: {tx_hash.hex()} (block {receipt['blockNumber']})")

After this one-time approval, all subsequent Permit2 payments for that token work automatically.

For full details on EVM transfer methods and gas sponsorship, see Network Support.

8. Error Handling

Clients throw errors if:

No scheme is registered for the required network
The request configuration is missing
A payment has already been attempted for the request
There is an error creating the payment header

On TypeScript, if you configured spend controls, a blocked payment throws a SpendControlError with a machine-readable code (for example per_payment_cap, cumulative_cap, or network_not_allowed). Switch on err.code rather than matching message text.

Summary

Install an x402 client package (CDP SDK on TypeScript; vanilla x402 on Go/Python)
Set up your wallet (CDP-managed on TypeScript; CDP or standalone on Go/Python)
Use the provided wrapper/interceptor to make paid API requests (exact for fixed-price, upto for usage-based billing)
(Optional) Use the x402 Bazaar to discover services dynamically
(Optional) Register a Base Builder Code to get attributed for transactions you drive on Base
Payment flows are handled automatically for you, including upto where you only pay the actual usage

References

x402 in the CDP SDK - TypeScript primitives reference
@x402/fetch on npm
@x402/axios on npm
@x402/evm on npm
x402 Go module
x402 Python package on PyPI
x402 Bazaar documentation - Discover available services
X402 with CDP Wallets - User-facing applications with CDP wallets

For questions or support, join our Discord.

GET STARTED

WALLETS

PAYMENTS

STABLECOINS

TRADING

ONCHAIN TOOLS

CUSTOMERS

WEBHOOKS

CONSUMER APIS

BUSINESS APIS

INSTITUTIONAL APIS

Prerequisites

1. Install dependencies

2. Set up your wallet

3. Make paid requests automatically

Multi-Network Client Setup

Supporting the Upto Scheme

Additional Client Configuration (TypeScript)

Migrating from a self-managed key

Limiting spend for autonomous agents

4. Fund your wallet

5. Discover Available Services (Optional)

6. Integrate Base Builder Codes (Optional)

7. Paying with Any ERC-20 Token via Permit2 (EVM)

Gas Sponsorship (Automatic)

One-Time Manual Approval (Fallback)

8. Error Handling

Summary

References

​Prerequisites

​1. Install dependencies

​2. Set up your wallet

​3. Make paid requests automatically

​Multi-Network Client Setup

​Supporting the Upto Scheme

​Additional Client Configuration (TypeScript)

​Migrating from a self-managed key

​Limiting spend for autonomous agents

​4. Fund your wallet

​5. Discover Available Services (Optional)

​6. Integrate Base Builder Codes (Optional)

​7. Paying with Any ERC-20 Token via Permit2 (EVM)

​Gas Sponsorship (Automatic)

​One-Time Manual Approval (Fallback)

​8. Error Handling

​Summary

​References

Prerequisites

1. Install dependencies

2. Set up your wallet

3. Make paid requests automatically

Multi-Network Client Setup

Supporting the Upto Scheme

Additional Client Configuration (TypeScript)

Migrating from a self-managed key

Limiting spend for autonomous agents

4. Fund your wallet

5. Discover Available Services (Optional)

6. Integrate Base Builder Codes (Optional)

7. Paying with Any ERC-20 Token via Permit2 (EVM)

Gas Sponsorship (Automatic)

One-Time Manual Approval (Fallback)

8. Error Handling

Summary

References