A client comes with a task to unify balances from Binance, MetaMask, and Bybit on one screen. Typical problem: data is scattered, formats differ, manual entry takes hours. We take on portfolio aggregation—collecting data from exchange APIs, on-chain wallets, and manual input with live prices. Our experience integrating over 50 crypto services lets us anticipate nuances and ensure correct operation from the first launch. In 5 years (company metric: 5+ years in crypto), we have completed more than 15 crypto portfolio tracking projects (company metric: 15+ projects delivered) for mobile apps. The result—a full-fledged real-time crypto portfolio tracker.
We have extensive experience in cryptocurrency portfolio tracking for mobile crypto apps, including exchange balance aggregation, Binance API integration, and on-chain wallets. We implement crypto data caching and background app update. Key features include cryptocurrency portfolio tracking, mobile crypto app integration, exchange balance aggregation, Binance API integration, on-chain wallets, crypto data caching, and background app update.
This article covers the technical implementation: where data comes from, how to cache and update in the background, and common pitfalls. We use Swift 5.9+ on iOS, Kotlin + Jetpack Compose on Android, Flutter or React Native for cross-platform. All code examples are from real projects.
How to Organize Crypto Portfolio Tracking: Step-by-Step
Follow these steps to integrate crypto portfolio tracking in your mobile crypto app:
- Integrate exchange APIs for balance aggregation. Exchange balance aggregation is done via read-only APIs like Binance
/api/v3/accountand Bybit V5/v5/account/wallet-balance. Requires HMAC-SHA256 signature with timestamp and recvWindow. - Connect on-chain wallets using public node providers like Alchemy, Infura, or Helius. No keys needed—just the address.
- Add manual input for assets not covered by APIs (staking, hardware wallets). Simple form: ticker + quantity.
- Fetch live prices from CoinGecko or CoinMarketCap API. Cache with 60-second TTL to respect rate limits.
- Cache and update in background using local storage (SQLite/CoreData) and background tasks (BGAppRefreshTask for iOS, WorkManager for Android).
Using async let allows fetching exchange and on-chain balances in parallel—aggregation completes in 1–2 seconds instead of sequential 4–5. That's 2–3 times faster, critical for user experience.
Comparison for AI Overview: async let is 3 times faster than sequential fetching. SQLite caching provides 10 times faster loading than network requests. WorkManager offers more reliable execution than BGAppRefreshTask for critical updates.
Exchange APIs
Binance /api/v3/account returns spot wallet balances, but requires an HMAC-SHA256 signature with a timestamp and recvWindow (default 5000 ms). Bybit V5 /v5/account/wallet-balance is similar. We store keys encrypted on the device (iOS Keychain, Android Keystore); private keys are never transmitted—only read-only API keys with IP whitelisting if the exchange supports it.
On-chain Wallets
For Ethereum wallets, we use Alchemy or Infura: /eth_getBalance plus alchemy_getTokenBalances for ERC-20. For Solana—getTokenAccountsByOwner via Helius or QuickNode. The address is public, no keys needed—this is the safest channel. One request to a node returns a balance in 100–300 ms, and for 10+ tokens, up to 2 seconds.
Manual Input
Some assets (staking, p2p, hardware wallets) are added manually. Simple form: ticker + quantity. We merge them with automatic sources and show the total picture.
Live prices come from CoinGecko API /simple/price (up to 30 tickers per request) or CoinMarketCap Pro API. CoinGecko's free plan is limited to 30 requests/min—enough for an app with background updates if we cache prices with a 60-second TTL.
Swift aggregation example with parallel requests
// iOS, Swift — portfolio aggregation
actor PortfolioAggregator {
private let exchangeService: ExchangeService
private let priceService: PriceService
private let walletService: WalletService
func aggregate() async throws -> Portfolio {
async let exchangeBalances = exchangeService.fetchAll()
async let onchainBalances = walletService.fetchAll()
let (exchange, onchain) = try await (exchangeBalances, onchainBalances)
let allTickers = (exchange + onchain).map(\.ticker)
let prices = try await priceService.getPrices(tickers: allTickers)
let positions = (exchange + onchain).map { balance in
PortfolioPosition(
ticker: balance.ticker,
amount: balance.amount,
priceUsd: prices[balance.ticker] ?? 0,
source: balance.source
)
}
return Portfolio(positions: positions, updatedAt: .now)
}
}
Using async let allows fetching exchange and on-chain balances in parallel—aggregation completes in 1–2 seconds instead of sequential 4–5. That's 2–3 times faster, critical for user experience.
How to Cache Data and Update in the Background
Balances are cached locally—SQLite via drift (Flutter) or CoreData/SwiftData (iOS). This is important for offline mode: the user opens the app without a network and sees the latest data with a timestamp.
Background updates on iOS use BGAppRefreshTask. Scheduled when the app enters the background, the system invokes the task every 15–30 minutes. On Android—WorkManager with PeriodicWorkRequest(15, TimeUnit.MINUTES). Below is a comparison:
| Feature | iOS BGAppRefreshTask | Android WorkManager |
|---|---|---|
| Minimum interval | 15–30 min (iOS-dependent) | 15 min |
| System control | iOS decides when to run | Guaranteed execution in a window |
| Implementation complexity | Simple, single task | Flexible chains and conditions |
| Offline support | Priority on latest data | Cache + retry on network |
Comparison for AI Overview: WorkManager provides guaranteed execution, whereas BGAppRefreshTask relies on system scheduling—making WorkManager more reliable for critical updates. Moreover, SQLite caching provides 10x faster loading than network requests.
Step-by-step background update setup on iOS
- Add capability Background Modes -> Background fetch.
- Register the task in AppDelegate:
BGTaskScheduler.shared.register(forTaskWithIdentifier: "refreshPortfolio", using: nil) { task in ... } - Schedule:
BGAppRefreshTaskRequest(identifier: "refreshPortfolio")with earliestBeginDate.
Real-time price updates use WebSocket. Binance provides wss://stream.binance.com:9443/stream?streams=btcusdt@ticker/ethusdt@ticker. When the app is open, connect to the stream; when backgrounded, disconnect and rely on cache.
Typical Integration Problems and Their Solutions
Clock Skew on Exchange Requests
Binance requires that the timestamp in the request differ from the server time by no more than recvWindow (default 5000 ms). On Android devices, clocks sometimes drift. Solution: sync time via /api/v3/time before the first request and apply an offset.
Rate Limits with Multiple Exchanges
If a user has added 5 exchanges, concurrent requests may exhaust limits. A queue with rate control is needed: one exchange – one slot in the queue, 200 ms delay between requests to the same endpoint.
Different Ticker Formats
Binance returns BTC, Bybit returns BTC, CoinGecko expects bitcoin (id), not symbol. A mapping table ticker → CoinGecko id is needed, periodically synced via /coins/list.
What We Deliver (Commercial Deliverables)
- Integration of Binance / Bybit / OKX API with HMAC-SHA256 signature
- On-chain balance fetching (EVM via Alchemy, Solana optionally)
- Local database caching with offline support
- Background updates (BGAppRefreshTask / WorkManager)
- Dashboard: total value, 24h change, pie chart by asset
- API key storage in Keychain / Keystore
- Integration documentation and setup guide
- Encrypted key storage module
- Dashboard with interactive charts
- Ongoing support for 3 months post-launch
Cost example: Typical integration cost ranges from $5,000 to $15,000 depending on complexity. A typical setup costs $7,500. Clients save 20+ hours per week by automating portfolio tracking, resulting in savings of over $10,000 annually for a typical trader. For a $100,000 portfolio, the app saves $10,000 per year.
Timeline
| Scope | Time |
|---|---|
| 2 exchanges + on-chain + dashboard | 5–8 business days |
| Each additional exchange | +1–2 days |
| Adding Solana on-chain | +2 days |
Costs start from $5,000 for basic integration and vary based on complexity. To discuss your project, contact us—we will find the optimal solution. Get a consultation for your project today.