IQ Option + Python

API IQ Option com Python (iqoptionapi) — Conectar, Operar e check_win

Como conectar na IQ Option pelo Python usando a biblioteca da comunidade iqoptionapi: logar, ler velas, enviar ordens e ler o resultado com check_win_v4. E um bot open source grátis que já faz tudo isso.

🤖 Receba o bot IQ Option grátis (API pronta)

Bot Python open source usando iqoptionapi. Você edita conversando com ChatGPT/Claude — sem programar. Grátis, sem spam.

A IQ Option tem API oficial?

Não. A IQ Option não tem API pública oficial. A comunidade usa a biblioteca open source iqoptionapi, que fala com o mesmo WebSocket da plataforma. É não-oficial — use conta demo (practice) e saiba do risco de banimento em conta real.

Como instalar a iqoptionapi do jeito certo (ambiente virtual)

O motivo mais comum de o exemplo acima falhar é a instalação. pip install iqoptionapi baixa o pacote com esse nome no PyPI, que é a versão 0.5, publicada em outubro de 2016. Essa versão não tem o módulo stable_api, então from iqoptionapi.stable_api import IQ_Option quebra com ModuleNotFoundError. O código da comunidade que tem check_win_v4 é mantido no GitHub e precisa ser instalado de lá:

Crie um ambiente isolado na pasta do projeto: python -m venv .venv
Ative: .venv\Scripts\activate no Windows, source .venv/bin/activate no Linux/macOS.
Se instalou o pacote antigo, remova: pip uninstall iqoptionapi
Instale do GitHub via HTTPS: pip install -U git+https://github.com/iqoptionapi/iqoptionapi.git (precisa do Git). Sem Git, use o link ZIP que o README do projeto indica: pip install -U https://github.com/iqoptionapi/iqoptionapi/archive/refs/heads/master.zip
Teste o import: python -c "from iqoptionapi.stable_api import IQ_Option" — se não aparecer nada, funcionou.

Por que ambiente virtual: a biblioteca fixa websocket-client==0.56, uma versão bem antiga. Dentro do .venv essa trava não quebra outros projetos Python da mesma máquina. E ignore o comando git+git:// que ainda aparece no README: o GitHub desativou de vez o protocolo git:// sem criptografia em 15 de março de 2022, então só a forma https:// funciona.

Conectar com Python — exemplo mínimo

Logar, ler velas, comprar e ler o resultado com check_win_v4:

# pip install -U git+https://github.com/iqoptionapi/iqoptionapi.git  (NÃO o pacote do PyPI — veja a seção de instalação)
import time
from iqoptionapi.stable_api import IQ_Option

api = IQ_Option("voce@email.com", "suasenha")
api.connect()
api.change_balance("PRACTICE")               # sempre demo primeiro
velas = api.get_candles("EURUSD", 60, 100, time.time())
ok, order_id = api.buy(1, "EURUSD", "call", 1)   # 1 = expiração de 1 min
resultado, lucro = api.check_win_v4(order_id)  # ("win" | "loose" | "equal", lucro)

check_win_v4 retorna uma tupla: o status em texto — "win", "loose" (grafia da própria biblioteca) ou "equal" — e o lucro em número (ganho líquido no win, menos o valor da entrada no loss, 0 no empate). Só funciona para opções binárias/turbo e espera o resultado sem limite de tempo.

Métodos úteis do iqoptionapi

connect() / change_balance()

get_candles()

buy() / buy_digital_spot()

check_win_v4() / get_balance()

O que cada chamada retorna de verdade (conferido no código stable_api.py da versão do GitHub, 7.1.1):

Método	O que faz	Retorno / cuidado
`connect()`	Faz login e abre o WebSocket	`(True, None)` se deu certo, `(False, motivo)` se falhou, `(False, "2FA")` quando pede código por SMS
`connect_2fa(codigo)`	Conclui o login com o código do SMS	Mesma tupla do `connect()`
`change_balance(modo)`	Escolhe a conta: `"PRACTICE"`, `"REAL"` ou `"TOURNAMENT"`	Qualquer outro texto (ex.: `"DEMO"`) registra erro e chama `exit(1)` — o script simplesmente para
`get_balance()`	Saldo da conta selecionada	Um número
`get_candles(ativo, intervalo, qtd, fim)`	Histórico; `intervalo` em segundos (60 = M1), `fim` em timestamp Unix	Lista de dicionários de vela (`"from"` = início da vela). Ativo desconhecido imprime `Asset … not found on consts`
`get_all_open_time()`	Quais ativos estão abertos agora	Dicionário aninhado: `[tipo][ativo]["open"]` = True/False, tipo como `"turbo"`, `"binary"`, `"digital"`
`get_all_profit()`	Payout por ativo	Frações: `{"turbo": 0.85, ...}` significa 85%
`buy(valor, ativo, "call"/"put", minutos)`	Abre uma opção binária/turbo	`(True, order_id)` ou `(False, mensagem)`; após 5 s sem confirmação registra `buy late 5 sec` e retorna `(False, None)`
`check_win_v4(order_id)`	Espera a ordem fechar	`("win" \| "loose" \| "equal", lucro)` — trava sem timeout; só binária/turbo
`buy_digital_spot()` / `check_win_digital_v2()`	Equivalentes para opções digitais	Use estes em ordens digitais; o `check_win_v4` nunca retorna para elas
`check_connect()`	O WebSocket está vivo?	`False` quando o socket caiu

Erros comuns e como resolver

Sintoma	Causa provável	Solução
`ModuleNotFoundError: No module named 'iqoptionapi.stable_api'`	Está instalado o pacote do PyPI de 2016 (0.5)	`pip uninstall iqoptionapi` e instale pelo GitHub como mostrado acima
pip falha numa URL `git+git://`	O GitHub não aceita mais git://	Use `git+https://`
O import funciona num terminal e não em outro	O pip instalou em outro Python, não no que roda o script	Ative o venv e use `python -m pip install ...`; confira `python --version` (README da biblioteca: 3.7+; nosso bot: 3.12+)
`connect()` retorna `(False, motivo)`	E-mail/senha errados ou login bloqueado	Imprima o `motivo`; entre uma vez pelo navegador com os mesmos dados
`motivo == "2FA"`	Login em dois fatores por SMS ativado	`api.connect_2fa(input("Código SMS: "))`
O script fecha logo depois do `change_balance`	Modo diferente de PRACTICE/REAL/TOURNAMENT	Use exatamente `"PRACTICE"`
`Asset EURUSD-op not found on consts`	Ativo ausente em `constants.ACTIVES`	Injete o ID (veja a seção "-op" abaixo) ou use um nome da lista
`check_win_v4` nunca retorna	Ordem digital, ou o WebSocket caiu antes do resultado	Use `check_win_digital_v2` na digital; monitore `check_connect()`
`check_connect()` vira `False` depois de horas	Queda de rede ou sessão expirada	Chame `api.connect()` de novo e repita `change_balance("PRACTICE")` antes da próxima ordem

Confira o payout antes de cada ordem (a conta)

O get_all_profit() devolve o payout em fração, e esse número define a taxa de acerto mínima: acerto de equilíbrio = 1 / (1 + payout). Resultado esperado por R$ 1 operado = p × payout − (1 − p), onde p é sua taxa de acerto.

Payout	Acerto de equilíbrio	Resultado por R$ 1 com 56% de acerto
0,90 (90%)	52,6%	+R$ 0,064
0,85 (85%)	54,1%	+R$ 0,036
0,80 (80%)	55,6%	+R$ 0,008
0,70 (70%)	58,8%	−R$ 0,048

A mesma taxa de 56% passa de um lucro pequeno para prejuízo constante só porque o payout caiu de 85% para 70%. No nosso teste com velas M1 reais de forex, as melhores estratégias ficaram em ~57–61% fora da amostra e nada chegou perto de 70% (resultados completos); nos ativos OTC o resultado foi estatisticamente aleatório, ~50% (por que o OTC é aleatório). Por isso o bot deve pular qualquer ativo cujo payout coloque o equilíbrio acima do que a estratégia mostrou na demo.

Boas práticas antes de automatizar

Senha fora do código: leia de variáveis de ambiente — IQ_Option(os.environ["IQ_EMAIL"], os.environ["IQ_PASSWORD"]) — e nunca suba para o GitHub um arquivo com credenciais.
Não digite sua senha em .exe fechado ou "site de robô": o próprio README da biblioteca alerta que golpistas já roubaram senhas da IQ Option assim. Código aberto roda no seu PC e você consegue ler o que ele faz com a senha.
PRACTICE como padrão: chame change_balance("PRACTICE") ao iniciar e só mude para "REAL" por uma configuração explícita, nunca como padrão.
Confira antes de comprar: get_all_open_time() para o ativo, get_all_profit() para o payout, depois buy().
Uma leitura de velas por vela fechada basta para estratégias M1; um loop sem pausa só baixa os mesmos dados de novo.
Registre cada order_id com o resultado do check_win_v4, para comparar sua taxa real de acerto com a tabela de equilíbrio acima.

Pule a configuração: pegue o bot pronto

O IaTraderPro Bot já usa o iqoptionapi e adiciona 13 estratégias prontas, painel visual Streamlit, filtro de payout, stop loss/win diário e martingale configurável — open source, você lê e altera o código. Funciona na IQ Option em conta demo (PRACTICE) e real — comece sempre pela demo.

Altere com IA — sem programar

Cole o bot.py no ChatGPT ou Claude, descreva a estratégia que quer, receba o código pronto. Cola, testa na demo e pronto.

Perguntas frequentes

É oficial? Não — biblioteca da comunidade. Teste na demo primeiro.
O que faz o check_win_v4? Espera uma ordem binária/turbo fechar e retorna a tupla (status, lucro).
Risco de banir a conta? Automação tem risco em conta real; teste na demo e leia os termos.
É grátis? Sim — o bot é grátis e open source. Também suporta Quotex.

Forex REAL na IQ Option: os ativos "-op" (descoberta 2026)

A API antiga da IQ Option parecia morta para forex real: turbo/binárias só em OTC e digitais desativadas. Mas em 2026 a IQ lançou os ativos com sufixo -op (ex.: USDJPY-op, EURUSD-op) — forex real em opção binária, com expirações de 2 a 15 minutos.

O detalhe técnico: a iqoptionapi não lista esses ativos porque eles não existem no constants.ACTIVES da biblioteca. A solução (que nosso bot já faz sozinho) é injetar os IDs dos "-op" no dicionário na inicialização. Duas observações práticas: contas verificadas têm acesso mais amplo aos "-op", e o payout deve ser lido com fallback (1 − comissão) quando a API não devolve o valor.

Como injetar os ativos "-op" (código que funciona)

A biblioteca traz um dicionário estático de ativos, então os instrumentos novos de forex real ficam invisíveis até você adicioná-los. Nosso bot faz isso na inicialização:

# Torna os ativos "-op" (forex real) visíveis para a iqoptionapi
from iqoptionapi import constants
from iqoptionapi.stable_api import IQ_Option

OP_ASSETS = {"USDJPY-op": 1807, "EURUSD-op": 1806, "GBPJPY-op": 1811}
constants.ACTIVES.update(OP_ASSETS)   # os IDs mudam por conta/região — leia pela API

api = IQ_Option("voce@email.com", "suasenha")
api.connect()
api.change_balance("PRACTICE")          # demo primeiro, sempre

# fallback de payout: alguns -op não retornam profit na chamada padrão
def payout(api, ativo):
    d = api.get_all_profit().get(ativo, {})
    p = d.get("binary") or d.get("turbo")
    return p   # None = payout não veio: pule o ativo (a iqoptionapi não tem método get_commission())

ok, ordem = api.buy(1, "USDJPY-op", "call", 15)   # binária de 15 min

Expiração	Disponibilidade	Observações
2 min	EURUSD-op e alguns majors	Mais rápida; não existe em todos os pares
5 / 10 min	Maioria dos -op	Formato blitz; a biblioteca não compra blitz direto
15 min	USDJPY-op, GBPJPY-op	Binária padrão — é a que nosso bot usa em produção

Duas observações de quem roda isso ao vivo: conta verificada tem acesso mais amplo à lista -op, e o conjunto de ativos muda por região — leia sempre a lista ao vivo em vez de fixar no código.

⚠️ Opções binárias envolvem alto risco e podem levar à perda total. Conteúdo educacional, não é recomendação de investimento. Nenhum bot garante lucro. Teste sempre em conta demo primeiro.