TypeScript Examples

The TypeScript SDK includes over 100 working examples demonstrating every feature of the CDP SDK. All examples use modern async/await patterns and full TypeScript support.

Setup

Get CDP Credentials

Get your CDP API key and wallet secret from the CDP Portal

Configure Environment

Copy .env.example to .env and add your credentials:

cd examples/typescript
cp .env.example .env

Edit .env:

.env

CDP_API_KEY_ID=your_api_key_id
CDP_API_KEY_SECRET=your_api_key_secret
CDP_WALLET_SECRET=your_wallet_secret

Install Dependencies

# In root typescript/ folder
pnpm install && pnpm build

# In examples/typescript folder
pnpm install

Running Examples

Run any example using pnpm tsx:

pnpm tsx path/to/example.ts

For example:

pnpm tsx evm/accounts/createAccount.ts
pnpm tsx solana/transactions/signMessage.ts
pnpm tsx evm/swaps/account.swap.ts

Quickstart Example

The quickstart example demonstrates the complete flow: create an account, fund it, and send a transaction.

quickstart/index.ts - Complete Getting Started Example

quickstart/index.ts

#!/usr/bin/env node
import { parseEther } from "viem";
import { CdpClient } from "@coinbase/cdp-sdk";
import readline from "readline/promises";
import { stdin as input, stdout as output } from "process";
import { homedir } from "os";
import { join } from "path";
import { readdir, readFile, stat } from "fs/promises";

// Auto-load credentials from Downloads folder or prompt
const rl = readline.createInterface({ input, output });

if (!CDP_API_KEY_ID) CDP_API_KEY_ID = await rl.question("Enter CDP_API_KEY_ID: ");
if (!CDP_API_KEY_SECRET) CDP_API_KEY_SECRET = await rl.question("Enter CDP_API_KEY_SECRET: ");
if (!CDP_WALLET_SECRET) CDP_WALLET_SECRET = await rl.question("Enter CDP_WALLET_SECRET: ");
rl.close();

// Initialize CDP client
const cdp = new CdpClient({
  apiKeyId: CDP_API_KEY_ID,
  apiKeySecret: CDP_API_KEY_SECRET,
  walletSecret: CDP_WALLET_SECRET,
});

// Create account
const account = await cdp.evm.createAccount();
console.log("✅ Created EVM account:", account.address);

const baseSepoliaAccount = await account.useNetwork("base-sepolia");

// Request testnet funds
const { transactionHash: faucetTx } = await baseSepoliaAccount.requestFaucet({
  token: "eth",
});
await baseSepoliaAccount.waitForTransactionReceipt({ hash: faucetTx });
console.log("🚰 Received testnet ETH:", faucetTx);

// Send transaction
const { transactionHash } = await baseSepoliaAccount.sendTransaction({
  transaction: {
    to: "0x0000000000000000000000000000000000000000",
    value: parseEther("0.000001"),
  },
});
await baseSepoliaAccount.waitForTransactionReceipt({ hash: transactionHash });
console.log(`📦 TX confirmed: https://sepolia.basescan.org/tx/${transactionHash}`);

What it does:

Creates a new EVM account
Requests testnet ETH from Base Sepolia faucet
Sends a test transaction
Waits for confirmation

Run it:

pnpm tsx quickstart/index.ts

EVM Examples

Account Management

Create Account - Basic account creation

evm/accounts/createAccount.ts

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

const cdp = new CdpClient();
const account = await cdp.evm.createAccount();
console.log("Created account:", account.address);

Run: pnpm tsx evm/accounts/createAccount.ts

Get or Create Account - Idempotent account creation

evm/accounts/getOrCreateAccount.ts

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

const cdp = new CdpClient();

// Will create account if it doesn't exist, or return existing
const account = await cdp.evm.getOrCreateAccount({ 
  name: "my-app-account" 
});

console.log("Account address:", account.address);
console.log("Account name:", account.name);

Run: pnpm tsx evm/accounts/getOrCreateAccount.ts

Export & Import Account - Backup and restore accounts

evm/accounts/exportAccount.ts

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

const cdp = new CdpClient();
const account = await cdp.evm.createAccount();

// Export account data (private key encrypted with wallet secret)
const exportedData = await account.export();
console.log("Exported account:", exportedData);

// Save exportedData securely (e.g., encrypted storage)

evm/accounts/importAccount.ts

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

const cdp = new CdpClient();

// Import previously exported account
const account = await cdp.evm.importAccount({
  address: "0x...",
  encryptedPrivateKey: "...",
});

console.log("Imported account:", account.address);

Run:

pnpm tsx evm/accounts/exportAccount.ts
pnpm tsx evm/accounts/importAccount.ts

List Accounts - Get all accounts in project

evm/accounts/listAccounts.ts

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

const cdp = new CdpClient();

const accounts = await cdp.evm.listAccounts();
console.log(`Found ${accounts.length} accounts:`);

for (const account of accounts) {
  console.log(`- ${account.address} (${account.name || "unnamed"})`);
}

Run: pnpm tsx evm/accounts/listAccounts.ts

Transactions

Transfer Tokens - Send ETH and ERC20 tokens

evm/transactions/account.transfer.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { createPublicClient, http } from "viem";
import { baseSepolia } from "viem/chains";
import "dotenv/config";

const cdp = new CdpClient();

const sender = await cdp.evm.getOrCreateAccount({ name: "Sender" });
const receiver = await cdp.evm.getOrCreateAccount({ name: "Receiver" });

console.log("Requesting USDC and ETH from faucet...");

const [usdcFaucetResult, ethFaucetResult] = await Promise.all([
  cdp.evm.requestFaucet({
    address: sender.address,
    network: "base-sepolia",
    token: "usdc",
  }),
  cdp.evm.requestFaucet({
    address: sender.address,
    network: "base-sepolia",
    token: "eth",
  }),
]);

const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

await publicClient.waitForTransactionReceipt({
  hash: usdcFaucetResult.transactionHash,
});

console.log(`Sending 0.01 USDC from ${sender.address} to ${receiver.address}...`);

const { transactionHash } = await sender.transfer({
  to: receiver,
  amount: 10000n, // 0.01 USDC (6 decimals)
  token: "usdc",
  network: "base-sepolia",
});

const receipt = await publicClient.waitForTransactionReceipt({ hash: transactionHash });
console.log(`Transfer status: ${receipt.status}`);
console.log(`Explorer: https://sepolia.basescan.org/tx/${receipt.transactionHash}`);

Run: pnpm tsx evm/transactions/account.transfer.ts

Sign Transaction - Sign without sending

evm/transactions/signTransaction.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { parseEther, parseTransaction } from "viem";
import "dotenv/config";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ name: "Signer" });

const transaction = {
  to: "0x0000000000000000000000000000000000000000",
  value: parseEther("0.001"),
  chainId: 84532, // Base Sepolia
  nonce: 0,
  maxFeePerGas: 1000000000n,
  maxPriorityFeePerGas: 100000000n,
  gas: 21000n,
};

const { signedTransaction } = await cdp.evm.signTransaction({
  address: account.address,
  transaction,
});

console.log("Signed transaction:", signedTransaction);

// Can now broadcast this signed transaction to the network

Run: pnpm tsx evm/transactions/signTransaction.ts

Sign Message - Sign arbitrary messages

evm/transactions/signMessage.ts

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

const cdp = new CdpClient();
const account = await cdp.evm.createAccount();

const message = "Hello from CDP SDK!";

const { signature } = await cdp.evm.signMessage({
  address: account.address,
  message,
});

console.log(`Message: ${message}`);
console.log(`Signature: ${signature}`);

Run: pnpm tsx evm/transactions/signMessage.ts

Sign Typed Data - EIP-712 structured data signing

evm/transactions/signTypedData.ts

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

const cdp = new CdpClient();
const account = await cdp.evm.createAccount();

const typedData = {
  domain: {
    name: "My DApp",
    version: "1",
    chainId: 84532,
  },
  types: {
    Person: [
      { name: "name", type: "string" },
      { name: "wallet", type: "address" },
    ],
  },
  primaryType: "Person",
  message: {
    name: "Alice",
    wallet: "0x1234567890123456789012345678901234567890",
  },
};

const { signature } = await account.signTypedData(typedData);
console.log("Signature:", signature);

Run: pnpm tsx evm/transactions/signTypedData.ts

Token Swaps

Swap Tokens - Exchange tokens on DEXs

evm/swaps/account.swap.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { parseEther } from "viem";
import "dotenv/config";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ name: "Swapper" });

// Swap 0.01 ETH for USDC on Base
const result = await account.swap({
  network: "base",
  fromToken: "eth", // or token address
  toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  fromAmount: parseEther("0.01"),
  slippageBps: 100, // 1% slippage tolerance
});

console.log("Swap transaction:", result.transactionHash);
console.log(`View on BaseScan: https://basescan.org/tx/${result.transactionHash}`);

Run: pnpm tsx evm/swaps/account.swap.ts

Quote Swap - Get swap price without executing

evm/swaps/account.quoteSwap.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { parseEther, formatUnits } from "viem";
import "dotenv/config";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ name: "Quoter" });

// Get quote for swapping ETH to USDC
const quote = await account.quoteSwap({
  network: "base",
  fromToken: "eth",
  toToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  fromAmount: parseEther("0.1"),
  slippageBps: 100,
});

const expectedUsdc = formatUnits(BigInt(quote.toAmount), 6);
console.log(`0.1 ETH = ${expectedUsdc} USDC`);
console.log(`Minimum received: ${formatUnits(BigInt(quote.minToAmount), 6)} USDC`);

// Execute the swap if the price is acceptable
const result = await quote.execute();
console.log("Swap executed:", result.transactionHash);

Run: pnpm tsx evm/swaps/account.quoteSwap.ts

Smart Accounts

Send User Operation - EIP-4337 smart account transactions

evm/smart-accounts/sendUserOperation.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { parseEther } from "viem";
import "dotenv/config";

const cdp = new CdpClient();

// Create an owner account
const owner = await cdp.evm.getOrCreateAccount({ name: "Owner" });

// Create a smart account with this owner
const smartAccount = await cdp.evm.createSmartAccount({
  owners: [owner.address],
});

console.log("Smart account:", smartAccount.address);

// Fund the smart account
await cdp.evm.requestFaucet({
  address: smartAccount.address,
  network: "base-sepolia",
  token: "eth",
});

// Send a user operation (gasless transaction)
const result = await cdp.evm.prepareAndSendUserOperation({
  address: smartAccount.address,
  network: "base-sepolia",
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      value: parseEther("0.000001"),
      data: "0x",
    },
  ],
});

console.log("User operation hash:", result.userOpHash);

Run: pnpm tsx evm/smart-accounts/sendUserOperation.ts

Spend Permissions

Create Spend Permission - Allow others to spend on your behalf

evm/spend-permissions/createSpendPermission.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { parseEther } from "viem";
import "dotenv/config";

const cdp = new CdpClient();

const owner = await cdp.evm.getOrCreateAccount({ name: "Owner" });
const spender = await cdp.evm.getOrCreateAccount({ name: "Spender" });

// Create a spend permission allowing spender to use up to 0.01 ETH
const permission = await cdp.evm.createSpendPermission({
  account: owner.address,
  spender: spender.address,
  token: "eth",
  allowance: parseEther("0.01"),
  network: "base-sepolia",
  period: 86400, // 24 hours in seconds
});

console.log("Spend permission created:", permission.id);

Run: pnpm tsx evm/spend-permissions/createSpendPermission.ts

Solana Examples

Account Management

Create Solana Account

solana/accounts/createAccount.ts

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

const cdp = new CdpClient();

const account = await cdp.solana.createAccount();
console.log("Created Solana account:", account.address);

Run: pnpm tsx solana/accounts/createAccount.ts

Transfer SOL

solana/transactions/account.transfer.ts

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

const cdp = new CdpClient();

const sender = await cdp.solana.getOrCreateAccount({ name: "Sender" });
const receiver = await cdp.solana.getOrCreateAccount({ name: "Receiver" });

// Request SOL from faucet
await sender.requestFaucet();

// Transfer 0.01 SOL
const result = await sender.transfer({
  to: receiver.address,
  amount: 10000000n, // 0.01 SOL (9 decimals)
});

console.log("Transfer signature:", result.signature);

Run: pnpm tsx solana/transactions/account.transfer.ts

Viem Integration

The CDP SDK integrates seamlessly with Viem for advanced Ethereum development:

Use CDP Account with Viem

evm/ecosystem/viem/sendTransactionWithViem.ts

import { CdpClient } from "@coinbase/cdp-sdk";
import { createWalletClient, http } from "viem";
import { baseSepolia } from "viem/chains";
import "dotenv/config";

const cdp = new CdpClient();
const account = await cdp.evm.createAccount();

// Create Viem wallet client using CDP account
const walletClient = createWalletClient({
  account: account.toViemAccount(),
  chain: baseSepolia,
  transport: http(),
});

// Use standard Viem methods
const hash = await walletClient.sendTransaction({
  to: "0x0000000000000000000000000000000000000000",
  value: 1000000000000000n,
});

console.log("Transaction hash:", hash);

Run: pnpm tsx evm/ecosystem/viem/sendTransactionWithViem.ts

Full Example List

View all examples in the repository:

Browse TypeScript Examples

View all 100+ TypeScript examples on GitHub

Next Steps

TypeScript SDK Reference

Explore the full TypeScript SDK API

Python Examples

See Python examples

Rust Examples

View Rust examples

Go Examples

Check Go examples

Get Started

Core Concepts

Guides

Examples

TypeScript Examples

Setup

Running Examples

Quickstart Example

EVM Examples

Account Management

Transactions

Token Swaps

Smart Accounts

Spend Permissions

Solana Examples

Account Management

Viem Integration

Full Example List

Browse TypeScript Examples

Next Steps

TypeScript SDK Reference

Python Examples

Rust Examples

Go Examples

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Examples

​Setup

​Running Examples

​Quickstart Example

​EVM Examples

​Account Management

​Transactions

​Token Swaps

​Smart Accounts

​Spend Permissions

​Solana Examples

​Account Management

​Viem Integration

​Full Example List

Browse TypeScript Examples

​Next Steps

TypeScript SDK Reference

Python Examples

Rust Examples

Go Examples

Build docs developers (and LLMs) love

Setup

Running Examples

Quickstart Example

EVM Examples

Account Management

Transactions

Token Swaps

Smart Accounts

Spend Permissions

Solana Examples

Account Management

Viem Integration

Full Example List

Next Steps