Connect to Litecoin 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 Litecoin — 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 Litecoin
Account & wallet	`account.wallets[].address`	The connected Litecoin 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 LTC balance — Litecoin is UTXO-based, so there are no tokens or NFTs. The balance has ticker LTC, amount, decimals and fiat_value (USD).
Transactions	`GET /accounts/:id/transactions`	Native LTC deposits and withdrawals (UTXO), one per on-chain transaction. See "How to read a transaction" below.
Assets / securities	`balance.ticker`	Only the native coin LTC — there are no token contracts on Litecoin, so ticker_address is not used.

How to read a transaction

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

Native LTC movement — parts[] (direction received/sent, ticker "LTC", amount, fiat_value) and the network fee in fees[] (always LTC).
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 LTC movement (ticker "LTC")
const gas     = tx.fees?.[0];                // network fee, always in LTC
const parties = native?.other_parties ?? []; // extra UTXO inputs / outputs

// Litecoin 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 ("LTC"), amount, fiat_value, from_address, to_address, other_parties`	Native LTC movement. other_parties holds the extra UTXO inputs/outputs.
`tx.fees[0]`	`ticker ("LTC"), amount, fiat_value`	Network fee — always paid in LTC.

misc.origin_type is one of:

Supported

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

Notes & limitations

Litecoin 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 Litecoin 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