How to Build an AI Trading Bot with Claude and the EODHD API

Setting up

You’ll need two API keys: one from EODHD, one from Anthropic.

pip install requests anthropic python-dotenv

Store your keys in a .env file:

EODHD_API_KEY=your_eodhd_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Step 1: Pull market data from EODHD

Start with a function that grabs recent price history and a live quote for a given ticker.

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,
    }

This gives you a clean payload: current price, percentage change, volume, and 30 days of history. No scraping, no broken HTML selectors.

Step 2: Ask Claude to reason over the data

This is the part that separates it from a rule-based bot. Instead of hardcoding thresholds, you hand Claude the data and ask for a structured judgment call.

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)

The key detail here is the response format. Asking for structured JSON, not a paragraph, is what makes this usable in an actual pipeline instead of a chat window.

Step 3: Wire it together

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")

Sample output:

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.

That reasoning field is the whole point. You get a decision plus the logic behind it, which you can log, review, and adjust over time. A rule-based bot never gives you that.

Testing it without risking real money

Before connecting this to anything resembling a real account, run it against a paper trading environment.

Alpaca is a solid option here. Its paper trading API mirrors the live trading endpoints exactly, so you can route Claude’s decisions through simulated buy and sell orders and see how the strategy would have performed, with fake money and real market conditions.

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}.")

Run execute_paper_trade after get_trading_decision and you have a full loop: EODHD for data, Claude for reasoning, Alpaca for execution, all without a single dollar at risk.

This is also where you’d start tracking accuracy. Log every decision, compare it against what actually happened three or five days later, and you’ll quickly see whether the reasoning holds up or needs a better prompt.

From here you can build:

• a scheduler that runs this analysis daily across a watchlist
• a logging layer that scores decisions against actual outcomes
• a risk filter that blocks trades below a confidence threshold

Key takeaways

An LLM adds contextual reasoning that fixed rules can’t replicate on their own.

Clean, reliable market data matters more than people expect. Claude is only as good as what you feed it, and EODHD removes the guesswork of scraping or rate-limited free APIs.

This is a starting point, not a production system. Position sizing, stop losses, and proper risk management live outside the scope of this tutorial, and skipping them before going live is how paper gains turn into real losses.

FAQs

❓ Do I need trading experience to build this?
✅ No. You need basic Python and an understanding of what a buy, hold, or sell decision means. The reasoning comes from Claude, not from you having to encode strategy logic manually.

❓ Is this real algorithmic trading?
✅ It’s a form of it, specifically an LLM-assisted decision layer rather than a pure quantitative model. Traditional algo trading uses fixed mathematical rules; this approach adds a reasoning step on top of the data.

❓ Can I connect this to a real brokerage account?
✅ Technically yes, since Alpaca’s live and paper APIs share the same structure. Don’t, until you’ve backtested extensively and added proper risk controls. This tutorial is educational, not a plug-and-play trading system.

❓ Does EODHD provide real-time data or only end-of-day?
✅ Both. EODHD offers end-of-day historical data going back years, plus real-time and delayed quotes depending on your plan, which is why it works for both the historical context and the live price checks in this tutorial.

If you’re a software or API company looking to explain your product through high-quality educational content, not marketing fluff, feel free to connect with me on LinkedIn: Kevin Meneses González

Building something with market data?
EODHD gives you 30+ years of historical data, real-time quotes, and fundamentals in one API.
Start free with EODHD →

More tutorials like this
I write about fintech APIs, Python, and AI agents every week.
Read more on kevinmeneses.com →

Looking for technical content for your company? I can help — LinkedIn · kevinmenesesgonzalez@gmail.com