Reaching the liquidation and futures numbers inside CoinUp

CoinUp packs liquidation levels, Binance futures prices, per-exchange long/short ratios and a continuously refreshed kimchi-premium view into a single mobile screen. The valuable part for an integrator is not any one chart — it is the normalized, cached aggregation the app builds on top of several exchanges at once. Reproduce that, and you have a clean derivatives-sentiment source without wiring up Binance, Upbit, Bithumb, Coinone and Korbit feeds individually.

The route here is authorized protocol analysis of the app's own traffic, under the client's authorization, with native push payloads as a second source for the alert surfaces. Below is what the app holds, how we reach it, and what gets delivered.

The market surfaces CoinUp aggregates

Each row is something the app actually renders. Where the app names a surface in its own words, that name is kept.

Authorized paths to the data

Protocol analysis of the app's own traffic

The app talks to a backend that has already done the cross-exchange aggregation. Capturing and documenting that traffic, under the client's authorization, reaches the liquidation, futures, long/short and premium surfaces in their normalized form. Effort is moderate; durability is good for as long as the app's client contract holds, and we account for revisions in maintenance. This is the path we would build the integration on, because it returns exactly what the app shows without you reconstructing each exchange feed.

Native push payloads for the alert surfaces

Exchange announcements, Binance change alerts and whale alerts are delivered as push notifications. Decoding those payloads gives an event stream with low latency and little overhead — a good complement for the announcement and whale surfaces specifically, less suited to the continuous chart data.

Direct exchange endpoints as a backstop

Where a surface maps cleanly onto a documented exchange endpoint — Binance publishes a long/short account-ratio endpoint, for instance — we can pull it straight from source. That trades the app's convenient aggregation for raw fidelity, and is worth keeping for fields where the upstream is authoritative.

A sample pull: long/short refresh

Illustrative shape, confirmed against the app's surface during the build rather than copied from a public document. It shows the normalized record we would expose and how the client handles a stale-cache response.

GET /v1/coinup/longshort?symbol=BTCUSDT&exchange=binance
Authorization: Bearer <session-token from documented auth flow>
Accept: application/json

200 OK
{
  "symbol": "BTCUSDT",
  "exchange": "binance",
  "as_of": "2026-06-07T08:15:00Z",
  "account_ratio": { "long": 0.612, "short": 0.388 },
  "top_trader_position": { "long": 0.547, "short": 0.453 },
  "source_cache_age_s": 42
}

# client side: reject anything older than the app's own refresh window
if record["source_cache_age_s"] > 120:
    raise StaleFeed(record["symbol"], record["source_cache_age_s"])

Field names and the exact auth handshake are pinned during the build; the token flow above stands in for whatever the live capture confirms.

What lands in your repo

Tied to the surfaces above, not a generic checklist:

• An OpenAPI/Swagger spec covering the liquidation, futures, long/short and premium endpoints we map.
• A protocol and auth-flow report — the token or session chain the app uses, plus how push payloads decode for the alert surfaces.
• Runnable source for the key endpoints in Python or Node.js, including the stale-cache guard shown above.
• Automated tests that exercise each surface and catch schema drift on the announcement and whale feeds.
• Interface documentation and data-retention guidance written for the Korean rules in play.

Keeping a live feed honest

This is real-time data, so freshness is part of correctness. We pin each record to the app's own cache age and refuse anything past its refresh window, the way the snippet does. Funding and liquidation series update on exchange cadence; the kimchi premium moves with both KRW spot and the USD/KRW reference, so we timestamp each leg separately rather than trusting a single combined value. The push surfaces are event-driven and need a reconnect-and-replay path so a dropped socket does not silently lose an announcement.

Korean data rules that shape the work

The market-data surfaces — liquidation, futures, long/short, premium — carry no personal data, which keeps most of this build clean. The community and account surfaces are different and stay on a user-consented footing. Korea's Personal Information Protection Act and the PIPC are the active regime; the commission has been probing Upbit and Bithumb over cross-border order-book sharing, which is a reminder that anything touching account-linked records needs explicit consent and data minimization. Separately, DAXA tightened exchange-API rules around key handling, identity verification and IP whitelisting, so any direct-endpoint backstop is built to respect those controls. We log access, keep consent records, and work under NDA where the client needs it.

What we plan around for this build

Two things we design for from the start, both handled on our side:

• The premium view fuses Korean spot quotes with a USD/KRW reference, and those two move on different clocks. We model each leg independently and compute the spread ourselves, so a lag on one side does not produce a phantom premium.
• Exchange-announcement and whale payloads change shape when an exchange revises its notice format. We bake a schema-version check into the parser and run a re-validation step that surfaces drift before it reaches your data, rather than waiting for a downstream break.

Access is arranged with you during onboarding — the build runs against a consenting account and the documented client traffic, and we scope the maintenance window up front so the live surfaces stay reliable.

Screens we mapped against

The app's own surfaces, used to confirm field names and layouts during the build.

How this brief was put together

Checked in June 2026 against the app's Google Play and App Store listings for its surface list, Binance's published derivatives documentation for the long/short shape, and recent Korean regulatory coverage of exchange-API and cross-border data rules. Citations:

• CoinUp on Google Play
• CoinUp on the App Store
• Binance long/short ratio endpoint docs
• South Korea / DAXA exchange-API rules
• PIPC cross-border data probe

Mapping reviewed by the OpenBanking Studio integration desk, 2026-06-07.

Where CoinUp sits among derivatives-data tools

Same category, useful when planning one unified feed across sources:

• CoinGlass — broad derivatives data and liquidation heatmaps aggregated across many exchanges.
• Coinalyze — aggregated open interest, funding and CVD with a clean charting surface.
• CoinAnk — liquidation heatmaps and predicted liquidation levels by leverage band.
• Cryptopolitan Data — open interest, pricing and liquidation feeds pulled from exchange REST APIs.
• Amberdata — live and historical Binance futures, order books, liquidations and funding rates.
• CryptoDataDownload — transaction-level liquidation data and timeseries summaries.
• Hyblock Capital — institutional liquidation analytics weighted by estimated position size.
• CoinMarketCap — market-cap, dominance and category data overlapping the app's heatmap view.

Questions integrators ask about CoinUp

Where do CoinUp's liquidation and long/short numbers actually come from?

They are aggregated from exchange derivatives endpoints. The app stitches together Binance futures data, top-trader and account long/short ratios, and liquidation events into per-symbol, time-bucketed series. We map how CoinUp normalizes and caches those before re-serving them, so the integration reflects what the app shows rather than guessing at raw exchange feeds.

Can the per-exchange price differences and USD/KRW spread be pulled separately?

Yes. The kimchi-premium view combines Korean spot quotes from Upbit, Bithumb, Coinone and Korbit with a USD/KRW reference, so we expose each leg as its own field plus the computed spread. That lets an arbitrage or monitoring tool consume the components without re-deriving the conversion.

Which Korean rules shape an integration that touches Upbit and Bithumb data?

Korea's Personal Information Protection Act and the PIPC's enforcement are the live concern, alongside DAXA's tightened exchange-API rules around key handling, identity verification and IP whitelisting. Market-data surfaces such as liquidation and futures series carry no personal data; the community and account surfaces do, so we keep those on a user-consented footing and minimize what is retained.

How do you keep up when the push alerts or announcement feed change format?

Exchange-announcement and whale-alert payloads shift when an exchange revises its notice schema, so we build a schema-version check into the parser and a re-validation pass that flags drift before it reaches your side. Delivery runs in one to two weeks, and maintenance windows are scoped up front.

Two ways the work is bought, and you can pick whichever fits. Source-code delivery starts at $300: you get the runnable source, the OpenAPI spec, tests and documentation, and you pay after delivery once you are satisfied. Or run on our pay-per-call hosted API — no upfront fee, you pay only for the calls you make. Either way the cycle is one to two weeks. Tell us the app and what you want out of it on the contact page and we will scope it.