Quotex + Python

API Quotex con Python — Conectar, Leer Velas y Automatizar

¿Quieres conectar a Quotex desde Python para leer precios y enviar órdenes CALL/PUT automáticamente? Esta página explica cómo funciona la API de Quotex, muestra un ejemplo mínimo en Python y te da un bot open source gratis que ya hace todo eso — 13 estrategias y panel visual, sin programar.

🤖 Recibe el bot Quotex gratis (API lista)

Bot Python open source usando la API de Quotex. Edítalo conversando con ChatGPT/Claude — sin programar. Gratis, sin spam.

¿Quotex tiene API oficial?

Quotex no ofrece una API pública oficial. La comunidad se conecta por el mismo WebSocket que usa la plataforma web, mediante librerías Python open source (la más conocida es pyquotex). Funciona, pero al ser no oficial puede cambiar sin aviso — usa siempre cuenta demo primero.

Qué puedes hacer con la API de Quotex en Python

Leer velas en vivo

Saldo y payout

Enviar órdenes CALL/PUT

Cómo instalar pyquotex (no está en PyPI)

Buscando "pip install pyquotex" es donde casi todos se traban: la librería no está publicada en PyPI (en septiembre de 2026 pypi.org/project/pyquotex devuelve "not found"), así que pip responde No matching distribution found for pyquotex. Se instala directo desde el repositorio en GitHub, cuyo pyproject.toml exige Python 3.12 o superior:

Revisa la versión: python --version debe mostrar 3.12 o más (la misma que usa nuestro bot).
Crea y activa un entorno virtual: python -m venv .venv y luego .venv\Scripts\activate en Windows o source .venv/bin/activate en Linux/macOS.
Instala desde GitHub: pip install git+https://github.com/cleitonleonel/pyquotex.git (necesitas Git instalado). El README también documenta Poetry: poetry add git+https://github.com/cleitonleonel/pyquotex.git.
Prueba: python -c "from pyquotex.stable_api import Quotex" — si no aparece nada, funcionó.

Todos los métodos son asíncronos: llámalos con await dentro de una función async def lanzada con asyncio.run(), como en los ejemplos de esta página. Llamar a client.connect() sin await solo crea una corrutina y no se conecta nada.

Conectar con Python — ejemplo mínimo

Con la librería pyquotex (ya incluida en nuestro bot), una conexión mínima se ve así:

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

async def main():
    client = Quotex(email="tu@email.com", password="tuclave")
    client.account_is_demo = 1            # empieza siempre en demo
    ok, motivo = await client.connect()
    velas = await client.get_candles("EURUSD_otc", time.time(), 3600, 60)  # última hora en M1
    status, orden = await client.buy(1, "EURUSD_otc", "call", 60)
    await client.close()

asyncio.run(main())

Eso es la API cruda. Convertirla en una estrategia segura y comprobable (señales, control de riesgo, filtro de payout, stop loss) es la parte difícil — que es justo lo que el bot de abajo ya hace.

Métodos de pyquotex que realmente vas a usar

Las firmas y valores de retorno se verificaron en el código fuente de la librería (versión 1.1.0, septiembre de 2026):

Método	Qué hace	Devuelve / cuidado
`Quotex(email, password, host="qxbroker.com", lang="pt")`	Crea el cliente	Si el dominio por defecto está bloqueado en tu país, el README lista alternativas para `host`: `quotex.com`, `qxbroker.io`, `quotex.io`
`set_account_mode("PRACTICE")`	Elige demo o real antes de conectar	Solo `"PRACTICE"` o `"REAL"`; cualquier otro valor lanza `ValueError`
`await connect()`	Inicia sesión y abre el WebSocket	`(True, motivo)` o `(False, motivo)`; el token de sesión queda guardado en `session.json`
`await change_account("PRACTICE")`	Cambia demo/real ya conectado	Nada
`await get_balance()`	Saldo de la cuenta activa	Un número; lanza `RuntimeError` si no hay conexión
`await get_candles(activo, end_from_time, offset, period)`	Historial de velas	Lista de diccionarios (con `"close"`). `offset` son segundos de historial: 100 velas M1 = `6000`
`await get_available_asset(activo, force_open=True)`	Revisa si el activo está abierto	`(nombre, info)`; `info[2]` es True cuando está abierto. Con `force_open` cambia a la versión `_otc` si la normal está cerrada
`get_payout_by_asset(activo)`	Payout para operaciones de 1 minuto (no es async)	Un porcentaje, ej.: `85`
`await buy(monto, activo, "call"/"put", duracion)`	Envía la orden; `duracion` en segundos	`(status, info)`; el ID de la orden es `info["id"]`
`await check_win(order_id, duracion)`	Espera el resultado	`("win" o "loss", ganancia)`. Espera hasta 300 s y, si se agota el tiempo, devuelve `("loss", 0.0)`
`await close()`	Cierra la conexión	Llámalo siempre al final

Ese último detalle afecta tus estadísticas: un ("loss", 0.0) puede significar "sin respuesta en 5 minutos" y no una pérdida real. Una pérdida real llega con ganancia negativa; cuando llegue exactamente 0.0, confirma el ticket con await client.get_result(order_id), que lo busca en el historial de operaciones.

Sáltate la configuración: usa el bot listo

En lugar de armar la API a mano, descarga el IaTraderPro Bot: ya usa la API de Quotex y añade 13 estrategias listas (EMA, RSI, Bollinger, MACD, ADX…), panel visual Streamlit, filtro de payout, stop loss/win diario y martingala configurable. Todo open source — lees y modificas el código.

Modifícalo con IA — sin programar

Pega bot.py en ChatGPT o Claude, describe la estrategia que quieres en español, y la IA te devuelve el código listo. Lo pegas de vuelta, pruebas en demo y listo. Esa es la ventaja real de un bot abierto frente a uno "mágico" cerrado.

Preguntas frecuentes

¿Es oficial? No — usa la API WebSocket de la comunidad. Prueba en demo primero.
¿Pueden banear mi cuenta? La automatización tiene riesgo en cuenta real; prueba en demo y lee los términos del bróker.
¿Es gratis? Sí — el bot es gratis y open source.
¿Funciona para IQ Option? Sí, el bot tiene versión para IQ Option también.

Ejemplo completo: un bot de RSI en 30 líneas

El ejemplo mínimo de arriba solo conecta y envía una orden. Abajo, un bot funcional de verdad: lee las últimas 100 velas, calcula el RSI y abre CALL en sobreventa (RSI < 30) o PUT en sobrecompra (RSI > 70), repitiendo cada minuto:

# Ejemplo completo: estrategia RSI simple (educativo — usa la DEMO)
import asyncio, time
from pyquotex.stable_api import Quotex

ASSET, AMOUNT, EXP = "EURUSD_otc", 1, 60

def rsi(closes, period=14):
    gains = [max(closes[i+1]-closes[i], 0) for i in range(len(closes)-1)]
    losses = [max(closes[i]-closes[i+1], 0) for i in range(len(closes)-1)]
    ag = sum(gains[-period:]) / period
    al = sum(losses[-period:]) / period or 1e-9
    return 100 - 100 / (1 + ag / al)

async def main():
    client = Quotex(email="you@email.com", password="yourpass")
    client.account_is_demo = 1                      # DEMO siempre primero
    ok, _ = await client.connect()
    while ok:
        candles = await client.get_candles(ASSET, time.time(), 100 * 60, 60)  # 100 velas M1
        closes = [c["close"] for c in candles]
        r = rsi(closes)
        if r < 30:   # sobreventa → CALL
            await client.buy(AMOUNT, ASSET, "call", EXP)
        elif r > 70: # sobrecompra → PUT
            await client.buy(AMOUNT, ASSET, "put", EXP)
        await asyncio.sleep(60)

asyncio.run(main())

Ese es el esqueleto de cualquier bot para Quotex: leer velas → calcular indicador → decidir → enviar orden. Lo que separa este ejemplo de un bot usable a diario es la capa de protección: stop loss/win diario, filtro de payout mínimo, límite de pérdidas seguidas y registro de operaciones — todo lo que el IaTraderPro Bot ya trae listo.

Cómo funciona la conexión por dentro (WebSocket)

Entender el mecanismo ayuda a diagnosticar problemas. La plataforma web de Quotex habla con sus servidores por un canal WebSocket (wss://) — el mismo que envía el gráfico en tiempo real a tu navegador. Las librerías de Python hacen exactamente lo que hace el navegador:

Login: se autentican con e-mail/contraseña y guardan las cookies de sesión (por eso la sesión expira y a veces hay que reconectar).
Suscripción de datos: piden el flujo de ticks/velas del activo elegido y reciben JSON continuo con precio, hora y volumen.
Órdenes: enviar un CALL/PUT es mandar un mensaje por el mismo canal con activo, monto, dirección y expiración; el bróker responde con el ID y luego el resultado.
Keepalive: un ping periódico mantiene el canal abierto — conexiones inestables tumban el bot; la red estable importa más que la CPU.

Por eso las APIs no oficiales se rompen de vez en cuando: cuando Quotex cambia su protocolo interno, hay que actualizar las librerías. Prefiere proyectos activos en GitHub y evita versiones "congeladas" de cursos y grupos.

Errores comunes al conectar (y cómo resolverlos)

“Connection failed” o timeout — casi siempre es sesión expirada. Borra la sesión guardada de la librería (el archivo session.json) y reconecta; confirma e-mail y contraseña entrando manualmente por el navegador.

Error de SSL/certificado — actualiza Python a 3.12+ y el paquete certifi (pip install -U certifi). En redes corporativas, los proxies pueden bloquear el WebSocket.

Cuenta con 2FA/verificación — en la primera conexión Quotex puede enviarte un PIN por e-mail. Las librerías actuales lo piden en la terminal; escríbelo una vez y la sesión queda guardada.

“Asset is closed” — el activo está fuera de horario. Usa los pares _otc el fin de semana y revisa el payout antes de operar (menos de 80% rara vez compensa).

La orden no se ejecuta — revisa el saldo de la cuenta seleccionada (demo vs real) y el monto mínimo de la orden (US$1).

No matching distribution found for pyquotex — el paquete no está en PyPI; instálalo desde GitHub (ver arriba). requires a different Python significa que tu Python es anterior a 3.12.

El sitio o el WebSocket no abre en tu país — prueba otro host de la lista del README (quotex.com, qxbroker.io, quotex.io) al crear Quotex(...).

ValueError: Invalid balance mode — set_account_mode() solo acepta "PRACTICE" o "REAL"; "DEMO" no es válido.

2FA sin terminal (un servicio o un panel Streamlit) — la librería pide el PIN con input(), que se queda esperando para siempre si nadie escribe. Pasa on_otp_callback= con una función que devuelva el código, o haz el primer login en una terminal para que se cree session.json.

Buenas prácticas de gestión de riesgo

Demo primero, siempre: ejecuta cualquier cambio al menos unos días en demo antes de pensar en cuenta real.
Stops diarios: define stop loss y stop win por día (ej.: −5% / +10% del capital) — el bot se detiene solo y no devuelves la ganancia.
Entrada pequeña: 1–2% del capital por operación; el martingale multiplica ganancias y pérdidas.
Filtro de payout: opera solo activos que paguen 80%+ — un payout bajo destruye cualquier estrategia a largo plazo.
Registro: sigue las estadísticas del panel para saber qué estrategia funciona en qué horario.
Credenciales fuera del código: lee correo y contraseña desde variables de entorno (os.environ["QX_EMAIL"]) y nunca subas session.json a GitHub — guarda el token de tu sesión.

Payout, OTC y expiración: los números antes de operar

get_payout_by_asset() devuelve un porcentaje. Conviértelo y calcula el acierto necesario para no perder: acierto de equilibrio = 1 / (1 + payout). Con 85% es 54,1%; con 80%, 55,6%; con 70%, 58,8%. El resultado esperado por cada $1 es p × payout − (1 − p).

Situación	Acierto	Payout	Resultado por $1
Par OTC (aleatorio en nuestra prueba)	~50%	85%	−$0,075
Par de mercado real, buena estrategia	57%	85%	+$0,055
Misma estrategia, payout bajo	57%	70%	−$0,031

Los ejemplos de esta página usan EURUSD_otc solo porque el OTC abre el fin de semana y facilita las pruebas. En nuestro estudio con velas reales, el OTC resultó estadísticamente aleatorio (~50%) — por debajo del equilibrio con cualquier payout (detalles). Otros dos resultados del mismo estudio se aplican fácil desde la API: una expiración de 2 velas superó a 1 vela por unos 3 puntos (60,8% frente a 57,5% en Exhaustion+Band), que en pyquotex es buy(..., 120) en M1; y la ventaja se concentró entre 9–10 h y 18–23 h (UTC−3), con el viernes como peor día (mejores horarios, todas las estrategias probadas).

⚠️ Las opciones binarias implican alto riesgo y pueden resultar en pérdida total. Contenido educativo, no es asesoramiento de inversión. Ningún bot garantiza ganancias. Prueba siempre en cuenta demo primero.