Connect to Binance via Vezgo API

Real-Time

Accounts

Positions

Transactions

Support for Accounts, Positions, Transactions and Streaming enabled.

Support for Positions & Balances:

Spot
Margin
Earn (Staking)
Funding
Futures (Perpetual and Delivery)
Options (Only positions supported)
Auto Investments
NFT Holdings (limited metadata available in the Binance API)

Supported Transaction Types:

Spot: deposits/withdrawals, trades (including convert), fiat payments, BUSD converts, pay transactions and universal transfers.
Margin: trades.
Earn: dividends (staking).
Funding: BUSD converts, pay transactions and universal transfers.
Futures (Perpetual and Delivery).
Auto Investments: subscriptions

Additional Notes:

Only confirmed/completed transactions are supported.
Binance have a hard limit on trades earlier than oct 2022. Trades done before this date are not returned by their API.
Launchpad staking accounts are not supported by the Binance API.
We're working actively on enriching the supported transaction types.
alternate_names — Alternate names can be used in place of the provider's unique name in Connect URL.
Prefer to use binanceglobal as alternate_names for Connect URL.

Full List of Integrations

Data mapping

A field-level guide to the Vezgo API data for Binance — 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 Binance
Account & wallets	`account.wallets[]`	Binance connects with an API key + secret (no OAuth, no wallet address); a read-only key is recommended. Binance organizes holdings into several wallets — Spot, Funding, Margin, Earn (Savings / Staking), USD-M Futures, COIN-M Futures (delivery), Options and Auto-Invest — and Vezgo surfaces each present wallet as an entry in account.wallets[] (key on wallet.id). Only the Spot wallet's balances are reconciled from transaction history; the other wallets are the exchange-reported snapshot. wallet.is_reconciled is surfaced only for specially-enabled connections and is normally absent. (Binance US exposes only Spot and Savings.)
Balances / positions	`account.balances[]`	Per-asset balances and positions within each wallet. Each has ticker, amount, decimals and fiat_value (USD). asset_type includes "crypto" (spot / funding / margin / flexible-Earn holdings), "staked" (Earn staking — provider_ticker carries a .staked suffix, e.g. ticker ETH, provider_ticker ETH.staked), "cash" (USD fiat), "cash_equivalent" (non-USD fiat held in Spot / Funding / Margin), and the derivative position types "future" (USD-M), "delivery" (COIN-M) and "option" (contract details in misc.future_details / delivery_details / option_details). No ticker_address — exchange holdings are identified by ticker.
Transactions	`GET /accounts/:id/transactions`	Spot / margin trades, convert and dust trades, crypto and fiat deposits / withdrawals, staking / unstaking, rewards and bonuses, and futures income. A trade's two legs are reconciled into one transaction. See "How to read a transaction" below.
Assets / securities	`balance.ticker`	Identified by ticker (e.g. BTC, ETH). No ticker_address — custodial exchange balances are not on-chain tokens.

How to read a transaction

Each Binance activity maps to a Vezgo transaction. Read the value movement from parts[], and classify with transaction_type / transaction_subtype:

Value movement — parts[] (direction sent/received, ticker, provider_ticker, amount, fiat_value in USD). A trade has two parts (the base leg + the quote leg); staking / unstaking also have two legs that share the base ticker but differ by provider_ticker (base vs base.staked). Deposits, withdrawals, rewards and bonuses have one part.
Type — transaction_type (trade / deposit / withdrawal / staking / unstaking / reward / bonus / other). Most trades carry no transaction_subtype (read each leg's direction from parts[]); the exception is a dust trade (transaction_type "trade", transaction_subtype "dust_trade"). transaction_subtype refines the rest (common values, non-exhaustive — some derive from Binance's raw description): transfer_in / transfer_out, fiat_deposit / fiat_withdrawal, onchain_deposit / onchain_withdrawal, send_payment (deposits / withdrawals); income_reward, staking_reward (rewards); distribution, referral_bonus, rebate (bonuses); fees, refund (other).
Fees — fees[] (USD fiat_value); the fee's native asset and amount come from Binance's original network / trade fee.
Crypto deposits / withdrawals are on-chain: the part carries from_address / to_address and misc.network (the chain), and the on-chain hash is misc.origin_id (Binance uses the txId). Fiat deposits / withdrawals use the fiat ticker and have no address.
misc.origin_id is the txId for on-chain deposits / withdrawals, the order number for fiat, or the trade id for trades; misc.origin_type is the raw Binance / connector type (deposit, withdraw, trade, convert, fiat_deposit, fiat_withdrawal, dust_trade, …).

// One Vezgo transaction = a Binance activity (a trade's two legs reconciled into one)
const id   = tx.misc.origin_id;         // txId (on-chain), order no (fiat), or trade id
const kind = tx.misc.origin_type;       // raw Binance type (deposit, withdraw, trade, convert, dust_trade, …)

const type    = tx.transaction_type;    // trade | deposit | withdrawal | staking | unstaking | reward | bonus | other
const subtype = tx.transaction_subtype; // fiat_deposit | onchain_withdrawal | income_reward | … (trades none, except dust_trade)
const parts   = tx.parts ?? [];         // trade / staking / unstaking = 2 legs; else 1
const fees    = tx.fees ?? [];          // network / trade fee (fiat_value in USD)

const onchain = tx.parts?.find(p => p.from_address || p.to_address); // crypto deposit/withdrawal
if (onchain) { /* misc.network = chain; misc.origin_id = on-chain txId */ }
// Binance has no tokenTransfers / nftTransfers / internalTransfers arrays, and no
// top-level transaction_hash (the on-chain hash is in misc.origin_id).

Where to read it	Attributes	What it is
`tx.parts[]`	`direction, ticker, provider_ticker, amount, fiat_value, from_address, to_address`	Value movement. Trades, staking and unstaking have 2 legs (staking legs share ticker, differ by provider_ticker base vs base.staked); other activities have 1. from_address / to_address are present only on on-chain crypto deposits / withdrawals.
`tx.transaction_type · transaction_subtype`	`trade/deposit/withdrawal/staking/unstaking/reward/bonus/other · fiat_deposit, onchain_deposit, income_reward, distribution, rebate, …`	Normalized classification — prefer these over the raw misc.origin_type. Subtypes refine non-trade activity; trades carry no subtype except dust trades (dust_trade). Read each leg's direction from parts[].
`tx.fees[]`	`ticker, amount, fiat_value`	Network / trade fee. fiat_value is USD; ticker / amount are the native fee asset.

misc.origin_type is the raw activity type from Binance / the connector. It is open-ended — internal transfers use a UT_<route> form (e.g. UT_MAIN_UMFUTURE) and dividends carry Binance's raw description string — so always classify off transaction_type, not origin_type. Common values:

deposit
withdraw
trade
convert
dust_trade
fiat_deposit
fiat_withdrawal
staking
unstaking
reward
commission

Supported

Multiple wallets — Spot, Funding, Margin, Earn (Savings / Staking), USD-M & COIN-M Futures, Options, Auto-Invest
Crypto and fiat (cash) balances
Spot / margin trades, convert and dust trades (legs reconciled into one transaction)
Crypto deposits / withdrawals (on-chain, with from / to address and network) and fiat deposits / withdrawals
Staking / unstaking and staking rewards
Bonuses (referral, rebate, distribution) and income / dividends
Derivative positions — USD-M futures, COIN-M delivery and options (contract details in misc)
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.
A read-only API key is recommended; write-permission rejection is enforced only for clients with that feature enabled, and the check is best-effort.
There is no top-level transaction_hash — the on-chain hash for crypto deposits / withdrawals is misc.origin_id (the txId), with from / to address on the part and the chain in misc.network.

See the full Vezgo object reference

Try to connect to Binance 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