Quotex + Python

API Quotex com Python — Conectar, Ler Velas e Automatizar

Quer conectar na Quotex pelo Python para ler preços e enviar ordens CALL/PUT automaticamente? Esta página explica como a API da Quotex funciona, mostra um exemplo mínimo em Python e te dá um bot open source grátis que já faz tudo isso — 13 estratégias e painel visual, sem programar.

🤖 Receba o bot Quotex grátis (API pronta)

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

A Quotex tem API oficial?

A Quotex não oferece uma API pública oficial. A comunidade conecta pelo mesmo WebSocket que a plataforma web usa, por bibliotecas Python open source (a mais conhecida é a pyquotex). Funciona, mas por ser não-oficial pode mudar sem aviso — use sempre em conta demo primeiro.

O que dá para fazer com a API da Quotex em Python

Ler velas ao vivo

Saldo e payout

Enviar ordens CALL/PUT

Como instalar a pyquotex (ela não está no PyPI)

É na busca por "pip install pyquotex" que a maioria trava: a biblioteca não é publicada no PyPI (em setembro de 2026 pypi.org/project/pyquotex retorna "not found"), então o pip responde No matching distribution found for pyquotex. A instalação é direto do repositório no GitHub, cujo pyproject.toml exige Python 3.12 ou mais novo:

Confira a versão: python --version precisa mostrar 3.12 ou superior (a mesma que o nosso bot usa).
Crie e ative um ambiente virtual: python -m venv .venv e depois .venv\Scripts\activate no Windows ou source .venv/bin/activate no Linux/macOS.
Instale do GitHub: pip install git+https://github.com/cleitonleonel/pyquotex.git (precisa do Git instalado). O README também documenta o Poetry: poetry add git+https://github.com/cleitonleonel/pyquotex.git.
Teste: python -c "from pyquotex.stable_api import Quotex" — se não aparecer nada, funcionou.

Todos os métodos são assíncronos: chame com await dentro de uma função async def iniciada por asyncio.run(), como nos exemplos desta página. Chamar client.connect() sem await só cria uma corrotina — nada conecta.

Conectar com Python — exemplo mínimo

Com a biblioteca pyquotex (já incluída no nosso bot), uma conexão mínima fica assim:

# pip install git+https://github.com/cleitonleonel/pyquotex.git  (não está no PyPI; Python 3.12+)
import time
from pyquotex.stable_api import Quotex
import asyncio

async def main():
    client = Quotex(email="voce@email.com", password="suasenha")
    client.account_is_demo = 1            # comece sempre na demo
    ok, motivo = await client.connect()
    velas = await client.get_candles("EURUSD_otc", time.time(), 3600, 60)  # última hora em M1
    status, ordem = await client.buy(1, "EURUSD_otc", "call", 60)
    await client.close()

asyncio.run(main())

Isso é a API crua. Transformar em estratégia segura e testável (sinais, controle de risco, filtro de payout, stop loss) é a parte difícil — que é exatamente o que o bot abaixo já faz.

Métodos da pyquotex que você vai usar de verdade

Assinaturas e retornos abaixo foram conferidos no código-fonte da biblioteca (versão 1.1.0, setembro de 2026):

Método	O que faz	Retorno / cuidado
`Quotex(email, password, host="qxbroker.com", lang="pt")`	Cria o cliente	Se o domínio padrão estiver bloqueado na sua região, o README lista alternativas para `host`: `quotex.com`, `qxbroker.io`, `quotex.io`
`set_account_mode("PRACTICE")`	Escolhe demo ou real antes de conectar	Só `"PRACTICE"` ou `"REAL"`; qualquer outro valor gera `ValueError`
`await connect()`	Faz login e abre o WebSocket	`(True, motivo)` ou `(False, motivo)`; o token da sessão fica salvo em `session.json`
`await change_account("PRACTICE")`	Troca demo/real depois de conectado	Nada
`await get_balance()`	Saldo da conta ativa	Um número; gera `RuntimeError` se não estiver conectado
`await get_candles(ativo, end_from_time, offset, period)`	Histórico de velas	Lista de dicionários (com `"close"`). `offset` são segundos de histórico: 100 velas M1 = `6000`
`await get_available_asset(ativo, force_open=True)`	Verifica se o ativo está aberto	`(nome, info)`; `info[2]` é True quando aberto. Com `force_open` ele troca para a versão `_otc` se a normal estiver fechada
`get_payout_by_asset(ativo)`	Payout para operações de 1 minuto (não é async)	Um percentual, ex.: `85`
`await buy(valor, ativo, "call"/"put", duracao)`	Envia a ordem; `duracao` em segundos	`(status, info)`; o ID da ordem é `info["id"]`
`await check_win(order_id, duracao)`	Espera o resultado	`("win" ou "loss", lucro)`. Espera até 300 s e, se estourar o tempo, retorna `("loss", 0.0)`
`await close()`	Fecha a conexão	Chame sempre no final

Esse último detalhe pesa nas estatísticas: um ("loss", 0.0) pode significar "sem resposta em 5 minutos", e não um loss real. Um loss de verdade vem com lucro negativo; quando vier exatamente 0.0, confirme o ticket com await client.get_result(order_id), que procura no histórico de operações.

Pule a configuração: pegue o bot pronto

Em vez de montar a API na mão, baixe o IaTraderPro Bot: ele já usa a API da Quotex e adiciona 13 estratégias prontas (EMA, RSI, Bollinger, MACD, ADX…), painel visual Streamlit, filtro de payout, stop loss/win diário e martingale configurável. Tudo open source — você lê e altera o código.

Altere com IA — sem programar

Cole o bot.py no ChatGPT ou Claude, descreva a estratégia que quer em português, e a IA devolve o código pronto. Você cola de volta, testa na demo e pronto. Essa é a real vantagem de um bot aberto sobre um bot "mágico" fechado.

Perguntas frequentes

É oficial? Não — usa a API WebSocket da comunidade. Teste na demo primeiro.
Minha conta pode ser banida? Automação tem risco em conta real; teste na demo e leia os termos da corretora.
É grátis? Sim — o bot é grátis e open source.
Funciona para IQ Option? Sim, o bot tem versão para IQ Option também.

Exemplo completo: bot de RSI em 30 linhas

O exemplo mínimo acima só conecta e envia uma ordem. Abaixo, um bot funcional de verdade: lê as últimas 100 velas, calcula o RSI e abre CALL em sobrevenda (RSI < 30) ou PUT em sobrecompra (RSI > 70), repetindo a cada minuto:

# Exemplo completo: estratégia RSI simples (educacional — rode na DEMO)
import asyncio, time
from pyquotex.stable_api import Quotex

ATIVO, VALOR, EXP = "EURUSD_otc", 1, 60

def rsi(fechamentos, periodo=14):
    ganhos = [max(fechamentos[i+1]-fechamentos[i], 0) for i in range(len(fechamentos)-1)]
    perdas = [max(fechamentos[i]-fechamentos[i+1], 0) for i in range(len(fechamentos)-1)]
    mg = sum(ganhos[-periodo:]) / periodo
    mp = sum(perdas[-periodo:]) / periodo or 1e-9
    return 100 - 100 / (1 + mg / mp)

async def main():
    client = Quotex(email="voce@email.com", password="suasenha")
    client.account_is_demo = 1                      # DEMO sempre primeiro
    ok, _ = await client.connect()
    while ok:
        velas = await client.get_candles(ATIVO, time.time(), 100 * 60, 60)  # 100 velas M1
        fech = [v["close"] for v in velas]
        r = rsi(fech)
        if r < 30:   # sobrevendido → CALL
            await client.buy(VALOR, ATIVO, "call", EXP)
        elif r > 70: # sobrecomprado → PUT
            await client.buy(VALOR, ATIVO, "put", EXP)
        await asyncio.sleep(60)

asyncio.run(main())

Esse é o esqueleto de qualquer bot para Quotex: ler velas → calcular indicador → decidir → enviar ordem. O que separa esse exemplo de um bot usável no dia a dia é a camada de proteção: stop loss/win diário, filtro de payout mínimo, limite de perdas seguidas e registro das operações — tudo que o IaTraderPro Bot já traz pronto.

Como a conexão funciona por dentro (WebSocket)

Entender o mecanismo ajuda a diagnosticar problemas. A plataforma web da Quotex conversa com os servidores por um canal WebSocket (wss://) — o mesmo que envia o gráfico em tempo real para o seu navegador. As bibliotecas Python fazem exatamente o que o navegador faz:

Login: autenticam com e-mail/senha e guardam os cookies de sessão (por isso a sessão expira e às vezes é preciso reconectar).
Assinatura de dados: pedem o fluxo de ticks/velas do ativo escolhido e recebem JSON contínuo com preço, hora e volume.
Ordens: enviar um CALL/PUT é mandar uma mensagem no mesmo canal com ativo, valor, direção e expiração; a corretora responde com o ID e depois com o resultado.
Keepalive: um ping periódico mantém o canal aberto — conexões instáveis derrubam o bot, por isso rede estável importa mais que CPU.

É também por isso que APIs não-oficiais quebram de tempos em tempos: quando a Quotex muda o protocolo interno, as bibliotecas precisam ser atualizadas. Prefira projetos ativos no GitHub e evite versões "congeladas" de cursos e grupos.

Erros comuns ao conectar (e como resolver)

“Connection failed” ou timeout — na maioria dos casos é sessão expirada. Apague a sessão salva da biblioteca (o arquivo session.json) e conecte de novo; confirme e-mail e senha entrando manualmente pelo navegador.

Erro de SSL/certificado — atualize o Python para 3.12+ e o pacote certifi (pip install -U certifi). Em redes corporativas, proxies podem bloquear o WebSocket.

Conta com 2FA/verificação — na primeira conexão a Quotex pode pedir código PIN enviado por e-mail. As bibliotecas atuais pedem o código no terminal; digite e a sessão fica salva.

“Asset is closed” — o ativo está fora do horário de pregão. Use os pares _otc no fim de semana e verifique o payout antes de operar (abaixo de 80% raramente compensa).

Ordem não executa — cheque o saldo da conta selecionada (demo × real) e o valor mínimo da ordem (US$1).

No matching distribution found for pyquotex — o pacote não está no PyPI; instale pelo GitHub (veja acima). requires a different Python significa Python mais antigo que 3.12.

Site ou WebSocket não abre no seu país — teste outro host da lista do README (quotex.com, qxbroker.io, quotex.io) ao criar o Quotex(...).

ValueError: Invalid balance mode — o set_account_mode() só aceita "PRACTICE" ou "REAL"; "DEMO" não vale.

2FA sem terminal (serviço ou painel Streamlit) — a biblioteca pede o PIN com input(), que trava para sempre quando ninguém está digitando. Passe on_otp_callback= com uma função que devolve o código, ou faça o primeiro login num terminal para criar o session.json.

Boas práticas de gerência de risco no bot

Demo primeiro, sempre: rode qualquer alteração pelo menos alguns dias em demo antes de pensar em conta real.
Stop diário: defina stop loss e stop win por dia (ex.: −5% / +10% da banca) — o bot para sozinho e você não devolve o lucro.
Entrada pequena: 1–2% da banca por operação; martingale multiplica ganhos e perdas.
Filtro de payout: só opere ativos pagando 80%+ — payout baixo destrói qualquer estratégia no longo prazo.
Registro: acompanhe as estatísticas no painel para saber qual estratégia funciona em qual horário.
Credenciais fora do código: leia e-mail e senha de variáveis de ambiente (os.environ["QX_EMAIL"]) e nunca suba o session.json para o GitHub — ele guarda o token do seu login.

Payout, OTC e expiração: os números antes de operar

O get_payout_by_asset() devolve um percentual. Converta e calcule o acerto necessário para empatar: acerto de equilíbrio = 1 / (1 + payout). Com 85% dá 54,1%; com 80%, 55,6%; com 70%, 58,8%. O resultado esperado por R$ 1 é p × payout − (1 − p).

Situação	Acerto	Payout	Resultado por R$ 1
Par OTC (aleatório no nosso teste)	~50%	85%	−R$ 0,075
Par de mercado real, estratégia boa	57%	85%	+R$ 0,055
Mesma estratégia, payout baixo	57%	70%	−R$ 0,031

Os exemplos desta página usam EURUSD_otc só porque o OTC abre no fim de semana e facilita o teste. No nosso estudo com velas reais, o OTC foi estatisticamente aleatório (~50%) — abaixo do equilíbrio em qualquer payout (detalhes). Dois outros resultados do mesmo estudo são fáceis de aplicar pela API: expiração de 2 velas superou 1 vela em cerca de 3 pontos (60,8% contra 57,5% na Exhaustion+Band), o que na pyquotex é buy(..., 120) no M1; e a vantagem se concentrou das 9–10h e das 18–23h (horário de Brasília), com a sexta-feira como pior dia (melhores horários, todas as estratégias testadas).

Perguntas frequentes sobre a API da Quotex

A API da Quotex é oficial?
Não. A Quotex não publica uma API oficial: a comunidade conecta pelo mesmo WebSocket da plataforma web, usando bibliotecas Python open source como a pyquotex.

Como usar a API da Quotex com Python?
Instale a biblioteca, conecte com e-mail e senha, leia as velas com get_candles e envie ordens CALL/PUT com buy. O exemplo completo de bot RSI está nesta página.

Existe documentação oficial da API da Quotex?
Não existe documentação oficial pública. O que existe é a documentação das bibliotecas da comunidade e o código aberto delas — por isso recomendamos projetos ativos no GitHub.

Dá para usar a API da Quotex de graça?
Sim. As bibliotecas são open source e o nosso bot também — não há custo de licença. O único requisito é ter uma conta na corretora (comece pela demo).

⚠️ 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.