Binomo + Python

Binomo API in Python — Does It Exist & How to Automate

Want to use the Binomo API with Python to read candles and send orders? The honest answer: Binomo has no official API — only unofficial community libraries exist (like BinomoAPI projects on GitHub), and they are unstable. Below is the real picture, plus a free open-source bot that's far more stable for Quotex and IQ Option.

🤖 Get the free bot (API ready)

Open-source Python bot for Quotex and IQ Option. Edit it with ChatGPT/Claude — no coding. Free, no spam.

Does Binomo have an official API?

No. Binomo does not publish an official public API for developers. What exists are unofficial community libraries that talk to the platform by mimicking the web app. They sometimes work, but break when Binomo updates, may violate the terms and put your account at risk of being blocked. That's why automating Binomo is fragile — and why we recommend platforms with a more stable connection.

What you can (and can't) do with the Binomo API

Read candles (unstable)

Check balance (demo/real)

Send orders (risky)

No official support

What an unofficial lib looks like in Python

Community libs follow a pattern similar to this (illustrative — may break on any update):

# UNOFFICIAL community library — use at your own risk
from binomoapi import BinomoAPI

api = BinomoAPI(email="you@email.com", password="yourpassword")
api.connect()
balance = api.get_balance()               # start on demo
candles = api.get_candles("EURUSD", 60)
# sending an order is the riskiest, most unstable part
api.buy("EURUSD", amount=1, direction="call", duration=60)

Note: none of this is supported by Binomo. Turning it into a safe strategy (risk management, payout filter, stop) is hard — and unstable on a broker with no official API.

Why Binomo has no official API — and what its terms say

An official API means public documentation, tokens you generate in your own account, versioning and a changelog. Binomo offers none of that, and it says why. Its help center answers the question “Can I use bots for trading?” directly: “Our platform is created to be used by people, and any type of trading software violates the principles of honesty, fairness, and reliability” (Binomo help center).

The Binomo Client Agreement (operator Dolphin Corp LLC, Saint Vincent and the Grenadines, as checked in September 2026) turns that into contract terms:

Clause 12.12: profits made with trading bots, artificial intelligence or specialized software “not directly approved by the Company” are not the company's responsibility “and are not paid to the Client”.
Clause 12.13: if the client breaks the agreement, the company can terminate it without notice, deduct from the account the profits generated through the violation and refuse to register that client again.

So the real question is not only “can I make a Binomo bot work?” but “will Binomo pay if it works?”. Under clause 12.12, a winning bot is precisely the case in which the profit can be withheld.

What an unofficial “Binomo API” actually does

Every Binomo library on GitHub is the result of reverse engineering the web front-end. The recipe is always the same:

Open the Binomo web platform with the browser's DevTools on the Network → WS tab and watch the WebSocket frames while you switch assets and open a trade.
Copy the login flow: an HTTP request with e-mail and password that returns an authentication token. The ChipaDevTeam/BinomoAPI project, for example, calls login(email, password) to obtain an authtoken and also sends a device ID.
Open the same WebSocket with that token and replay the JSON messages the front-end sends: subscribe to quotes, request candle history, open a deal.
Wrap it all in Python functions such as get_candles() or buy() — which is what the illustrative example above imitates.

Nothing in this chain is a contract. The message names, the fields, the endpoint and any anti-automation check belong to Binomo's front-end and can change with any deploy. The library only finds out when it stops working.

Concrete risks, one by one

Risk	What happens	How you notice
Breakage after an update	A field is renamed or the WebSocket address changes; the library connects but receives no candles, or orders are rejected	“Connection closed” errors, empty candle lists, a burst of new GitHub issues in the same week
Silently wrong data	Candles arrive with shifted timestamps or an unfinished last candle, and the strategy reads a signal that isn't on the chart	Signals in your log don't match what the platform shows
Profit withheld, account closed	Clauses 12.12 and 12.13 of the Client Agreement	Withdrawal on hold, account review, termination
Credential leak	Your password passes through third-party code; a malicious fork can send it anywhere	Usually you don't — which is why the checklist below exists
Duplicated or orphan orders	After a timeout the library retries and the trade opens twice, or an order is sent and never confirmed	Balance in the platform doesn't match the bot's log

How to vet a GitHub repository before you run it

If you still want to study one of these libraries — ideally only to read data on a demo account — spend 15 minutes on this list before any pip install:

Last commit and archive status. Run git log -1 --format=%cd or look at the top of the repository page. For a reverse-engineered protocol, several months without commits usually means it is broken. Look for the “archived” banner too: even Deriv's official Python bindings (deriv-com/python-deriv-api) were archived in March 2026.
Open issues. Search the issues for “login”, “websocket” and “not working”. If the newest ones are unanswered complaints, you have your answer.
Where your password goes. grep -rnE "https?://|wss?://" . lists every address in the code. The only domains should be the broker's. A webhook, Telegram or Discord URL, a paste site or a bare IP address is a hard stop.
Obfuscation. grep -rnE "exec\(|eval\(|base64|marshal" . — a legitimate API wrapper has no reason to execute encoded strings. Reject projects that ship only .pyc or .exe files.
Dependencies. Read requirements.txt. Expect well-known packages such as requests, websocket-client or websockets, and check the spelling of each one: typosquatted look-alikes do get published on PyPI. Install inside a virtual environment and run pip-audit to list known vulnerabilities.
License and author. No license means no permission to reuse the code. A brand-new account with one repository promising a “90% win rate” is marketing, not engineering.
Isolation. Demo account only, a password you use nowhere else, and read-only calls (candles, balance) before anything that trades.

A safe Python skeleton: candles in, signal out

The part of a bot you can actually test and improve has nothing to do with the broker. The skeleton below reads M1 candles from a CSV file (columns time,open,high,low,close), calculates Bollinger Bands (20, 2) and RSI (14), and prints CALL, PUT or “no trade”. It uses only Python's standard library, contains no login and sends no orders.

# signal_skeleton.py — reads M1 candles from a CSV and prints a signal
# No broker login, no credentials, no orders.
import csv
import statistics

def load_closes(path):
    with open(path, newline="") as f:
        return [float(row["close"]) for row in csv.DictReader(f)]

def rsi(closes, n=14):
    diffs = [b - a for a, b in zip(closes[-n - 1:-1], closes[-n:])]
    gains = sum(d for d in diffs if d > 0)
    losses = -sum(d for d in diffs if d < 0)
    if losses == 0:
        return 100.0
    return 100 - 100 / (1 + gains / losses)

def bollinger(closes, n=20, k=2.0):
    window = closes[-n:]
    mid = statistics.fmean(window)
    sd = statistics.pstdev(window)
    return mid - k * sd, mid + k * sd

def signal(closes):
    if len(closes) < 21:
        return None                      # not enough candles
    lower, upper = bollinger(closes)
    r = rsi(closes)
    if closes[-1] > upper and r > 70:
        return "PUT"                     # above the upper band + overbought
    if closes[-1] < lower and r < 30:
        return "CALL"                    # below the lower band + oversold
    return None

if __name__ == "__main__":
    closes = load_closes("candles_EURUSD_M1.csv")
    print(signal(closes) or "no trade")

To try it, export candles from a source you trust (the site's study used the Deriv feed), save them as candles_EURUSD_M1.csv and run python signal_skeleton.py. The rule is a simplified version of the Bollinger + RSI reversal idea behind Double Reversal, which reached ~57–61% out-of-sample in our strategy tests. The simplified code is not that result — test it yourself. The RSI here uses simple averages instead of Wilder's smoothing, so values differ slightly from charting platforms.

Before any signal matters it has to beat the break-even, 1 / (1 + payout): 55.6% wins at 80% payout, 58.8% at 70%. With 57% wins at 80% payout the expectancy is 0.57 × 0.80 − 0.43 = +$0.026 per $1 staked; the same 57% at 70% payout gives −$0.031. The IaTraderPro Bot ships simular_csv.py for exactly this kind of CSV backtest.

Alternatives with a more mature API

Broker	Official API?	How the bot connects	Status in the IaTraderPro Bot
Deriv	Yes — public documentation, app ID and token	Official Options API	Works (demo and real)
Quotex	No	Community library (pyquotex)	Works (demo and real)
IQ Option	No	Community library (iqoptionapi)	Works (demo and real)
Olymp Trade	No	—	Basic
Binomo	No	—	Not supported

Deriv is the only broker in this table with documented, official access: you register an app, generate a token with the scopes you need and connect to a documented WebSocket (Deriv API documentation). Quotex and IQ Option have no official API either — the bot reaches them through community libraries, so the breakage risk described above applies to them as well; read their terms and start on demo. Details: Deriv bot · Quotex API in Python · IQ Option API in Python · Olymp Trade bot.

Better path: ready-made bot for Quotex and IQ Option

Instead of fighting an unofficial Binomo API, download the IaTraderPro Bot: open source, with 13 ready strategies, a Streamlit dashboard, payout filter, stop loss/win and martingale — running far more stably on Quotex and IQ Option.

→ Quotex bot & API · → IQ Option bot & API · → Binomo guide (is it reliable, withdrawals)

Frequently asked questions

Does Binomo have an official API? No — only unofficial community libs.
What's the Binomo minimum deposit? Around US$10; the demo is free.
Can my account be banned? Yes, unofficial automation carries that risk — always test on demo.
Is the bot free? Yes, open source and free for Quotex and IQ Option.

⚠️ Binary options involve high risk and can lead to total loss. Educational content, not investment advice. No bot guarantees profit. Always test on a demo account first.