Connect to Coinbase Prime via Vezgo API

Accounts

Positions

Transactions

Support for Accounts, Positions and Transactions enabled.

Support for transactions and orders enabled.
Only transactions that affect balances are accessible.
Types of transactions supported:
TRANSACTION_TYPE_UNKNOWN
DEPOSIT
WITHDRAWAL
INTERNAL_DEPOSIT
INTERNAL_WITHDRAWAL
SWEEP_DEPOSIT
SWEEP_WITHDRAWAL
PROXY_DEPOSIT
PROXY_WITHDRAWAL
BILLING_WITHDRAWAL
REWARD
COINBASE_REFUND
TRANSACTION_TYPE_OTHER
WITHDRAWAL_ADJUSTMENT
DEPOSIT_ADJUSTMENT
KEY_REGISTRATION
DELEGATION
UNDELEGATION
RESTAKE
COMPLETE_UNBONDING
WITHDRAW_UNBONDED
STAKE_ACCOUNT_CREATE
CHANGE_VALIDATOR
STAKE
UNSTAKE
REMOVE_AUTHORIZED_PARTY
STAKE_AUTHORIZE_WITH_SEED
SLASH
COINBASE_DEPOSIT
CONVERSION
CLAIM_REWARDS
VOTE_AUTHORIZE
WEB3_TRANSACTION
ONCHAIN_TRANSACTION:
PORTFOLIO_STAKE
PORTFOLIO_UNSTAKE
Types of orders supported:
UNKNOWN_ORDER_TYPE
MARKET
LIMIT
TWAP
BLOCK
VWAP
STOP_LIMIT
RFQ
PEG

Full List of Integrations

Data mapping

A field-level guide to the Vezgo API data for Coinbase Prime — what each attribute means and where to read it — so you can map it into your own system.

Data	Where to read it	Source on Coinbase Prime
Account & wallets	`account.wallets[]`	Coinbase Prime connects with a Prime API key — Access Key, Signing Key and Passphrase (no OAuth, no wallet address); a read-only (View) key is sufficient. The connection surfaces one wallet, "Coinbase Prime Trading Account" (key on wallet.id; wallet.address is null), valued at the entity's total trading balance in USD, summed across every portfolio.
Balances / positions	`account.balances[]`	Per-symbol balances of the trading account, as reported by Coinbase Prime. Each balance has ticker, amount, decimals and fiat_value (USD, Prime's own valuation). asset_type is "crypto" for crypto assets and "cash_equivalent" for fiat (e.g. USD). balance.name is the symbol itself (Prime does not provide full asset names). No ticker_address — custodial holdings are identified by ticker only.
Transactions	`GET /accounts/:id/transactions`	Filled orders (buys and sells, surfaced as trades with both legs as parts) plus the activity feed: deposits and withdrawals (external, internal, sweep and Coinbase-linked), conversions, and other account activity. See "How to read a transaction" below.
Assets / securities	`balance.ticker · balance.provider_ticker`	Identified by Coinbase Prime's own symbol, passed through as both ticker and provider_ticker (e.g. BTC, ETH, USDC). Prime lists some network-specific assets under a prefixed symbol — for example ARBUSDC is USDC on Arbitrum — and these arrive verbatim; there is no ticker_address or network field to resolve them, so map such symbols to the underlying asset on your side.
KYC data	`GET /accounts/:id/kyc-data`	Coinbase Prime supports KYC data: the portfolio user's email and name, with the Prime role, entity id and portfolio id under misc. KYC is read from the first portfolio the API returns, so the portfolio id names that one rather than the whole entity.

How to read a transaction

Each Coinbase Prime order or activity maps to a Vezgo transaction. Read the value movement from parts[], and classify with transaction_type:

Trades — a filled order is one transaction with transaction_type "trade" and transaction_subtype "buy" or "sell". Its two legs are parts[] (base asset and quote currency, direction sent/received); both legs carry the order's filled quote value converted to USD as fiat_value, so a MON-USD buy filled for 498.76 USD reports 498.76 on both the MON and the USD leg. fees[] carries the order commission. misc holds Prime's order status, side, average_filled_price, exchange_fee and quote_value; misc.origin_type is the Prime order type (market, limit, twap, …).
Deposits and withdrawals — one part each (transaction_type "deposit" / "withdrawal"); external, internal (between portfolios), sweep and Coinbase-linked transfers are all classified this way, with the raw kind in misc.origin_type. parts[].to_address / from_address carry Prime's transfer endpoints (an address or a Prime wallet id). fees[] carries the transfer fee when Prime reports one. There is no transaction_hash.
Conversions (e.g. USDC ↔ USD) — transaction_type "other" with two parts: the sent source asset and the received destination asset (misc.origin_type "conversion"). Other activity kinds Vezgo does not model (rewards, staking activity, …) also arrive as "other" with the raw kind in misc.origin_type.
misc.origin_id is the Prime order id or activity id; misc.status is Prime's own status for the order or activity.

// One Vezgo transaction = a Coinbase Prime filled order or activity-feed entry
const id   = tx.misc.origin_id;        // Prime order id / activity id
const kind = tx.misc.origin_type;      // raw Prime kind (market, limit, deposit, withdrawal, internal_deposit, conversion, …)

const type  = tx.transaction_type;     // trade | deposit | withdrawal | other
const side  = tx.transaction_subtype;  // buy | sell (trades only)
const parts = tx.parts ?? [];          // trade / conversion = 2 legs; deposit / withdrawal = 1
const fees  = tx.fees ?? [];           // order commission or transfer fee (fiat_value in USD)

// Both legs of a trade carry the same fiat_value: the filled quote value in USD.
// Symbols are Prime's own — ARBUSDC is USDC on Arbitrum; resolve prefixed symbols on your side.

Where to read it	Attributes	What it is
`tx.parts[]`	`direction, ticker, provider_ticker, amount, fiat_value, to_address, from_address`	Value movement. Trades and conversions have 2 legs; deposits and withdrawals have 1. Trade legs both carry the filled quote value in USD. to_address / from_address are present on deposits and withdrawals (Prime transfer endpoints: an address or a Prime wallet id).
`tx.transaction_type · tx.transaction_subtype`	`trade / deposit / withdrawal / other · buy / sell`	Normalized classification — prefer it over the raw misc.origin_type. transaction_subtype is set on trades only. Conversions and unmodelled activity kinds are "other".
`tx.fees[] · tx.misc`	`fees: ticker, amount, fiat_value · misc: origin_id, origin_type, status, side, average_filled_price, exchange_fee, quote_value`	Order commission or transfer fee (native asset + USD value). misc carries Prime's raw status plus, on trades, the order side, average filled price, exchange fee and quote value.

misc.origin_type is the raw Coinbase Prime order type or activity kind, lower-cased. Always classify off transaction_type. Common values:

market
limit
twap
deposit
withdrawal
internal_deposit
internal_withdrawal
sweep_deposit
sweep_withdrawal
coinbase_deposit
coinbase_withdrawal
conversion
reward

Supported

One trading-account wallet valued at the entity's total trading balance across all portfolios (USD)
Crypto balances (asset_type crypto) and fiat balances (asset_type cash_equivalent)
Filled orders as trades — buy / sell subtype, both legs as parts, order commission as fees
Deposits and withdrawals — external, internal, sweep and Coinbase-linked — with transfer endpoints
Conversions (two legs as parts)
KYC data (email, name, role, entity and portfolio ids)
USD fiat valuation for balances and transactions

Notes & limitations

Balances are the exchange's reported (custodial) holdings — there is no on-chain wallet address for balances.
Symbols are Prime's own and are not normalized: network-specific listings such as ARBUSDC (USDC on Arbitrum) arrive verbatim with no ticker_address or network field.
An entity's portfolios are combined into the one trading-account wallet: balances are summed and history is merged across all of them.
Conversions, rewards and other activity kinds Vezgo does not model surface as transaction_type "other" — read the raw kind from misc.origin_type.
Deposits and withdrawals carry to_address / from_address but no transaction_hash.
Values are USD; fiat_value can be 0 when a USD rate is unavailable.

See the full Vezgo object reference

Try to connect to Coinbase Prime in our Demo Sandbox

Open Demo

Let's get you started

To get your API Keys, sign up on the portal or reach out to the team at sales@vezgo.com

Talk to Sales Explore a Demo