Coinbase API Cheat Sheet for Developers

When you’re building crypto-powered applications, one of the most practical tools in your developer toolbox is a reliable exchange API. Coinbase, one of the most established and widely used cryptocurrency platforms globally, offers such an interface. Its API provides developers with access to a wide range of features, including market data, trading, wallets, and user account information. But instead of combing through technical documentation for each task, you can bookmark this post. It compiles the most commonly used Coinbase API commands and endpoints into one easy-to-navigate guide. This way, you spend more time building and less time searching.

Coinbase’s API documentation is detailed and technically robust, but also scattered across different product endpoints. Some are REST, some are WebSocket, and others are used primarily for commerce or Coinbase Wallet SDKs. For your convenience, we’ve compiled everything in a unified Coinbase API cheat sheet that you can refer to again and again.

Before diving into the commands, let’s take a quick look at what the Coinbase API offers and its structure. You’ll then find categorized sections including authentication, user accounts, crypto wallets, trades, payments, WebSocket support, and more, all explained clearly and thoroughly.

What is the Coinbase API Cheat Sheet?

This Coinbase API cheat sheet helps you get easy access to most of the most commonly used commands for the Coinbase API.

The Coinbase API is a RESTful service that allows developers to interact with Coinbase’s platform programmatically. You can access account balances, retrieve deposit and withdrawal histories, place orders, monitor crypto prices, and much more. It includes both public and private endpoints, where public endpoints provide access to general market data, and private endpoints require authentication, granting access to user-specific resources, such as wallet details and trade history.

For advanced use cases, Coinbase also provides a WebSocket feed that enables developers to stream live market data in real-time. If you are learning blockchain development, this API is one of the most straightforward and valuable tools for experimentation. You can integrate with the Coinbase API to build a crypto portfolio tracker, payment gateway, or automated trading bot.

Now let’s break down the categories of commands and see how to work with the Coinbase API effectively.

Section 1: Authentication

Before using most private endpoints, you need to authenticate your requests. Coinbase utilizes API keys in conjunction with HMAC SHA-256 signatures for secure access.

You can generate your API key and secret from the Coinbase account dashboard under Settings > API.

Headers for authenticated requests:

pgsql

CB-ACCESS-KEY: Your API Key

CB-ACCESS-SIGN: Base64-encoded signature

CB-ACCESS-TIMESTAMP: Current UNIX timestamp

CB-ACCESS-PASSPHRASE: Your passphrase

How to create the signature:

• Concatenate the timestamp, HTTP method, request path, and body
  
• Use your secret key to create an HMAC SHA-256 signature of the above string
  

This authentication setup is required for all trading, account, and wallet endpoints.

Section 2: Get Current User Information

This endpoint helps you verify that your credentials are valid and lets you retrieve information about the account owner.

Endpoint:

bash
GET /v2/user
Curl Example:
bash
curl https://api.coinbase.com/v2/user \
  -H "CB-ACCESS-KEY: your_api_key" \
  -H "CB-ACCESS-SIGN: your_signature" \
  -H "CB-ACCESS-TIMESTAMP: your_timestamp" \
  -H "CB-ACCESS-PASSPHRASE: your_passphrase"

Section 3: Accounts and Balances

Each wallet on Coinbase is treated as an account. You can query all your accounts or fetch a specific one by its ID.

List All Accounts:

bash
GET /v2/accounts

Get a Single Account:

bash

GET /v2/accounts/{account_id}

Response Includes:

• Currency
  
• Balance
  
• Available funds
  
• Account name and ID
  

This endpoint is fundamental for tracking user balances and building a portfolio dashboard.

Section 4: Transactions: Send, Receive, List

You can use Coinbase to send and receive crypto directly through the API. This is useful for implementing crypto withdrawals or deposits inside your app.

List Transactions:

bash

GET /v2/accounts/{account_id}/transactions

Send Crypto:

bash

POST /v2/accounts/{account_id}/transactions

Request Body Example:

json

{
  "type": "send",
  "to": "destination_wallet_address",
  "amount": "0.01",
  "currency": "BTC",
  "description": "Withdrawal to external wallet"
}

Receive Address:

bash

GET /v2/accounts/{account_id}/addresses

Section 5: Get Spot Prices and Exchange Rates

Coinbase provides a straightforward method for retrieving spot prices for various crypto assets in multiple fiat currencies. This is often used in portfolio apps and dashboards to show real-time prices.

Get Spot Price:

bash

GET /v2/prices/BTC-USD/spot

Get All Exchange Rates:

bash

GET /v2/exchange-rates

You can also retrieve historical prices using the Coinbase Advanced Trade API, although it has a different structure and requires different permissions.

Section 6: Orders and Advanced Trade

Coinbase Advanced Trade provides REST and WebSocket APIs for professional trading. You’ll need to enable this feature in your Coinbase account and generate new keys specifically for it.

List Orders:

bash

GET /api/v3/brokerage/orders/historical

Place Order:

bash

POST /api/v3/brokerage/orders

Request Body Example:

json

{
  "client_order_id": "unique_id",
  "product_id": "BTC-USD",
  "side": "BUY",
  "order_configuration": {
    "market_market_ioc": {
      "quote_size": "50.00"
    }
  }
}

Orders are more flexible here, and you can choose from market, limit, and stop orders.

Section 7: Deposit and Withdrawals

Although Coinbase doesn’t offer programmatic access to initiate fiat deposits or withdrawals due to banking regulations, you can list recent deposits and crypto withdrawals.

List Deposits:

bash

GET /v2/accounts/{account_id}/deposits

List Withdrawals:

bash

GET /v2/accounts/{account_id}/withdrawals

You can track when a user has received or sent crypto using these endpoints. They are beneficial for SDKs and APIs targeting tax, accounting, or finance aggregation services.

Section 8: Coinbase Commerce API (For Payments)

The Commerce API enables developers to accept cryptocurrency payments in their applications. This API is separate from the main Coinbase user account API.

Create a Checkout:

bash

POST /charges

Request Example:

json

{
  "name": "Crypto Subscription",
  "description": "Monthly Pro Plan",
  "pricing_type": "fixed_price",
  "local_price": {
    "amount": "20.00",
    "currency": "USD"
  }
}

Get Charge Details:

bash

GET /charges/{charge_id}

Use this API for crypto payment processing, eCommerce plugins, or event ticketing platforms.

Section 9: Coinbase WebSocket API

Coinbase Pro’s WebSocket feed enables the use of websockets for real-time data streaming. It’s the fastest way to track price movements, order books, and trades.

WebSocket URL:

arduino

wss://ws-feed.exchange.coinbase.com

Subscribe to Channels:

json

{
  "type": "subscribe",
  "channels": [
    {
      "name": "ticker",
      "product_ids": ["BTC-USD"]
    }
  ]
}

You can subscribe to multiple channels including ticker, level2, matches, and user. This is helpful if your app requires live price updates without polling.

Rate Limits

Coinbase imposes different rate limits across its APIs.

• Public endpoints: 10,000 requests per hour
  
• Private endpoints: 5,000 requests per hour
  
• Advanced Trade API: More strict limits, often 10 req/sec
  

Always include retries and backoff logic in your code to handle rate limits gracefully.

Error Handling

Errors come with standard HTTP status codes:

• 400 – Bad Request
  
• 401 – Unauthorized
  
• 403 – Forbidden
  
• 404 – Not Found
  
• 429 – Rate Limit Hit
  
• 500 – Internal Server Error
  

All errors include a message field in the JSON body. You should log and report these errors clearly to help with debugging in production.

API Documentation and SDKs

Coinbase provides extensive documentation on its developer platform. You’ll find guides, code samples, and test credentials for different environments. While they don’t offer official SDKs in all languages, you’ll find several community-maintained ones across GitHub.

If you’re building with SDKs and APIs from multiple sources, Vezgo’s unified Crypto API helps bring all of them under one interface.

Support and Best Practices

Coinbase provides developer support through forums and ticketing systems. For business-critical applications, consider applying to their Enterprise API program. Best practices include:

• Use nonces and timestamps to avoid replay attacks
  
• Rotate your API keys periodically
  
• Monitor for suspicious activity and implement two-factor auth
  
• Use only HTTPS and validated domains
  

It is essential to follow secure development practices while working with crypto integrations, especially those involving user funds.

Final Thoughts

The Coinbase API is powerful, flexible, and battle-tested across a range of crypto products. You can use it for trading, wallet access, payments, and live data. If you’re building a product like a crypto portfolio tracker or tax accounting app, you should integrate with the Coinbase API as a foundational element. However, suppose you want to save months of development time and avoid the hassle of managing multiple integrations. In that case, Vezgo provides a unified solution that allows you to access data from Coinbase and hundreds of other platforms through a single interface. We’ll explore this further in the next section.

Vezgo: The Crypto API

As you explore Coinbase’s API for building your crypto app, it’s worth looking at how Vezgo can streamline and scale your development process. Vezgo is the all-in-one crypto data API designed to connect with major exchanges, including Coinbase, Binance, Kraken, and hundreds more. Instead of writing and maintaining individual integrations, Vezgo enables you to fetch balances, tokens, and transaction history across wallets, CEXs, DeFi protocols, and NFTs through a single, unified interface. It’s the bridge between your app and the entire crypto ecosystem, making it ideal for developers who want to move fast without sacrificing depth or accuracy.

Vezgo goes far beyond static data. Its infrastructure supports real-time data refreshes, making it perfect for portfolio and wealth trackers that require up-to-the-minute information on asset prices, wallet balances, and transaction flows. If your application requires monitoring user activity, updating holdings, or calculating portfolio value in fiat currencies, Vezgo delivers the data efficiently and securely. For developers building tools in the financial space, such as tax and accounting software, Vezgo provides normalized, structured, and historically accurate data that can be easily filtered, categorized, and integrated into ledgers or tax calculation workflows.

Security is also at the heart of the Vezgo platform. It is built on a SOC 2 Type II compliant infrastructure, utilizing AES-256 encryption and TLS 1.2, to ensure that user data remains secure during transmission and storage. Vezgo’s APIs are read-only, further reducing the risk of misuse. And suppose you want to see how it all works before diving into full development. In that case, Vezgo offers a live demo that allows you to preview the integration experience and test its capabilities in real-time. Are you building for personal finance, wealth management, or compliance? Vezgo offers the speed, flexibility, and reliability your product deserves.