Coinbase Advanced Trade API

This skill enables integration with Coinbase's Advanced Trade API to access granular Level 2 (L2) orderbook data, real-time market trades, and websocket feeds for cryptocurrency trading applications.

What This Skill Does

Provides secure access to Coinbase Advanced Trade API with real-time orderbook construction, trade data streaming, and proper credential management. Ideal for building trading dashboards, market analysis tools, or automated trading systems.

Instructions

1. Credential Management

**CRITICAL**: Never expose or log API credentials directly.

Access credentials exclusively through environment variables stored in `.env` file

Use `COINBASE_API_KEY` for the API access key

Use `COINBASE_SECRET_KEY` for the API secret key

**DO NOT** read, modify, display, or log these values in application code

Pass credentials directly to API client initialization without intermediate storage

2. Websocket Connection

**Endpoint**: `wss://advanced-trade-ws.coinbase.com`

When establishing websocket connections:

1. Create secure websocket client with authentication headers using env credentials

2. Implement reconnection logic with exponential backoff for network resilience

3. Subscribe to relevant channels immediately after connection established

4. Handle connection errors gracefully without exposing credentials in error messages

3. Available Channels

**`level2` Channel** - Full Orderbook Updates:

Provides complete L2 orderbook state with all price levels

Initial snapshot followed by incremental updates

Use for maintaining accurate orderbook state

**`market_trades` Channel** - Real-time Time & Sales:

Stream of executed trades as they occur

Includes price, size, timestamp, and trade side

Use for trade flow analysis and market monitoring

4. L2 Orderbook Construction

Implement orderbook maintenance following these steps:

**Step 1: Initialize with Snapshot**

Upon subscription, receive initial orderbook snapshot

Store complete bid/ask state with price levels and quantities

Validate snapshot integrity before processing updates

**Step 2: Apply Incremental Updates**

Process `l2update` messages sequentially

For each update: modify quantity at specified price level

If quantity = 0, remove that price level entirely

Maintain sorted order (bids descending, asks ascending)

**Step 3: Implement Pruning Strategy**

**Backend**: Maintain full orderbook depth for complete market view

**Frontend**: Slice to top 20 levels per side to minimize bandwidth

Implement efficient data structure (e.g., sorted map) for O(log n) updates

Consider websocket message throttling to reduce frontend update frequency

5. Implementation Pattern

```

1. Load credentials from environment (never hardcode)

2. Establish authenticated websocket connection

3. Subscribe to level2 and/or market_trades channels

4. Receive snapshot and initialize orderbook state

5. Process updates in real-time, maintaining full book backend

6. Transmit pruned top_20 data to frontend via optimized transport

7. Implement error handling and reconnection logic

```

6. Best Practices

Use connection pooling for multiple product subscriptions

Implement message validation to detect dropped updates

Add sequence number tracking to ensure update ordering

Log connection events (without credentials) for debugging

Implement graceful shutdown to unsubscribe from channels

Consider rate limiting compliance per Coinbase API terms

Example Usage

**Scenario**: Build a real-time orderbook visualization dashboard

1. Backend establishes websocket connection using env credentials

2. Subscribes to `level2` channel for BTC-USD product

3. Receives snapshot and constructs initial orderbook

4. Processes continuous `l2update` messages

5. Maintains full orderbook internally for analysis

6. Sends top 20 bid/ask levels to frontend every 100ms

7. Frontend renders dynamic orderbook ladder with price levels

**Scenario**: Market trade flow analyzer

1. Connect to `market_trades` channel for multiple products

2. Stream trade data into time-series database

3. Calculate rolling metrics (volume, VWAP, trade size distribution)

4. Trigger alerts on unusual trade patterns

Constraints

API credentials must remain in `.env` and never be logged or displayed

Maintain full orderbook backend; only prune for frontend transmission

Handle websocket disconnections with automatic reconnection

Respect Coinbase API rate limits and terms of service

Validate all incoming messages to ensure data integrity

Coinbase Advanced Trade API

Coinbase Advanced Trade API

What This Skill Does

Instructions

1. Credential Management

2. Websocket Connection

3. Available Channels

4. L2 Orderbook Construction

5. Implementation Pattern

6. Best Practices

Example Usage

Constraints

Reviews (0)