Getting balances, trades and live quotes out of a Quotex account

Every figure a Quotex user sees — the demo balance the app advertises at $10,000, a 60-second digital-options position, the candle feed behind the chart — arrives over a single persistent WebSocket, not a page you can scrape row by row. That one fact decides the whole integration. The data is not sitting in downloadable statements; it is a live stream plus a settlement event, and reaching it cleanly means speaking the socket protocol the app already speaks. That is the work this brief describes, and the thing we hand over at the end.

Quotex sells fast fixed-time trades on currencies, crypto, commodities and indices, with a $10 minimum deposit and trades from $1 per its own store description. For anyone building a trading journal, a copy-trade dashboard, a tax or P&L report, or a risk monitor on top of it, the useful records are per-account and behind a login: balance, open and closed positions, payout percentages, and the quote history. We map that surface under the account holder's authorization and deliver runnable code that reads it.

What a Quotex account actually holds

The rows below are the surfaces an integrator would actually want, named the way the platform exposes them over its channel. Granularity matters here: quotes tick continuously, but a trade only becomes a fact on expiry.

Authorized routes to the data

Three routes genuinely apply to an app shaped like this. None of them requires you to clear anything before we begin — access and consent are arranged with you as part of the build.

1. Socket protocol analysis (the route we'd take)

Quotex's client and server exchange data over a WebSocket. We map that channel — the authorization frame, the instrument subscriptions, the order and settlement messages — and reproduce it as a clean client. Open-source projects such as the PyQuotex library already demonstrate the same channel, which shortens the discovery work and gives us a reference to validate frame shapes against. This route reaches everything the app itself reaches, because it speaks the app's own language.

2. User-consented credential access

The session begins with the account holder's own login. With their consent we drive that login to derive a session token (SSID), then reuse it for the socket. This is what makes the data lawful to touch: it is the user's account, reached with the user's permission. Suited to single-account tools and back-office reconciliation.

3. In-app export as a fallback

Where a workflow only needs occasional history rather than a live feed, the trade and cashier views can be read and normalised on a schedule. Lower effort, lower freshness — a reasonable secondary path, not the one to build a real-time product on.

For most briefs that come to us about Quotex the answer is route one with the route-two login in front of it: a consented session that opens the socket, because that is the only path that delivers both live quotes and settled trades from the same source. The export path is worth keeping as a cheap backfill, nothing more.

How the socket session works in practice

The flow below is illustrative; the exact frame shapes get confirmed against the live channel and the open-source client during the build, not taken from any vendor manual. It shows the part that trips people up: the SSID has to be derived from a real login and refreshed when it lapses, and demo versus live is a flag on the same messages.

# Illustrative. Frame shapes confirmed against the open-source PyQuotex
# client and the live channel during the build.

# 1) Login derives the SSID session token (re-derived when it expires)
session = login(email, password)        # web login solved, SSID captured
ssid    = session["token"]

# 2) Open the trading socket and authorize the connection
ws = connect("wss://ws2.qxbroker.com/socket.io/?EIO=3&transport=websocket")
ws.send('42["authorization",{"session":"%s","isDemo":1}]' % ssid)

# 3) Read account state, then subscribe to a live instrument
ws.send('42["account/balance",{}]')
#   <- {"demo":10000.0,"live":0.0,"currency":"USD"}
ws.send('42["instruments/follow",{"asset":"EURUSD_otc"}]')   # quotes + payout %

# 4) Open a 60s digital option; reconcile on the expiry frame
ws.send('42["orders/open",{"asset":"EURUSD_otc","amount":1,'
        '"direction":"call","duration":60}]')
#   settlement on expiry -> {"id":..., "profit":0.92, "result":"win"}

# Error handling: missing/expired SSID -> re-run step 1; socket drop ->
# reconnect with backoff and re-send the authorization frame.
      

What lands at the end of the build

The deliverable is the working integration for this app, not advice about it. Concretely, for Quotex that means:

• Runnable client source (Python or Node.js) for the key surfaces: login/SSID handling, balance read, instrument subscription, order placement and the settlement callback, plus paged candle backfill.
• An OpenAPI/AsyncAPI-style spec describing the normalised surface we expose on top of the socket, so your side codes against stable shapes rather than raw frames.
• A protocol and auth-flow report: the login-to-SSID chain, the authorization frame, reconnection and token-refresh behaviour, and the demo/live flag.
• Automated tests against recorded frames so a schema change is caught as a failing test, not a wrong number in production.
• Interface documentation and data-retention guidance covering what is logged, what is kept, and how consent is recorded.

Latency, reconnection and backfill

A few properties of this feed shape how the client is built. Quotes are sub-second and continuous, so the subscription has to survive reconnects without gapping the series. Payout percentages move with the asset and the time of day, so we snapshot the payout at order time rather than read it later. Candle history is paged: a deep backfill walks the history endpoint in windows and stitches the result, and we de-duplicate at the boundaries. The settlement frame, not the quote stream, is the source of truth for a trade's outcome.

Engineering details we account for

Two things about Quotex specifically get handled inside the build rather than handed back to you as homework.

• Demo and live share a pipe. Both balances and both kinds of trade ride the same socket with the same method shape, separated only by a flag. We tag every record with the account mode at capture time, so the advertised $10,000 practice balance can never be reconciled as real money and demo trades can be filtered out of any report.
• The front end is a moving target. The web client and the frame schema change without announcement. We keep a re-validation step in the maintenance plan that diffs live frames against the mapped schema and fails loudly, and we re-derive the SSID through the login flow instead of assuming a long-lived token — so an expired session reconnects rather than silently returning stale data.

Access to a consenting account or a test login is arranged with you during onboarding; it is part of how we run the work, not a gate you have to pass first.

Authorization and the regulatory picture

Quotex is not a bank and sits outside any open-banking or account-aggregation regime, so there is no AIS consent flow to ride. The dependable basis is simpler and stated plainly: the account holder authorises access to their own data, and we work only within that. Per published regulator notices, the brand is operated by offshore-registered entities — Awesomo Ltd in Seychelles is named in the Portuguese (CMVM) and Spanish (CNMV) warnings — and it is not authorised by a tier-one regulator such as the FCA or CySEC. Several EU authorities, including CMVM, CNMV and CONSOB, have warned that it is not authorised to offer services in their markets. That status does not change what we build, but it is why the integration leans on the user's consent rather than a regulatory mandate, and why we keep access logged, consent recorded, personal data minimised, and an NDA in place where the client wants one. GDPR handling applies where the user is in the EU.

Working with us, and what it costs

Source for the Quotex socket client starts at $300, billed only after we hand it over and you have run it against your own account — if it does not do what the brief said, you do not pay. The alternative is a hosted endpoint: we run the integration and you call it, paying per call with nothing upfront, which suits teams that would rather not maintain a client against a moving front end. Either way the cycle is one to two weeks from the moment we have the app name and what you want out of it. Tell us which surfaces matter — balance only, full trade history, the live feed — at /contact.html and we will scope it.

Screens from the app

Store screenshots, useful for orienting the data surfaces against what a user sees. Click to enlarge.

Comparable platforms an aggregator would also map

If you are integrating Quotex you are usually integrating more than one of these. Each holds the same shape of per-account data — balances, positions, payouts, quote history — so a unified client can normalise them onto one schema.

• Pocket Option — fixed-time options with social and copy trading; per-account balances, trades and a low $5 minimum.
• IQ Option — CySEC-regulated multi-asset broker (forex, stocks, crypto); richer account and order data behind login.
• Olymp Trade — fixed-time trades and CFDs; balance, position and instrument data per account.
• Binomo — beginner-focused binary options; demo and live balances, trade history.
• ExpertOption — digital options with a similar live-quote and trade-record surface.
• IQcent — binary options and copy trading; per-account positions and payouts.
• Nadex — US, CFTC-regulated binary exchange; order book and contract data under an exchange model.

How this mapping was put together

Compiled on 2026-06-23 from the app's own store description, the open-source socket clients that already talk to the platform, and published regulator notices. Sources opened for this page are linked below.

• Quotex general FAQ (platform behaviour, accounts)
• PyQuotex — open-source WebSocket client (method names, session model)
• CMVM (Portugal) warning on Quotex/Awesomo Ltd
• CNMV (Spain) investor warning coverage

OpenBanking Studio integration desk · socket mapping, June 2026.

Questions integrators ask about Quotex

Can you keep demo-account activity separate from a live Quotex balance?

Yes. Demo and live balances travel over the same socket with the same method shape, so every record we pull is tagged with the account mode. The advertised $10,000 practice balance never lands in the same column as real funds, and reports can include or exclude demo trades on demand.

How do you handle the live quote stream versus closed-trade history?

They are two different surfaces and we treat them that way. Quotes and payout percentages arrive as a continuous subscription, while a position only resolves to win, loss or refund on expiry. We separate the streaming feed from the settle-on-expiry callback, and pull historical OHLC candles through a paged backfill so charts and backtests line up with what actually settled.

Quotex is not covered by a tier-one regulator — what does the integration rely on for authorization?

The basis is the account holder's own authorization to their own data, not an open-banking mandate. Quotex is offshore-registered and several EU regulators have published warnings about it, so no AIS or consent scheme applies. We work against a consenting account, log what we touch, minimise the personal data we retain, and apply GDPR handling where the user sits in the EU.

What happens to the delivered client when Quotex changes its socket frames?

The web front end and the frame schema shift without notice, so a renamed field can quietly corrupt candles or balances. We keep a re-validation step in the maintenance plan that compares live frames against the mapped schema and fails loudly instead of silently, and we re-derive the SSID session through the login flow rather than assume a long-lived token.