Pulling balances, trades and live quotes out of Quotex

Every quote tick, every option you open, and your running balance travel over a persistent WebSocket connection between the Quotex client and its back end — that socket is the integration target, not a set of REST pages. Quotex launched in 2019 and runs a fixed-time digital-options model: pick an asset, pick an expiry between five seconds and 24 hours, stake from $1, and the platform settles the contract against its own quote stream (per the platform's own description and third-party reviews). For anyone trying to mirror Quotex activity into a dashboard, a tax workbook, or a copy-trading engine, the data exists and is structured — it is just locked inside an authenticated real-time channel rather than an export button.

The bottom line: Quotex behaves like a real-time market client, so the work is decoding a session protocol and re-emitting it as something callable. We would read the authenticated socket against a consenting account, normalize the message types into a small typed API, and hand you that plus the captured protocol notes. Native export is thin here, so the socket route carries the integration and consented credential access is what makes it lawful.

What sits behind a Quotex login

These are the data domains an integrator would actually want, mapped to where they originate in the app and what they are good for.

Getting at the data: the routes that fit Quotex

Three approaches genuinely apply. They are not equal here, and the recommendation is plain.

Protocol analysis of the WebSocket session

We capture the authenticated socket traffic against an account you control, decode the handshake and the per-channel message types, and rebuild them as typed calls. Reachable: everything in the table above, in real time. Effort is moderate — the heavy part is mapping the message schema and the session/SSID handshake, not the transport. Durability is good between front-end revisions, with the caveat that payload field names do shift. Open-source references such as the community Python clients confirm the same surface set (connect, get_balance, buy, get_candles, get_historical_candles), which shortens discovery. This is the route we would run the integration on.

User-consented credential access

For a hosted setup, the account holder consents and we drive the session under that authorization, refreshing tokens as the client does. This is less a separate data route than the access model that makes the socket route lawful for an offshore platform with no regulator-backed consent rail — it pairs with route one rather than replacing it.

Native export as a fallback

Quotex surfaces trade history inside the app, but a structured in-app download is limited. Where a manual statement or CSV is available for a one-off reconciliation, we will wire a parser for it — useful as a backfill seed, not as the live feed.

The live socket, sketched

An illustrative shape of the session — message names and framing are confirmed per account during the build, not guessed at runtime. The real client multiplexes channels over one socket and authenticates with a session token rather than replaying a password.

# Illustrative — schema pinned from captured frames during the build
ws = connect("wss://<quote-host>/socket.io/?EIO=4&transport=websocket")

# 1) authorize the session with the account holder's token (no credential replay)
ws.send(authorize({ "session": SSID, "isDemo": 0, "tournamentId": 0 }))

# 2) subscribe to the surfaces you need
ws.send(subscribe("balance"))                       # account channel
ws.send(subscribe("candles", asset="EURUSD_otc",
                   period=60))                       # realtime OHLC

# 3) inbound frames, normalized to a stable schema
on("balance",  f -> upsert_balance(f.account, f.amount, f.currency))
on("position", f -> record_trade(f.id, f.asset, f.dir, f.stake, f.expiry))
on("closed",   f -> settle(f.id, f.result, f.payout, f.profit))

# error / lifecycle handling we ship by default
on("disconnect", _ -> backoff_reconnect(max=5))
on("auth_error", _ -> refresh_session_then_resubscribe())
      

The fields above (balance amount, account mode, contract id, payout, profit) map one-to-one onto the normalized records we expose; error handling for reconnect and token expiry is part of what ships, because a trading socket that drops silently is worse than no feed.

What lands in your repo

Concretely, for a Quotex build you receive:

• An OpenAPI/Swagger spec for the normalized surface — balance, positions, closed trades, candles, assets, cashier — so downstream teams code against a stable contract, not the raw socket.
• A protocol and auth-flow report: the session/SSID handshake, channel subscription model, demo-vs-real account context, and the message types we observed, with captured sample frames.
• Runnable source for the key channels in Python and Node.js — connect, authorize, subscribe, and the typed handlers — not a stub.
• Automated tests built on recorded fixtures so the schema is asserted, plus a reconnect/auth-refresh test.
• Interface documentation and data-retention guidance covering what is stored, for how long, and how consent is recorded.

What we plan around on a Quotex build

Two things we account for up front, because they are specific to this platform:

• Demo and live run side by side. Quotex pairs a $10,000 practice balance with the funded account, as the app describes it. The account mode rides on balance and order messages, so we tag every record by mode and keep practice fills out of any live P&L or tax output. Getting this wrong silently corrupts analytics, so it is a first-class field, not an afterthought.
• Quote payloads drift. Field names and asset identifiers on the realtime channel change without notice. We pin the observed schema, capture fixtures, and schedule a re-validation pass so a renamed field trips a failing test instead of feeding bad candles into a backtest. Maintenance cadence is agreed with you when we scope the work.
• OTC vs. exchange assets behave differently. Quotex runs synthetic OTC instruments alongside market-hours assets; we model the asset catalogue so consumers know which symbols trade around the clock and which follow a session.

Access to a working account is arranged with you during onboarding — the build runs against a consenting account you control, and credentials, scope and any NDA are handled as part of starting the project.

Authorization and the offshore-broker reality

Quotex is not licensed by a Tier-1 authority — no FCA, CySEC or ASIC oversight — and operates through Awesomo Ltd in Seychelles, with its earlier IFMRRC registration having lapsed in 2021 according to broker-review coverage. The practical consequence: there is no open-banking, AIS or account-aggregation regime to consent through. The dependable legal basis is therefore the account holder's own authorization to access their own data. We operate compliance-first regardless: access is authorized and logged, consent scope is recorded, data is minimized to what the integration needs, and we sign an NDA where the work touches anything sensitive. Reverse engineering of the interface here is for interoperability — reading data the account already owns — not for defeating any control.

Build scenarios this maps to

• Mirror a trader's closed-position history into a P&L and tax workbook nightly, demo trades excluded.
• Stream live balance and open contracts into a risk dashboard with drawdown alerts.
• Archive tick and candle data per asset for backtesting a signal model offline.
• Fan a consenting account's fills out to a copy-trading service in near-real-time.

Pricing and how a build runs

A typical Quotex socket integration is a one-to-two-week cycle. From there, two ways to take delivery. The first is source-code delivery from $300: you get the runnable API source, the protocol report, tests and documentation, and you pay only after delivery once it works for you. The second is a pay-per-call hosted API — we run the endpoints, you call them, and you pay per call with no upfront fee. You bring the app name and what you want from its data; we handle the rest. Tell us which surfaces matter and we will scope it — start a conversation on the contact page.

Screens we worked from

App store screenshots used while mapping the trading and account surfaces.

How this mapping was put together

Checked in June 2026: the app's own store description for the trading model, deposit minimums and demo balance; broker-review coverage for ownership and regulatory status; and two open-source Python clients to confirm the reachable channel set before scoping. Primary references opened:

• cleitonleonel/pyquotex — community client showing the connect / balance / candles / trade surface.
• ChipaDevTeam/QuotexAPI — async WebSocket client with auto-reconnect.
• Traders Union Quotex review — ownership, license status and trading mechanics.
• TradingFinder Quotex alternatives — same-category platform set.

OpenBanking Studio integration desk · mapping reviewed June 2026.

Peer platforms in the same bracket

Same-category apps an integrator often wants under one unified interface. Listed for ecosystem context only.

• Pocket Option — digital options with social and copy trading; holds balances, fills and a $5-minimum cashier ledger.
• IQ Option — CySEC-regulated multi-asset broker; account portfolios, order history and quote streams.
• Olymp Trade — fixed-time and CFD trades; per-user balances, positions and tutorials state.
• Binomo — beginner-focused options app; demo and live balances, trade records and deposits.
• ExpertOption — fast-execution options platform; account state and per-asset quotes.
• Deriv — successor to Binary.com; synthetic indices, contracts and a documented account model.
• IQcent — low-minimum options broker; balances, trade history and copy features.
• Binolla — newer fixed-time platform; account balances and trade settlement records.

Questions a Quotex integrator asks

Which Quotex surfaces actually carry the data worth syncing?

The account socket carries the live and demo balance; the trading and history modules carry open positions, closed trades with entry price, expiry and payout, and the deposit/withdrawal ledger; the realtime channel carries per-asset quote ticks and OHLC candles. Those are the surfaces we map, normalize and expose.

Quotex is an offshore broker with no Tier-1 license. Does that change the integration?

It changes the legal basis, not the engineering. With no open-banking or AIS regime over Awesomo Ltd, the dependable basis is the account holder's own authorization to reach their data. We build against a consenting account, log scope, and keep the work data-minimized and under NDA where you need it.

Can you separate demo-account activity from real-money trades?

Yes. Quotex runs a $10,000 demo balance alongside the funded account, as the app describes it, and the account context is part of every balance and order message. We tag each record by account mode so your downstream system never mixes practice fills with live ones.

How do you keep up when Quotex changes its socket payloads?

We pin the observed message schema, add fixtures captured during the build, and run a re-validation pass on a schedule so a renamed field or a changed handshake surfaces as a failing test rather than silent bad data. Maintenance windows are scoped with you up front.