Coinbase Developer Platform (CDP) SDK

The cdp Python package provides a comprehensive suite of modules for interacting with the Coinbase Developer Platform. Key functional areas include:

• Core Clients: cdp.cdp_client for general CDP operations and cdp.api_clients for specific API interactions.
• EVM Support: Extensive modules for Ethereum Virtual Machine (EVM) operations, including cdp.evm_client, cdp.evm_local_account, cdp.evm_server_account, cdp.evm_smart_account, and modules for handling evm_call_types, evm_message_types, evm_transaction_types, and evm_token_balances.
• Solana Support: Modules for Solana-specific operations via cdp.solana_account and cdp.solana_client.
• Authentication & Security: Subpackages for cdp.auth and cdp.x402 (likely related to the x402 protocol).
• Utilities & Constants: Core supporting modules like cdp.constants, cdp.utils, cdp.analytics, and cdp.export.

The cdp.openapi_client.api package provides access to various Coinbase Developer Platform (CDP) services through specialized submodules. Depending on your use case, you should import from the following modules:

• EVM Accounts: cdp.openapi_client.api.evm_accounts_api for managing Ethereum Virtual Machine accounts.
• EVM Smart Accounts: cdp.openapi_client.api.evm_smart_accounts_api for interacting with smart account abstractions on EVM chains.
• EVM Swaps: cdp.openapi_client.api.evm_swaps_api for executing token swaps on EVM chains.
• EVM Token Balances: cdp.openapi_client.api.evm_token_balances_api for querying token balances on EVM chains.
• Faucets: cdp.openapi_client.api.faucets_api for requesting testnet tokens.
• Payments (Alpha): cdp.openapi_client.api.payments_alpha_api for accessing early-access payment features.
• Policy Engine: cdp.openapi_client.api.policy_engine_api for managing security or operational policies.
• Solana Accounts: cdp.openapi_client.api.solana_accounts_api for managing Solana network accounts.

Use the x402 protocol to charge for HTTP routes and receive USDC in a CDP-managed wallet. This is suitable for monetizing APIs, putting paywalls in front of endpoints, or accepting payments from agents.

When to use this approach

• You want to monetize an API or price a route per request.
• You want to put a paywall in front of an endpoint.
• You want to accept payments from agents.
• You want to add x402 support to an existing server.

When NOT to use this approach

• Using Coinbase Business: If you want a hosted payment URL for people or a x402_url for agents without running a server, use the Business Checkouts API.
• Charging for MCP tools: If you are charging for an MCP tool rather than an HTTP route, see Charge over MCP.
• The user is the payer: If you are building the client side that makes payments, use the build-x402-client skill.
• No-code monetization: If you want a deployed service with no code, use the monetize-service skill from the agentic-wallet CLI.

The SDK supports three patterns for performing token swaps on EVM networks, working with both Regular Accounts (EOAs) and Smart Accounts.

1. All-in-one pattern (Recommended)

Use account.swap() or smartAccount.swap() for a simple, single-line execution. This handles everything automatically.

2. Get pricing information

Use cdp.evm.getSwapPrice() to get quick estimates and check liquidity without committing to a swap. This is suitable for UI displays and is less strictly rate-limited.

3. Create and execute separately

Use account.quoteSwap() or smartAccount.quoteSwap() when you need full control. This returns a quote object that you can inspect before calling .execute(). Note: quoteSwap() signals a soft commitment and may reserve funds on-chain, so it is more strictly rate-limited.

Key Differences: EOA vs Smart Account

• EOAs: Return transactionHash and execute immediately.
• Smart Accounts: Return userOpHash and execute via user operations (ERC-4337), supporting gas sponsorship via paymasters.

// Recommended: All-in-one swap for EOA
const { transactionHash } = await account.swap({
  network: "base",
  toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  fromToken: "0x4200000000000000000000000000000000000006",
  fromAmount: BigInt("1000000000000000000"),
  slippageBps: 100,
});

// Recommended: All-in-one swap for Smart Account
const { userOpHash } = await smartAccount.swap({
  network: "base",
  toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  fromToken: "0x4200000000000000000000000000000000000006",
  fromAmount: BigInt("1000000000000000000"),
  slippageBps: 100,
});

The Policy Engine allows you to manage sets of rules that govern the behavior of accounts and projects, such as enforcing allowlists or denylists. You can create policies at either the project scope (applying to all accounts) or the account scope.

Supported rule types include various signing and sending operations for both EVM and Solana, as well as User Operations for smart accounts. Rules use criteria like EthValueCriterion, EvmAddressCriterion, SolanaAddressCriterion, and SolValueCriterion to define conditions.

# Example: Create a project-level policy
policy = await cdp.policies.create_policy(
    policy=CreatePolicyOptions(
        scope="project",
        description="Project-wide Allowlist Example",
        rules=[
            SignEvmTransactionRule(
                action="accept",
                criteria=[
                    EthValueCriterion(ethValue="1000000000000000000", operator="<="),
                    EvmAddressCriterion(addresses=["0x..."], operator="in"),
                ],
            ),
        ],
    )
)