Bot de trading con IA usando Claude y la API de EODHD

Un bot de trading no necesita más reglas. Necesita razonamiento.

Eso es un tipo de sistema completamente distinto. En lugar de "si X entonces Y", quieres algo más parecido a "dado este dato, ¿qué concluiría un analista razonable, y por qué".

Los modelos de lenguaje grandes son buenos precisamente en ese tipo de juicio contextual, siempre que les des datos limpios y estructurados en lugar de pedirles que adivinen.

El stack

Este tutorial combina dos piezas:

la API de EODHD para los datos de mercado. Precios de cierre diario, cotizaciones en tiempo real, fundamentales y datos históricos a través de una sola interfaz REST, sin mantener scrapers que se rompen cada vez que una web cambia su HTML.

Claude para la capa de razonamiento. Dado un resumen del movimiento del precio, el volumen y los fundamentales básicos, Claude produce una decisión estructurada (comprar, mantener, vender) junto con el razonamiento detrás, en un formato que tu código puede parsear y sobre el que puede actuar.

Podrías cambiar cualquiera de las dos piezas. La idea no es "usa exactamente estas dos herramientas para siempre", sino mostrar cómo funciona el patrón para que lo adaptes.

¿Quieres datos de mercado fiables sin construir tu propia capa de scraping?
EODHD cubre más de 150.000 tickers con un plan gratuito generoso y sin sorpresas de límites de uso a mitad de proyecto.
Consigue tu API key gratuita de EODHD →

Preparando el entorno

Necesitarás dos API keys: una de EODHD, otra de Anthropic.

pip install requests anthropic python-dotenv

Guarda tus claves en un archivo .env:

EODHD_API_KEY=your_eodhd_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Paso 1: traer datos de mercado desde EODHD

Empieza con una función que obtiene el histórico reciente de precios y una cotización en vivo para un ticker dado.

import os
import requests
from dotenv import load_dotenv
load_dotenv()
EODHD_KEY = os.getenv("EODHD_API_KEY")
def get_market_data(ticker: str, exchange: str = "US"):
    symbol = f"{ticker}.{exchange}"
    # Last 30 days of end-of-day prices
    eod_url = f"https://eodhd.com/api/eod/{symbol}"
    eod_params = {
        "api_token": EODHD_KEY,
        "period": "d",
        "fmt": "json",
        "order": "d",
    }
    eod_resp = requests.get(eod_url, params=eod_params).json()[:30]
    # Live quote
    quote_url = f"https://eodhd.com/api/real-time/{symbol}"
    quote_params = {"api_token": EODHD_KEY, "fmt": "json"}
    quote_resp = requests.get(quote_url, params=quote_params).json()
    return {
        "ticker": ticker,
        "current_price": quote_resp.get("close"),
        "change_pct": quote_resp.get("change_p"),
        "volume": quote_resp.get("volume"),
        "recent_history": eod_resp,
    }

Esto te da un payload limpio: precio actual, variación porcentual, volumen y 30 días de histórico. Sin scraping, sin selectores de HTML rotos.

Paso 2: pedirle a Claude que razone sobre los datos

Esta es la parte que lo separa de un bot basado en reglas. En lugar de programar umbrales fijos, le pasas los datos a Claude y le pides un juicio estructurado.

import json
from anthropic import Anthropic
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
def get_trading_decision(market_data: dict) -> dict:
    prompt = f"""You are a trading analyst reviewing market data for {market_data['ticker']}.
Current price: {market_data['current_price']}
Change today: {market_data['change_pct']}%
Volume: {market_data['volume']}
Recent 30-day history: {json.dumps(market_data['recent_history'][:10])}
Based on this data, provide a trading decision. Respond ONLY with valid JSON in this exact format:
{{
  "decision": "buy" | "hold" | "sell",
  "confidence": 0.0 to 1.0,
  "reasoning": "2-3 sentence explanation grounded in the data provided"
}}"""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=300,
        messages=[{"role": "user", "content": prompt}],
    )
    raw_text = response.content[0].text.strip()
    return json.loads(raw_text)

El detalle clave aquí es el formato de la respuesta. Pedir JSON estructurado, no un párrafo, es lo que hace que esto sea utilizable en un pipeline real y no solo en una ventana de chat.

Paso 3: conectarlo todo

def run_analysis(ticker: str):
    data = get_market_data(ticker)
    decision = get_trading_decision(data)
print(f"\n{ticker} - Decision: {decision['decision'].upper()}")
    print(f"Confidence: {decision['confidence']}")
    print(f"Reasoning: {decision['reasoning']}")
    return decision

if __name__ == "__main__":
    run_analysis("AAPL")

Ejemplo de salida:

AAPL — Decision: HOLD
Confidence: 0.62
Reasoning: Price is up 0.8% on below-average volume, suggesting limited
conviction behind the move. Recent history shows consolidation rather than
a clear trend, so waiting for a volume-confirmed breakout makes more sense
than acting now.

Ese campo de razonamiento es todo el sentido de esto. Obtienes una decisión más la lógica detrás, que puedes registrar, revisar y ajustar con el tiempo. Un bot basado en reglas nunca te da eso.

Probarlo sin arriesgar dinero real

Antes de conectar esto a nada parecido a una cuenta real, ejecútalo contra un entorno de paper trading.

Alpaca es una buena opción aquí. Su API de paper trading refleja exactamente los endpoints de trading real, así que puedes enrutar las decisiones de Claude a través de órdenes simuladas de compra y venta y ver cómo habría rendido la estrategia, con dinero falso y condiciones de mercado reales.

import alpaca_trade_api as tradeapi
alpaca = tradeapi.REST(
    os.getenv("ALPACA_API_KEY"),
    os.getenv("ALPACA_SECRET_KEY"),
    "https://paper-api.alpaca.markets",
)
def execute_paper_trade(ticker: str, decision: dict):
    if decision["decision"] == "hold":
        print(f"No action for {ticker}, holding position.")
        return
    side = "buy" if decision["decision"] == "buy" else "sell"
    alpaca.submit_order(
        symbol=ticker,
        qty=1,
        side=side,
        type="market",
        time_in_force="day",
    )
    print(f"Paper {side} order submitted for {ticker}.")

Ejecuta execute_paper_trade después de get_trading_decision y tienes un bucle completo: EODHD para los datos, Claude para el razonamiento, Alpaca para la ejecución, todo sin arriesgar un solo euro.

Aquí es también donde empezarías a hacer seguimiento de la precisión. Registra cada decisión, compárala con lo que realmente pasó tres o cinco días después, y rápidamente verás si el razonamiento se sostiene o necesita un mejor prompt.

A partir de aquí puedes construir:

• un programador que ejecute este análisis a diario sobre una watchlist
• una capa de registro que puntúe las decisiones frente a los resultados reales
• un filtro de riesgo que bloquee operaciones por debajo de un umbral de confianza

Ideas clave

Un LLM añade un razonamiento contextual que las reglas fijas no pueden replicar por sí solas.

Tener datos de mercado limpios y fiables importa más de lo que la gente espera. Claude solo es tan bueno como los datos que le das, y EODHD elimina la incertidumbre del scraping o de las APIs gratuitas con límites de uso.

Esto es un punto de partida, no un sistema en producción. El dimensionamiento de posiciones, los stop losses y una gestión de riesgo adecuada quedan fuera del alcance de este tutorial, y saltárselos antes de operar en real es como las ganancias en papel se convierten en pérdidas reales.

Preguntas frecuentes

❓ ¿Necesito experiencia en trading para construir esto?
✅ No. Necesitas Python básico y entender qué significa una decisión de comprar, mantener o vender. El razonamiento viene de Claude, no de que tú tengas que codificar la lógica de la estrategia a mano.

❓ ¿Es esto trading algorítmico de verdad?
✅ Es una forma de ello, en concreto una capa de decisión asistida por LLM en lugar de un modelo puramente cuantitativo. El trading algorítmico tradicional usa reglas matemáticas fijas; este enfoque añade un paso de razonamiento encima de los datos.

❓ ¿Puedo conectar esto a una cuenta real de broker?
✅ Técnicamente sí, ya que las APIs real y de paper trading de Alpaca comparten la misma estructura. No lo hagas hasta que hayas hecho un backtesting exhaustivo y hayas añadido controles de riesgo adecuados. Este tutorial es educativo, no un sistema de trading listo para usar.

❓ ¿EODHD ofrece datos en tiempo real o solo de cierre diario?
✅ Ambos. EODHD ofrece datos históricos de cierre diario de varios años atrás, además de cotizaciones en tiempo real y con retraso según tu plan, por lo que funciona tanto para el contexto histórico como para las comprobaciones de precio en vivo de este tutorial.

Si trabajas en una empresa de software o de APIs y buscas explicar tu producto con contenido educativo de calidad, no marketing genérico, no dudes en escribirme por LinkedIn: Kevin Meneses González

¿Construyendo algo con datos de mercado?
EODHD te da más de 30 años de datos históricos, cotizaciones en tiempo real y fundamentales en una sola API.
Empieza gratis con EODHD →

Más tutoriales como este
Escribo sobre APIs fintech, Python y agentes de IA cada semana.
Lee más en kevinmeneses.com →

¿Buscas contenido técnico para tu empresa? Puedo ayudarte — LinkedIn · kevinmenesesgonzalez@gmail.com