Implementing Futures Trading in a Cryptocurrency Exchange Mobile App
We develop mobile modules for futures trading — with perpetual contracts, leverage up to 125x, and a funding rate mechanism. Unlike spot trading, there is no real asset, only a contract on the price difference. This imposes fundamentally different requirements on the interface: Mark Price, Funding Rate, Liquidation Price, unrealized/realized PnL, and margin mode — everything must update in real time. Below is how we solve these challenges.
Why Futures Trading Is More Complex Than Spot on Mobile Devices
The spot screen shows price, chart, and order form. The futures screen adds margin indicators, liquidation, funding, and Long/Short switching. All data must be accessible without scrolling and confusion. A mistake in displaying the Liquidation Price can lead to loss of funds. Therefore, we use proven architectural solutions: WebSocket for streams, local caching of Mark Price, and a liquidation calculation formula that accounts for Cross/Isolated margin mode.
Perpetual Futures: Key Concepts for the UI
Mark Price — the index price calculated by the exchange based on a weighted average of several spot markets and the funding premium. It is used to compute PnL and liquidation — not the Last Price. The difference between Mark and Last can reach 0.5–2% during high volatility. In the UI, we show both values.
Funding Rate — the rate that longs pay to shorts (or vice versa) every 8 hours. When the deviation is significant, the rate can be 0.1% every 8 hours (~0.3% per day). We display the Funding Rate and a countdown timer until the next payment in the position card.
Leverage on futures changes dynamically via a slider or input field. The maximum leverage depends on position size: for example, on Binance, 125x is available only for positions up to 50,000 USDT.
Liquidation Price: Calculation for Futures
Formula for USDM perpetual (Binance Futures), LONG position:
LiquidationPrice = EntryPrice × (1 - InitialMarginRate + MaintenanceMarginRate) where InitialMarginRate = 1 / Leverage.
// Android — liquidation price for perpetual futures LONG fun calcLiqPriceLong( entryPrice: BigDecimal, leverage: Int, mmRate: BigDecimal = BigDecimal("0.005") // Maintenance Margin Rate ): BigDecimal { val imr = BigDecimal.ONE.divide(BigDecimal(leverage), 8, RoundingMode.HALF_UP) return entryPrice.multiply(BigDecimal.ONE.subtract(imr).add(mmRate)) .setScale(2, RoundingMode.HALF_UP) } For positions with averaging, the Entry Price is recalculated as a weighted average, and the Liquidation Price is updated. In Cross Margin mode, the entire balance is considered.
How to Ensure Real Position Safety with TP/SL
In futures, Take Profit and Stop Loss are set as attributes of a position, not separate orders. Binance Futures API: POST /fapi/v1/order with parameters reduceOnly=true, or creating TP/SL via closePosition=true. It is important to use workingType: MARK_PRICE — TP/SL triggers based on Mark Price, protecting against false triggers (wick hunting). We explain this to the user in a tooltip.
// iOS — creating TP/SL for a futures position struct FuturesTpSlRequest: Codable { let symbol: String let side: String // opposite to the current position let type: String // TAKE_PROFIT_MARKET or STOP_MARKET let stopPrice: String let closePosition: String // "true" let workingType: String // MARK_PRICE or CONTRACT_PRICE let timeInForce: String // GTE_GTC } According to Binance API Reference, this approach eliminates accidental liquidations.
UI of the Trading Screen: What We Do Differently
The futures trading screen is overloaded with data. Our mobile structure:
- Top: Mark Price (large), Last Price, Funding Rate + Countdown, 24h Change
- Center: candlestick chart (TradingView Lightweight Charts in WebView) with timeframe switching
- Bottom: tabs "Position" / "Open Orders" / "History" + order form
The order form is a Bottom Sheet with Long/Short tabs. Fields: Leverage (slider), Price (limit orders), Size (in contracts or USDT), margin mode Cross/Isolated.
Comparison of UI Approaches: Spot vs Futures
| Parameter | Spot | Futures |
|---|---|---|
| Price display | Last Price | Mark Price + Last Price |
| Position | separate screen | embedded in trading screen |
| Leverage | no | slider/field |
| Risk management | limit orders | TP/SL, liquidation |
| Data updates | REST every N sec | WebSocket real-time |
Our Experience and Quality Guarantees
We have been developing mobile exchange applications for 5+ years, completing over 10 projects for crypto exchanges and brokers. Every module undergoes code review, load testing, and compliance checks with App Store / Google Play guidelines. We provide full documentation and support during integration.
What's Included in the Work
- Architectural design of the module (data flow diagrams, WebSocket nodes)
- Development of UI components for iOS (Swift/SwiftUI) and Android (Kotlin/Jetpack Compose)
- Integration with exchange API (REST + WebSocket)
- Configuration of push notifications (APNs/FCM) for liquidation risks
- Testing: unit tests, UI tests, testing on emulators and real devices
- Documentation for developers and end users
- Assistance with publishing to App Store / Google Play
Timeline
MVP of the futures module (perpetual, Long/Short, TP/SL):
| Component | Duration |
|---|---|
| WebSocket Mark Price + Funding Rate | 3 days |
| Order form with leverage and margin mode | 1 week |
| Real-time position: PnL, Liquidation Price | 1 week |
| Position-linked TP/SL | 3 days |
| Trade and funding payment history | 3 days |
| Risk push notifications | 3 days |
Total: 4–6 weeks. Full module with Multi-asset Mode, Portfolio Margin, hedge mode — 3 months.
We will evaluate your project for free — contact us for a consultation. Let us know, and we will explain how to implement futures trading turnkey in your app.