Connect to Dash via Vezgo API

Accounts

Positions

Transactions

Support for Accounts, Positions and Transactions enabled.

Retrieves a maximum of 5000 new transactions per sync, and up to 50,000 transactions in total. For extended keys, account is considered empty after encountering 20 unused addresses.

Full List of Integrations

Data mapping

A field-level guide to the Vezgo API data for Dash — 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 Dash
Account & wallet	`account.wallets[].address`	The connected Dash address or extended public key (xpub). An xpub derives all of the wallet's addresses; one address/xpub is one account. wallet.address holds it and is the stable identity reused across syncs and reconnects.
Balances / positions	`account.balances[]`	A single native DASH balance — Dash is UTXO-based, so there are no tokens or NFTs. The balance has ticker DASH, amount, decimals and fiat_value (USD).
Transactions	`GET /accounts/:id/transactions`	Native DASH deposits and withdrawals (UTXO), one per on-chain transaction. See "How to read a transaction" below.
Assets / securities	`balance.ticker`	Only the native coin DASH — there are no token contracts on Dash, so ticker_address is not used.

How to read a transaction

Each Dash transaction is a single native DASH movement (UTXO). Read it from the transaction itself:

Native DASH movement — parts[] (direction received/sent, ticker "DASH", amount, fiat_value) and the network fee in fees[] (always DASH).
Counterparties — parts[0] has from_address / to_address plus other_parties[] (UTXO transactions carry multiple inputs and outputs).
The on-chain transaction hash is in misc.origin_id; misc.owner_address is the wallet address (for an xpub wallet, the specific derived address involved — wallet.address holds the xpub).

// One Vezgo transaction = one on-chain transaction (tx.misc.origin_id = hash)
const hash = tx.misc.origin_id;        // on-chain transaction hash
const dir  = tx.transaction_type;      // "deposit" | "withdrawal" (canonical direction)
const kind = tx.misc.origin_type;      // "IN" (deposit) or "OUT" (withdrawal)

const native  = tx.parts?.[0];               // native DASH movement (ticker "DASH")
const gas     = tx.fees?.[0];                // network fee, always in DASH
const parties = native?.other_parties ?? []; // extra UTXO inputs / outputs

// Dash is native-only: no tokenTransfers / nftTransfers / internalTransfers.

Where to read it	Attributes	What it is
`tx.transaction_type`	`"deposit" \| "withdrawal"`	Canonical direction of the transaction.
`tx.parts[0]`	`direction, ticker ("DASH"), amount, fiat_value, from_address, to_address, other_parties`	Native DASH movement. other_parties holds the extra UTXO inputs/outputs.
`tx.fees[0]`	`ticker ("DASH"), amount, fiat_value`	Network fee — always paid in DASH.

misc.origin_type is one of:

Supported

Native DASH balance and transfers
Address and extended-public-key (xpub) wallets
Network fees (reported in DASH)
USD fiat valuation for balances and transactions

Notes & limitations

Dash is UTXO / native-only — no tokens, NFTs or staking.
decimals may be null for some chains (e.g. Dash, Litecoin); amount is in whole-coin units regardless.
fees[] is present on deposits too — there it is the whole on-chain network fee (economically paid by the sender), not a charge to your wallet; the connected wallet only bears the fee on sends/withdrawals.
Up to ~5,000 transactions per sync for typical wallets; for very large wallets the per-sync batch is smaller (~1,000) and history is imported incrementally over later syncs. Wallets with extremely large histories (50k+ transactions) are not supported.

See the full Vezgo object reference

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