How I Automated My Investing Workflow with EODHD and Claude Cowork

I had trade history files from three different brokers.

None of them used the same format.
None of them included fundamentals.
And none of them talked to each other.

If you're:

tracking a portfolio across multiple brokers,
trying to analyze dividend income and position performance in one place,
or building a personal finance dashboard without a data engineering team,

this matters.

The Problem With Manual Portfolio Tracking

Every month, the process looked the same.

Export a CSV from Degiro. Download the transaction history from Interactive Brokers. Pull the trade log from Binance. Open three different spreadsheets, each with different column names, different date formats, different ticker conventions.

Then start cleaning.

Rename columns. Fix date formats. Remove duplicate headers. Reconcile tickers that one platform calls AAPL and another calls AAPL.US. Add a column for cost basis. Calculate unrealized P&L manually.

Two hours later, the data was usable — but already outdated.

And fundamental data? P/E ratio, dividend yield, EPS, earnings dates? The broker exports never included any of it. That required a separate lookup, one ticker at a time.

The data was never the problem.

The system connecting it was.

The Stack: Two Tools, One Workflow

I stopped trying to fix the spreadsheet. Instead, I rebuilt the workflow around two tools that handle the parts I was doing manually.

Claude Cowork handles the messy human layer — the files, the formats, the logic.

EODHD API handles the data layer — prices, fundamentals, historical records.

Here's how each one fits in.

Claude Cowork: From Chaos to Clean Data

Claude Cowork is Anthropic's desktop agent. It can read files on your machine, understand their structure, write code, and execute it — all in a single session.

I drop my broker export files into a folder. Cowork reads all three, identifies the schema of each one, normalizes column names, standardizes ticker formats, and merges everything into a single unified dataset. It also categorizes each operation by type: buy, sell, dividend, or fee.

No manual cleaning. No scripting beforehand. I describe what I want, and Cowork figures out how to get there — including writing and running the Python script that does the actual transformation.

What used to take two hours now takes under five minutes.

EODHD API: Enriching Every Position

Once the positions are clean, the script calls the EODHD API to enrich each holding with data the broker exports never provide.

For each ticker in the portfolio, the script pulls:

End-of-day price and historical performance
Fundamental data: P/E ratio, EPS, dividend yield, payout ratio
Company metadata: sector, market cap, exchange
Upcoming dividend dates and amounts

EODHD covers 70+ exchanges and 150,000+ tickers, with consistent JSON responses that integrate cleanly into Python. One API key, one endpoint structure, everything you need.

👉 Start with EODHD here

The Implementation: Step by Step

Step 1 — Drop Files Into Cowork

I place the raw broker exports in a local folder: degiro_trades.csv, ibkr_history.csv, binance_transactions.csv. Then I open Claude Cowork and describe the task:

"I have three broker export files with different formats. Normalize them into a single DataFrame with columns: date, ticker, operation, quantity, price, broker. Then save the result as unified_portfolio.csv."

Cowork reads each file, identifies the column structure, maps the fields, and generates the script. It runs it. If something breaks — a date parsing error, a ticker format mismatch — it fixes it on the spot.

The output is a clean, unified CSV with every trade I've ever made, across every broker, in one consistent format.

Step 2 — Enrich With EODHD

The next part of the script calls the EODHD API for each unique ticker in the portfolio.

import requests
import pandas as pd

API_KEY = "your_eodhd_api_key"

def get_fundamentals(ticker):
    url = f"https://eodhd.com/api/fundamentals/{ticker}?api_token={API_KEY}&fmt=json"
    response = requests.get(url)
    data = response.json()

    highlights = data.get("Highlights", {})
    return {
        "ticker": ticker,
        "pe_ratio": highlights.get("PERatio"),
        "eps": highlights.get("EarningsShare"),
        "dividend_yield": highlights.get("DividendYield"),
        "market_cap": highlights.get("MarketCapitalization"),
        "sector": data.get("General", {}).get("Sector"),
    }

# Load unified portfolio
portfolio = pd.read_csv("unified_portfolio.csv")
tickers = portfolio["ticker"].unique()

# Fetch fundamentals for each position
fundamentals = pd.DataFrame([get_fundamentals(t) for t in tickers])
enriched = portfolio.merge(fundamentals, on="ticker", how="left")
enriched.to_csv("enriched_portfolio.csv", index=False)

From here you can extend the script to pull:

Historical price series for performance attribution
Dividend payment history and forecast
Earnings dates for upcoming calendar alerts

Step 3 — Update the Dashboard

The enriched CSV feeds a local dashboard — built in Python with Plotly or any tool that reads a CSV. Every time I run the workflow, the dashboard reflects the current state of the portfolio with up-to-date fundamentals and prices.

No manual input. No open tabs. No Sunday night cleanup.

What the Dashboard Shows

Monday morning. One tab open.

Every position across Degiro, Interactive Brokers, and Binance — unified. Current price and daily change from EODHD. P/E ratio and dividend yield per holding. Cost basis versus current value. Unrealized P&L by position and by broker.

The kind of view that used to require a Bloomberg terminal or three hours of spreadsheet work.

Now it runs in minutes.

Key Takeaways

Claude Cowork handles the messy layer — different file formats, inconsistent schemas, logic that changes every time a broker updates their export. You don't write that script yourself. Cowork does.
EODHD handles the data layer — clean, consistent, production-grade financial data across every asset class, accessible through a single REST API.
Together they eliminate every manual step — the transformation, the enrichment, the update. The workflow runs without you.

Most investors don't need better instincts.

They need a better system.

Get Started With EODHD

If you want to build something similar, EODHD is where I'd start. The free tier gives you access to end-of-day data for US equities — enough to prototype the full workflow before committing to a paid plan.

👉 Start with EODHD here

You'll get access to:

End-of-day prices for 70+ exchanges and 150,000+ tickers
Full fundamental data: P/E, EPS, dividends, market cap, sector
Historical data going back 30+ years, delivered via clean JSON

The API is straightforward. The documentation is solid. And unlike scraping or unofficial endpoints, it doesn't break.

FAQs

❓ Do I need coding experience to use this workflow?
✅ Claude Cowork writes and runs the Python script for you. Basic familiarity with Python helps when customizing the output, but you don't need to write the script from scratch.

❓ What brokers does this work with?
✅ Any broker that lets you export a CSV transaction history. Degiro, Interactive Brokers, Binance, and most major European and US brokers support this. Cowork handles the format differences automatically.

❓ Is the EODHD free tier enough to get started?
✅ Yes. The free tier includes end-of-day data for US equities, which is sufficient to build and test the full pipeline. Upgrading unlocks real-time data, international exchanges, and extended fundamentals.

❓ Can I use this with crypto positions?
✅ EODHD covers major crypto pairs. Binance exports can be normalized by Cowork using the same workflow — the ticker format just needs to be mapped to EODHD's convention (e.g. BTC-USD).

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

推荐订阅源

DEV Community