DEV Community: Kevin Meneses González

Stop Staring at Spreadsheets: How a Proper Portfolio Visualizer Kept Me From Panic-Selling

Kevin Meneses González — Thu, 14 May 2026 11:21:16 +0000

In March 2020, I sold positions I should have held for years.

The market was collapsing. My broker app was a wall of red. My spreadsheet, half-updated as always, showed numbers I didn't trust. And without a clear picture of what I actually owned and what it was generating, I did what most retail investors do under pressure: I reacted.

Some of those positions recovered 80%, 100%, more. I wasn't there for it.

I made the same mistake again in early 2025 — different correction, same psychology, same incomplete information driving the decision.

The problem wasn't discipline. The problem was what I was looking at.

The Red/Green Trap

Broker apps are designed around price movement. Every interface puts the daily change front and center — green when you're up, red when you're down. The number that dominates your screen is the one most likely to trigger an emotional response.

That's not an accident. Engagement and activity are good for brokers. Calm, long-term holding is not.

When markets fall, every broker app in your pocket is screaming the same thing: your money is disappearing. And if that's the only signal you have — if you have no visibility on income, no view of long-term trajectory, no sense of what your portfolio actually generates — your brain fills in the rest with anxiety.

Staring at a spreadsheet during a correction is worse. The numbers are stale, the formulas are fragile, and there's no context. Just a column of values declining in real time with no counterweight.

What I Sold in 2020 (And What It Cost Me)

March 2020 was a 34% drawdown in 33 days. The fastest crash in market history.

I had positions across Degiro and Interactive Brokers. I had no consolidated view — just four separate apps showing four separate catastrophes with no way to see the full picture.

I sold. Not everything. But enough.

The positions I sold weren't bad positions. They were sound companies, held at reasonable valuations, paying dividends. But I couldn't see that in the moment. All I could see was red.

Some of those positions doubled in the 18 months that followed. The cost of that panic wasn't just the loss on the sale — it was missing the entire recovery.

In early 2025, another correction. This time I had more context, more visibility. I still felt the pull. But I also added to some positions instead of exiting. Not because my discipline had improved. Because what I was looking at had changed.

The Shift: From Capital Value to Cash Flow

The single most useful reframe for a long-term investor is this: your portfolio's job is not to be worth more tomorrow. It's to generate income that grows over time.

Price is volatile. Income is sticky.

A stock down 20% in a correction is still paying its dividend. If it's a company with a 30-year streak of increasing payments, the correction doesn't change the income thesis at all. The price will recover. The dividend, in most cases, keeps coming.

But you can only hold that perspective if you can see it. If your primary view is a red/green price chart, every correction feels like destruction. If your primary view is a dividend calendar showing $451 arriving this month regardless of what the market does — the emotional equation changes.

This is the behavioral shift that proper portfolio visualization enables. Not motivation. Not discipline. Just better information, presented in a way that maps to your actual strategy.

What a Portfolio Visualizer Actually Shows You

The difference between a broker dashboard and a proper portfolio visualizer isn't cosmetic. It's structural.

A broker dashboard shows you:

Today's price vs. yesterday's price
Your position's gain/loss since purchase
Account value (on their platform only)

A portfolio visualizer shows you:

Total net worth across all accounts, updated automatically
Asset allocation across every broker simultaneously
Income generated — actual dividends received and projected forward
Cash flow by month — what arrives when, declared vs. estimated
Performance in your base currency, adjusted for exchange rate movements

[Screenshot: Snowball Analytics portfolio overview — allocation donut chart across Funds, Stocks, Cash, Commodities]

The first view makes you feel exposed during corrections. The second gives you the global vision to stay in control.

The Dividend Calendar During a Correction

The most powerful view during a market downturn is not your portfolio value. It's your income schedule.

When prices are falling, this view answers the question that actually matters for a dividend investor: is my income stream intact?

$3,455.20 in projected annual income. $287.93 arriving every month. $9.47 every single day — whether the market is up, down, or sideways.

Look at the bar chart: June $405, August $311, September $404, December $406. The income pattern is visible a full year ahead. Not estimated loosely — projected from declared and scheduled payments, month by month.

None of that changes because the S&P dropped 8% this week.

Seeing that — really seeing it, with a 12-month forward view and specific monthly amounts — is what separates a strategic hold from a panic sell. The income calendar makes the abstract concept of "long-term investing" concrete and visible in a way that a price chart never can.

A Sense of Control vs. Reacting to Noise

There's a reason experienced investors talk about "sleeping well at night" as a portfolio objective. It's not a metaphor. It's a literal description of what good information architecture does for your decision-making.

When I have a global view of my full portfolio — allocation, performance, income, projections — I have a sense of control that no single broker app can provide. Not because the numbers are always good. But because I can see the full picture clearly enough to distinguish signal from noise.

A 5% correction in one position feels different when you can see it represents 2% of your total allocation and its dividend income is unaffected

Context doesn't eliminate volatility. But it eliminates the feeling that volatility is the whole story.

The Practical Test: What Are You Looking at When Markets Drop?

If the answer is your broker app — you're looking at the worst possible information for making a long-term decision. Designed for short-term reaction, updated in real time, stripped of all income context.

If the answer is a spreadsheet — you're looking at stale data you don't fully trust, with no income projection and no global allocation view.

If the answer is a consolidated portfolio view that shows your full allocation, your projected income for the next 12 months, and your performance in your actual base currency — you have what you need to make a rational decision under pressure.

The goal isn't to feel nothing during a correction. The goal is to have enough context that your response is strategic rather than reflexive.

That's what a proper portfolio visualizer does. Not motivation. Not courage. Just the right information, in one place, when you need it.

👉 Get a full view of your portfolio with Snowball Analytics

One Last Thing

I still think about those positions I sold in March 2020.

Not with regret — the decisions made sense given what I could see at the time. That's the point. The problem wasn't fear. The problem was incomplete information making fear the dominant input.

If I'd had a consolidated view showing my full allocation, a dividend calendar showing income arriving regardless of price, and a performance number I actually trusted — I might have held. I might have bought more.

You can't change past decisions. But you can change what you look at before you make the next one.

👉 Start visualizing your portfolio the right way

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

Why I Stopped Relying on My Broker's App to Track My Wealth

Kevin Meneses González — Wed, 13 May 2026 14:49:26 +0000

Most investors think their broker's app is enough.

It's not.

And I have a very specific date to prove it: Wednesday, February 25, 2026.

That morning I bought 35 shares of NVIDIA. Not because I had a clear thesis. Not because I'd reviewed my full allocation. But because Degiro showed me cash available, the stock looked like a dip worth catching, and I hadn't updated my consolidated spreadsheet in two weeks.

What I didn't see: I was already overexposed to tech across my other accounts.

I had to sell at a loss days later to rebalance.

That wasn't bad luck. That was a visibility problem.

If you're:

splitting your portfolio across multiple brokers,
holding crypto alongside traditional assets,
or making decisions without seeing your full picture first,

This matters.

The Broker Blind Spot Nobody Talks About

I invest across four platforms: Degiro, Interactive Brokers, Binance, and MyInvestor.

Each one shows me exactly what I hold with them. Clean charts. Green numbers. A polished interface designed to make me feel good about staying on their platform.

What none of them show me is the full picture.

Degiro doesn't know what's sitting in my Interactive Brokers account. Binance has no idea about my index funds at MyInvestor. And none of them — not a single one — can tell me my consolidated net worth at any given moment.

That's not a bug. That's a feature. Brokers are designed to keep you inside their ecosystem.

The Spreadsheet Trap

So I did what every investor eventually does: I built a spreadsheet.

It started simple. Two columns. Asset and value. Then it grew. Exchange rates. Manual updates every Sunday. Formulas that broke when a column shifted. A tab for crypto, a tab for stocks, a tab I stopped updating because it was taking too long.

The plan was to update it every week. The reality: I'd forget, skip a Sunday, then skip another, and suddenly two weeks had passed and the numbers were stale enough to be useless.

At peak complexity, maintaining that spreadsheet was costing me over 10 hours a month.

Not 10 hours of analysis. 10 hours of data entry.

And the worst part wasn't the time. It was what happened when the data was out of date: I made decisions anyway. By intuition. By gut feel. With incomplete information dressed up as a spreadsheet.

That's how you end up buying 35 shares of a stock you're already overweight in.

The stress wasn't from the market. It was from never really knowing where I stood.

There's a difference between investing with conviction and investing with anxiety. One comes from clarity. The other comes from flying blind.

The Hidden Cost Nobody Calculates

Ten hours a month sounds manageable until you run the real math.

That's 120 hours a year spent on data entry, not analysis. But the actual cost isn't the time — it's the decisions you make while the data is stale.

A bad trade made with incomplete information doesn't show up as "spreadsheet maintenance cost" in your portfolio. It shows up as a loss you didn't need to take.

Impulsive buys when you can't see your true exposure. Panic sells when you can't see your actual gain across accounts. Missed rebalancing because the picture was never complete enough to act on.

That's the real opportunity cost of the DIY approach.

The Real Problem Isn't Data. It's Fragmentation.

Every broker gives you data. The problem is that the data lives in silos — and no single broker has any incentive to fix that.

What you end up with is:

Performance metrics that only reflect one slice of your portfolio
No way to see cross-asset allocation in one view
Return calculations that ignore currency fluctuations between accounts
Zero visibility on your actual net worth across all positions

You're not missing information. You're missing integration.

What Changed When I Tried Snowball Analytics

I wasn't looking for another app. I was looking for a way to stop wasting time.

What I found was a portfolio tracker that actually understands how modern investors invest — across multiple brokers, multiple asset classes, multiple currencies.

The setup is straightforward. You connect your accounts, and Snowball pulls everything into a single dashboard. Degiro. Interactive Brokers. Binance. MyInvestor. All of it, in one place.

No more spreadsheets. No more Sunday night rituals.

What made the difference wasn't just the consolidation — it was the interface. Clean, intuitive, and built around the questions investors actually ask: What do I own? How is it performing? Where am I overexposed?

👉 Try Snowball Analytics here

What a Proper Portfolio Tracker Actually Shows You

The portfolio tracker is where I spend most of my time in Snowball.

Not because it's flashy — but because it finally shows me what I couldn't see before.

The first view that changed everything: a single donut chart showing my full allocation across Funds, Stocks, Cash, Commodities — with the exact value invested, current gain, and target allocation side by side. Not per broker. For everything.

That alone replaced three tabs I used to keep open simultaneously.

But the view I check most is the holdings table. Every position, in one place:

Cost basis vs. current value — so I always know what I actually paid
Dividends received — total and per share, updated automatically
Dividend yield and 5-year growth — not just what a stock pays now, but whether it's growing
Total profit and IRR — the real return number, not the one that looks good on a broker dashboard
Share in portfolio — so I can see concentration risk at a glance

Before Snowball, I had pieces of this scattered across platforms and a spreadsheet that was always one bad formula away from being useless.

Now I open one tab and I know exactly where I stand.

Your Broker's App Is Not a Wealth Tracker

Broker apps are trading interfaces with dashboards bolted on.

They're optimized for executing orders, not for giving you a complete picture of your financial life. That distinction matters more as your portfolio grows and spreads across multiple platforms.

A dedicated portfolio tracker isn't a luxury for institutional investors. It's the baseline infrastructure any serious retail investor needs to make decisions with confidence.

Most investors don't need more data. They need to see all their data in one place.

👉 Start tracking your full portfolio with Snowball Analytics

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

I Replaced Yahoo Finance with EODHD — Here's What Changed

Kevin Meneses González — Mon, 11 May 2026 10:22:34 +0000

Your script ran fine yesterday. Today it throws:

$AAPL: possibly delisted; no price data found (1d 2024-03-02 -> 2025-03-02)

Nothing changed in your code. Nothing changed on your machine. Yet the data is gone.

If you've been building with yfinance, you know this moment.

If you're:

running a backtesting system,
building a portfolio tracker,
or automating any kind of financial analysis in Python,

This matters more than you think.

The Problem Isn't Your Code

In early 2025, Yahoo Finance quietly restricted historical data downloads to paid subscribers — Gold tier, $50/month or $500/year.

The yfinance GitHub repository filled up with hundreds of issue reports overnight. The error messages were misleading: tickers marked as "possibly delisted" that were actively trading. Scripts that had worked for years suddenly returning empty DataFrames.

But even before the paywall, the cracks were already visible:

Rate limiting that blacklisted IPs without warning
HTML parsing that broke whenever Yahoo updated their frontend
No official support — when it breaks, you're on your own
Data gaps that only surface mid-analysis

The real problem isn't that yfinance had a bad release. It's that yfinance was never designed for production. It's a scraper that happens to return financial data.

At some point, the gap between what you need and what Yahoo Finance can provide becomes impossible to ignore.

What I Switched To — and Why EODHD

After testing several alternatives, I migrated to EODHD APIs.

EODHD (EOD Historical Data) is a financial data provider with coverage across 70+ global exchanges, 30+ years of historical data, and a REST API that's been running in production for actual financial products — not hobbyist wrappers.

What you get access to:

End-of-day stock prices (global: US, EU, Asia, LatAm)
Intraday and real-time feeds
Fundamental data (income statements, balance sheets, cash flow)
Dividends and splits history
Economic calendar and macro indicators
Technical indicators via API
WebSocket streaming for live quotes
Excel and Google Sheets add-ons (no code required)

One API key. One provider. No scraping, no workarounds.

👉 Get started with EODHD here — free tier available to test endpoints before committing.

The Migration in Python

Let's go through the three most common yfinance use cases and their EODHD equivalents. No SDK required — raw HTTP calls, clean and explicit.

1. Historical Price Data

Before — yfinance:

import yfinance as yf

ticker = yf.Ticker("AAPL")
df = ticker.history(start="2023-01-01", end="2024-01-01")
print(df[["Open", "High", "Low", "Close", "Volume"]].head())

Works until it doesn't. No guaranteed uptime, no SLA.

After — EODHD:

import requests
import pandas as pd

API_KEY = "your_eodhd_api_key"
ticker = "AAPL.US"

url = f"https://eodhd.com/api/eod/{ticker}"
params = {
    "api_token": API_KEY,
    "from": "2023-01-01",
    "to": "2024-01-01",
    "fmt": "json"
}

response = requests.get(url, params=params)
df = pd.DataFrame(response.json())
df["date"] = pd.to_datetime(df["date"])
df.set_index("date", inplace=True)

print(df[["open", "high", "low", "close", "volume"]].head())

Output:

            open    high     low   close      volume
date
2023-01-03  130.28  130.90  124.17  125.07  112117500
2023-01-04  126.89  128.66  125.08  126.36   89113600
2023-01-05  127.13  127.77  124.76  125.02   80962700

Clean, predictable, JSON-native.

2. Fundamental Data (Balance Sheet / Income Statement)

This is where yfinance often fails silently — returning empty dictionaries or malformed tables when Yahoo updates their HTML structure.

After — EODHD:

url = f"https://eodhd.com/api/fundamentals/{ticker}"
params = {
    "api_token": API_KEY,
    "filter": "Financials::Income_Statement::annual",
    "fmt": "json"
}

response = requests.get(url, params=params)
income_data = response.json()

# Extract last 3 years of annual revenue
for year, values in list(income_data.items())[:3]:
    print(f"{year}: Revenue = ${int(values.get('totalRevenue', 0)):,}")

Output:

2023-09-30: Revenue = $383,285,000,000
2022-09-24: Revenue = $394,328,000,000
2021-09-25: Revenue = $365,817,000,000

Structured, typed, consistent across updates.

3. Dividend History

Before — yfinance:

ticker = yf.Ticker("AAPL")
dividends = ticker.dividends  # Often breaks or returns partial data

After — EODHD:

url = f"https://eodhd.com/api/div/{ticker}"
params = {
    "api_token": API_KEY,
    "from": "2020-01-01",
    "fmt": "json"
}

response = requests.get(url, params=params)
dividends = pd.DataFrame(response.json())
print(dividends.tail(5))

Output:

         date  value  unadjustedValue  currency
2022-08-05  0.23             0.23       USD
2022-11-04  0.23             0.23       USD
2023-02-10  0.23             0.23       USD
2023-05-12  0.24             0.24       USD
2023-08-11  0.24             0.24       USD

From here you can build:

dividend income projections
yield-on-cost calculators
automated reinvestment models

What Actually Changed After the Migration

Let me break this down across the dimensions that actually matter in production.

Data Coverage

yfinance was always US-centric. Outside of the major indices and NYSE/NASDAQ, coverage was inconsistent — tickers from European or Asian exchanges would return data sometimes, nothing other times, with no clear explanation.

EODHD covers 70+ exchanges out of the box. LSE, Euronext, XETRA, TSX, ASX, B3, NSE — same API, same endpoint structure, same response format. If you're tracking a portfolio that isn't 100% US equities, this alone justifies the switch.

Historical Depth

Yahoo Finance paywalled historical data downloads in 2025. Gold tier: $50/month. Without it, yfinance returns empty DataFrames for date ranges older than a rolling window — and the error messages don't tell you why.

EODHD includes 30+ years of historical data on paid plans. For backtesting, that's not a feature. It's the baseline.

Reliability vs. Scraping

This is the core difference. yfinance works by mimicking browser requests to Yahoo's servers — it scrapes, parses HTML, and hopes the page structure hasn't changed. Any frontend update on Yahoo's side can silently break it. IP bans happen without warning. Rate limits have no documented threshold.

EODHD is an official REST API. You authenticate with a key, you hit an endpoint, you get JSON back. There's no HTML parsing layer, no scraping, no fragile dependencies on a third-party website's layout decisions.

Endpoint Depth

yfinance gives you prices, basic fundamentals, and dividends — and even those break periodically. EODHD exposes endpoints that don't exist in the yfinance ecosystem at all:

Technical indicators calculated server-side (RSI, MACD, Bollinger Bands via /api/technical/)
Economic calendar with macro events by country
News and sentiment feeds per ticker
WebSocket streaming for real-time quotes
Options chains and CBOE data
Bulk exchange downloads (entire market snapshot in one call)

Full Comparison

Dimension	yfinance	EODHD
Type	Scraper (unofficial)	Official REST API
Uptime guarantee	None	99.9%+ SLA
Historical depth	Paywalled ($50/mo on Yahoo)	30+ years included
Global exchanges	~25, inconsistent	70+, structured
Fundamental data	Scraped, breaks often	Typed JSON, stable schema
Dividends & splits	Partial, unreliable	Full history, clean
Technical indicators	Not available	Via API (`/api/technical/`)
Real-time / intraday	Very limited	Available (delayed + live)
WebSocket streaming	Not available	Available on paid plans
Economic calendar	Not available	Yes, by country
News & sentiment	Not available	Yes, per ticker
Options data	Basic, via scrape	CBOE + options chains
Bulk downloads	Not available	Full exchange snapshot
Rate limits	IP bans, undocumented	Defined per plan tier
Official support	Community only	24/7 live support
Excel / Sheets add-on	Not available	Included
Python SDK	Is the SDK	Official library on GitHub
Free tier	Free (unreliable)	Free tier, defined limits
Entry paid plan	N/A	~$19.99/month

The Cost Question

yfinance is free — but that math changes when you factor in the hours spent debugging silent failures, the instability that's leaked into production pipelines, and now Yahoo's own $50/month paywall for the historical data that made it useful in the first place.

EODHD's entry plan is ~$19.99/month. For that you get end-of-day data across all supported exchanges, fundamentals, and the full historical archive.

For anyone running anything beyond a personal prototype, that trade-off is straightforward.

The biggest shift wasn't the data quality. It was the reliability.

When yfinance breaks, you spend hours debugging something you didn't break. With EODHD, the contract is clear: you send a request, you get data back.

That's worth more than free.

Key Takeaways

Yahoo Finance paywalled historical data in 2025 — yfinance is no longer a viable production option
EODHD covers the same use cases (prices, fundamentals, dividends) with a stable REST API and global exchange coverage
The migration is straightforward: same data, same pandas workflow, raw HTTP instead of a scraping wrapper

FAQs

❓ Is EODHD free to use?
✅ Yes, EODHD has a free tier that covers end-of-day data for a limited number of tickers — enough to test your integration and validate the API before upgrading. Paid plans start at around $19.99/month.

❓ Does EODHD work with pandas?
✅ Directly. The API returns JSON arrays that load into DataFrames in one line. No additional parsing library needed.

❓ Can I migrate my existing yfinance scripts without rewriting everything?
✅ Mostly yes. The data fields map 1:1 (open, high, low, close, volume). The main change is replacing yf.Ticker() calls with requests.get() calls to EODHD endpoints. Most scripts migrate in under an hour.

❓ Does EODHD cover non-US markets?
✅ Yes — 70+ exchanges including LSE, Euronext, TSX, ASX, and most major Asian markets. This is one of the biggest advantages over yfinance, which has inconsistent non-US coverage.

Most developers don't switch financial data providers because of a feature list.

They switch because their script broke on a Sunday night, and they decided not to fix it the same way again.

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

How I Automated My Investing Workflow with EODHD and Claude Cowork

Kevin Meneses González — Sat, 09 May 2026 10:26:57 +0000

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

Top 5 Social Media APIs for Developers in 2026

Kevin Meneses González — Thu, 07 May 2026 10:11:37 +0000

Most developers don't quit because the idea was wrong.

They quit because they spent three weeks wiring up six different OAuth flows, handling rate limits from five separate platforms, and debugging a TikTok upload that works in staging but fails silently in production.

If you're:

building a SaaS with social publishing features,
automating content across platforms with AI agents,
or running an agency that manages dozens of client accounts,

this is the decision that will eat your sprint if you get it wrong.

The native APIs — Meta Graph, X, TikTok, LinkedIn — are not built for developers building on top of them. They're built for compliance, for platform control, for gatekeeping. The approval processes alone can take weeks. And once you're approved, you still own every breaking change they ship.

Unified social media APIs solve a different problem: one endpoint, one token, one consistent response. You write the post once. The API handles the rest.

Here are the five worth looking at in 2026.

What makes a social media posting API worth using

Before the list, a few filters.

Platform coverage. Count the platforms your product actually needs, then add a few more for the roadmap. "Just Instagram and TikTok" turns into "Instagram, TikTok, LinkedIn, and Threads" faster than you'd expect.

Pricing model. Per-profile pricing is predictable at small scale and painful at volume. Per-post pricing rewards efficient workflows. Flat-rate is easiest to budget.

Auth model. Single API key works for internal tools. Multi-tenant SaaS needs profile-scoped keys or OAuth — check what the provider actually supports before committing.

Webhooks. If your app needs to react to "post published" or "post failed" events, you need webhooks. Polling is not a solution.

MCP / AI agent support. In 2026, if you're wiring up AI agents to publish content, you want a provider with a native MCP server. Not all of them have it.

1. Upload-Post — Best overall for developers

Upload-Post sits at the top of this list for a reason: it's the only API in this space that handles video properly out of the box.

Built-in FFmpeg processing means you don't have to normalize video formats yourself before sending to TikTok or Instagram Reels. That alone saves days of integration work. It covers 10+ platforms — TikTok, LinkedIn, Facebook, X/Twitter, Threads, Pinterest, Reddit, Bluesky — with native connectors for n8n and Make.com.

The pricing model is profile-based: $16/mo for unlimited posts on 5 profiles. This works well for small to medium setups. For agencies or SaaS products with many end-user accounts, costs scale with profiles, so model that before committing.

Here's a basic Python example:

import requests

url = "https://v1.upload-post.com/api/upload"

payload = {
    "text": "New post via API",
    "platforms": ["twitter", "linkedin", "tiktok"],
    "mediaUrl": "https://your-cdn.com/video.mp4"
}

headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

From here you can build:

automated content pipelines triggered by webhooks
AI agent workflows via n8n
multi-client publishing dashboards for agencies

Pros

FFmpeg video processing built in — no pre-processing required
Native n8n and Make.com integrations
Unlimited posts on all plans

Cons

No visual content calendar (pure API, no dashboard)
Profile-based pricing gets expensive for multi-tenant SaaS

Best for: Developers who need solid video support and want fast integration with workflow automation tools.

👉 Try Upload-Post

2. Zernio — Best free tier + widest platform coverage

Zernio (rebranded from getlate.dev in early 2026) covers 15 platforms — including Discord and WhatsApp, which most competitors skip. It also comes with a native MCP server, making it one of the cleaner options for AI agent workflows.

The free tier is genuinely usable: 20 posts/month, 2 profiles, full API access. Paid plans start at $19/mo. The catch is that analytics, DMs, and the Ads API are separate add-ons, so the base price can climb depending on what you actually need.

For indie developers evaluating a unified API without spending money first, Zernio is the default starting point in 2026.

Pros

Widest platform coverage (15 networks including Discord and WhatsApp)
MCP server included — ready for AI agent workflows
Competitive entry pricing vs Ayrshare

Cons

Analytics and DMs require paid add-ons
Free tier limited to 20 posts/month

Best for: Indie developers, early-stage startups, and teams building AI-powered publishing agents.

3. Postiz — Best for open-source / self-hosted setups

Postiz started as a one-developer open-source project. It now supports 30 platforms — the broadest coverage on this list — and has grown fast on the back of AI agent adoption.

The self-hosted version is effectively free. You own the infrastructure, you handle the API key changes, but there's no monthly bill. The cloud version starts at $29/mo for 5 accounts with 400 posts, or $99/mo for unlimited.

Some of the 30 platforms are niche (Lemmy, Mastodon, Nostr), which won't matter unless you specifically need them. But for teams that want broad coverage and are comfortable running their own stack, Postiz is the only option that gets close.

import requests

url = "https://api.postiz.com/v1/posts"

payload = {
    "content": "Published via Postiz API",
    "platforms": ["linkedin", "twitter", "bluesky"],
    "publishDate": "2026-06-01T10:00:00Z"
}

headers = {
    "Authorization": "Bearer YOUR_POSTIZ_KEY",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Pros

30 platforms — most on this list
Open-source: self-host for free
Good fit for AI agent workflows

Cons

Rate limits on the cloud API (30 req/hour on base plan) — too slow for interactive apps
Self-hosted version means you own platform API updates

Best for: Teams who want maximum platform coverage and don't mind managing their own infra, or developers who want to avoid recurring API costs.

4. Outstand — Best pay-per-use pricing

Outstand takes a different approach: $5/month base fee covers 1,000 posts and unlimited accounts. Beyond that, $0.01 per post. One pricing tier, no surprises.

The catch: you bring your own API keys. That means you still go through platform approval for Meta, TikTok, X, etc. Outstand normalizes the API layer and handles routing, but doesn't abstract the credentials away. For some teams this is fine — if you already have keys or are building internal tools. For others it defeats the main benefit of a unified API.

When it works, it really works: 99.92% uptime, 180ms average response, and published performance metrics that most competitors hide.

Pros

Cleanest pricing model on the list
Unlimited connected accounts
Transparent SLA and performance data

Cons

Requires your own platform API keys — not a true managed integration
Smaller SDK ecosystem than Ayrshare or Zernio

Best for: High-volume apps with variable posting loads and developers who already have their platform API approvals sorted.

5. PostPeer — Best for analytics alongside publishing

Most APIs on this list post content and stop there. PostPeer returns unified analytics in the same API call schema — likes, views, engagement — normalized across platforms so you don't write separate parsers for each network.

Pricing is credit-based: publishing a post costs 1 credit, reading analytics also costs 1 credit. This is predictable if your workflow is balanced. Covers X, Instagram, YouTube, TikTok, LinkedIn, Facebook, Pinterest, and Threads.

If you're building a social dashboard where content performance matters as much as publishing, PostPeer removes a significant integration burden.

Pros

Unified analytics schema — no per-platform parsing
Same credit model for posting and reading data
Clean REST API, straightforward auth

Cons

Smaller platform count (8 networks) vs Postiz or Zernio
Newer entrant — ecosystem still maturing

Best for: Developers building social dashboards who need publishing + analytics from a single integration.

Quick comparison

API	Platforms	Starting price	Video processing	MCP/AI agents	Best for
Upload-Post	10+	$16/mo	✅ Built-in FFmpeg	✅ n8n, Make	Video automation, agencies
Zernio	15	$19/mo	✅	✅ Native MCP	Startups, AI agents
Postiz	30	$29/mo (cloud)	✅	✅	Max coverage, self-hosted
Outstand	10	$5/mo + $0.01/post	—	✅	High-volume, variable load
PostPeer	8+	Credit-based	—	—	Publishing + analytics

How to choose

If you need video processing and want fast integration with n8n or Make: Upload-Post.

If you're early stage and want to test without spending: Zernio's free tier.

If you need the broadest platform coverage or want to self-host: Postiz.

If your posting volume is high and unpredictable: Outstand — but only if you already have your platform API credentials.

If you're building a dashboard where analytics matter as much as publishing: PostPeer.

The biggest mistake is picking an API based on the cheapest plan at five accounts. Model what happens at 50. That's where the pricing differences actually matter.

FAQs

❓ What is a unified social media API?
✅ A unified social media API lets you publish content to multiple platforms — Instagram, TikTok, LinkedIn, X, and others — through a single HTTP endpoint. Instead of managing separate credentials, rate limits, and SDK updates for each platform, you send one request to the unified API and it handles distribution. Tools like Upload-Post, Zernio, and Postiz work this way.

❓ Do I need to get approved by each social platform if I use a unified API?
✅ Usually not. Most unified APIs (Upload-Post, Zernio, Postiz) manage the platform credentials on their side, so you don't go through TikTok's partner review or Meta's App Review yourself. The exception is Outstand, which requires you to supply your own platform API keys.

❓ Which social media API has the best free tier in 2026?
✅ Zernio offers the most usable free tier: 20 posts/month, 2 profiles, and full API access. Upload-Post and Outstand also offer limited free tiers. If you want truly free with no monthly cap, Postiz's self-hosted open-source version has no cost beyond your server.

❓ Can I use these APIs with AI agents or n8n workflows?
✅ Yes. Upload-Post has native n8n and Make.com integrations. Zernio ships a native MCP server. Postiz supports MCP. Outstand is also MCP-compatible. For AI agent workflows that need to publish content autonomously, any of these four work — Upload-Post and Zernio are the most mature options.

❓ What's the cheapest social media API for high post volume?
✅ Outstand at $5/month base + $0.01/post is the cheapest at scale if you have variable volume. PostForMe at $10/month for 1,000 posts is the cheapest flat-rate option. Upload-Post at $16/month for unlimited posts is the best value if you need video processing included.

❓ Is there a social media API that handles TikTok video uploads automatically?
✅ Upload-Post is the only API on this list with built-in FFmpeg processing, which handles video normalization for TikTok's format and size requirements automatically. Genviral and Ayrshare also support TikTok video, but without the built-in processing layer.

The real cost of a social media API isn't the monthly plan. It's the engineering hours you spend maintaining it when platforms break their APIs — which they will.

Pick the one that handles that maintenance for you.

After testing every option on this list, my pick is Upload-Post. Native video processing, n8n and Make integrations, and straightforward pricing make it the most complete option for most projects. 👉 Try it here

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

I Asked Claude to Build Me a Dividend Screener Using EODHD — Here's What It Found

Kevin Meneses González — Mon, 04 May 2026 09:10:17 +0000

Most dividend tools give you a table.

Numbers in columns. Yield percentages. Payout ratios. A filter you drag left or right.

What they don't give you is judgment.

They can't tell you why a 7% yield might be a trap. They can't flag that a company's payout ratio has been climbing for six consecutive quarters. They won't notice that a dividend that looks rock-solid today is sitting on a balance sheet that started deteriorating twelve months ago.

That distinction — between data and reasoning — is exactly what this experiment was about.

I connected Claude to EODHD's financial data API, gave it a list of dividend-paying stocks, and asked it to build a screener from scratch. No spreadsheet. No Python script. No pre-built tool.

Just a conversation. And live data.

If you're:

building income-focused portfolio tools,
managing your own dividend strategy and tired of switching between screeners,
or evaluating what AI agents can actually do with institutional-grade financial data,

This is worth reading.

The Problem With Most Dividend Screeners

Here's what a typical investor does when they want to screen for dividend stocks:

Go to a screener. Set yield above 3%. Filter by sector. Sort by payout ratio. Export to Excel. Open a second tab for the income statement. A third for the balance sheet history. Maybe a fourth to check if the dividend was cut in the last five years.

Then they start the actual analysis.

The tool gave them a list. The thinking still happens manually, in isolation, without any connection between the data points.

That's the gap.

A high yield and a low payout ratio tell you something. But they don't tell you everything. A company can show a healthy payout ratio today while its free cash flow has been shrinking for eight quarters. The number looks fine. The trend doesn't.

Most screeners show you the snapshot. They don't show you the movie.

The Architecture Behind This Setup

What is MCP?

MCP stands for Model Context Protocol — an open standard introduced by Anthropic.

Think of it as USB-C for AI. Before MCP, connecting an AI model to an external data source required custom integration code for every single API. A different script, a different auth flow, a different data format. For each one.

MCP replaces all of that with a single standard. One connection. Full access.

Instead of the AI guessing based on training data, it can now query APIs, retrieve live data, and execute workflows in real time — directly from the conversation.

The Problem It Solves

Most AI tools have a hard ceiling: their knowledge cutoff.

Ask Claude about NVIDIA's earnings from two years ago — it knows. Ask it about last quarter's free cash flow — it guesses. And confident-sounding guesses built on stale data are worse than no answer at all, because they look credible.

Without MCP, a typical analyst workflow looks like this:

Open a screener for initial filtering
Export to Excel, reformat columns
Open a second tab for income statements
A third for dividend history
A fourth for analyst consensus

Then start the actual analysis.

The bottleneck isn't intelligence. It's infrastructure.

How MCP Changes the Flow

With an MCP-connected data source like EODHD, the flow collapses into a single layer:

1. You ask a question in natural language — "Which of these stocks has the safest dividend?"

2. Claude interprets the intent — it understands you need yield, payout ratio, FCF coverage, and dividend history.

3. Claude selects the right MCP tools — it calls EODHD's endpoints automatically, without you specifying which ones.

4. EODHD returns live data — sourced directly from exchanges and regulatory filings, not cached or estimated.

5. Claude synthesizes and responds — with structured analysis, not a table of raw numbers.

The analyst's job shifts from data gathering to judgment. Which is where their expertise actually lives.

Why EODHD Specifically

Not all financial data APIs are equal — and the quality gap matters more when AI is doing the reasoning.

EODHD provides:

150,000+ tickers across 70+ exchanges
Full financial statements — income, balance sheet, cash flow
Dividend history going back decades, adjusted for corporate actions
Analyst estimates and consensus data
Insider transactions sourced from regulatory filings
Macro indicators for cross-dataset analysis
Native MCP server — one connection, full dataset access in Claude

When Claude reasons on EODHD data, it isn't estimating. It's fetching. That distinction is what makes the output trustworthy enough to act on.

The Setup: EODHD + Claude in 2 Steps

EODHD offers a native MCP server. Once connected, Claude has direct access to EODHD's full dataset in natural language — no code, no custom integration.

Step 1 — Get your EODHD API key

Create an account at eodhd.com. The free tier covers historical data and fundamentals — enough to replicate everything in this article.

Step 2 — Add it to Claude

In Claude.ai: Settings → Connectors → Add custom connector → paste your EODHD MCP URL → name it "EODHD" → Add.

You will see the list of endpoints

Start a new chat. EODHD's tools are now available to Claude automatically.

👉 Start free with EODHD here — the free tier includes historical EOD data and fundamentals access.

The Session: Building the Screener in Conversation

I gave Claude a starting list of ten dividend-paying stocks across different sectors: JNJ, KO, PG, T, MO, ABBV, PEP, VZ, O, XOM.

Classic income portfolio candidates. Some with decades of consecutive dividend increases. Some with yields high enough to raise questions.

Then I started asking.

Question 1: "Rank these ten stocks by dividend yield and tell me which ones look sustainable"

Claude pulled current yield data and payout ratios from EODHD for all ten tickers simultaneously, then cross-referenced each against free cash flow coverage — a step I didn't ask for.

The output wasn't a sorted table. It was a tiered analysis:

Tier 1 — High yield, strong coverage: Altria (MO) and Realty Income (O) topped the yield ranking, but with important caveats. MO's payout ratio is high by conventional standards — yet its free cash flow generation has consistently covered the dividend with room to spare. O structures its dividends around AFFO, not earnings, which changes the payout ratio math entirely.

Tier 2 — Moderate yield, very safe: KO, PG, PEP. Lower yields but fortress-level dividend history. Claude flagged all three as Dividend Kings without me asking — pulling that context from the fundamentals data.

Tier 3 — High yield, worth watching: T and VZ both show elevated yields driven partly by compressed valuations. Claude noted that both have been managing high debt loads while maintaining dividends — a combination that warrants closer monitoring, not immediate exclusion.

What would normally take an hour of tab-switching took about 12 seconds.

Question 2: "Show me the 10-year dividend history for the three highest-yielding stocks and flag any cuts or freezes"

Claude fetched EODHD's full dividend history for MO, T, and VZ going back ten years, organized it chronologically, and flagged every year where the dividend was held flat or reduced.

The result surfaced something worth knowing: AT&T cut its dividend in 2022 following the WarnerMedia spinoff — a move that significantly reset its income profile. Claude noted this explicitly, with the quarter and percentage reduction, sourced directly from EODHD's dividend records.

Not guessed. Not approximated. Fetched.

This is the kind of signal that gets buried when you're looking at current yield alone. A stock that cut its dividend three years ago and has since stabilized is a very different investment than one with an unbroken 30-year record — even if the current yield looks identical.

Question 3: "For the Dividend Kings in this list, pull the last 8 quarters of free cash flow and tell me if the dividend is getting harder to cover"

Claude pulled quarterly cash flow statements from EODHD for KO, PG, and PEP, calculated the free cash flow payout ratio for each quarter, and plotted the trend directionally.

The analysis on Coca-Cola was particularly sharp: strong and stable FCF coverage throughout the period, with coverage ratios consistently above 70% — healthy for a mature consumer staples company with predictable cash flows.

Procter & Gamble showed a similar pattern, with one quarter of compression that Claude correctly attributed to elevated capex during a facility expansion cycle — visible in the capital expenditure line of the same cash flow statement.

It didn't just answer the question. It explained the anomaly.

Question 4: "If I had to build a 5-stock dividend portfolio from this list focused on income stability — not maximum yield — which would you pick?"

Claude synthesized everything it had already pulled — dividend history, FCF coverage trends, payout sustainability, debt levels — and built a structured argument for five positions.

The recommendation: KO, PG, PEP, O, ABBV.

The reasoning for each exclusion was explicit:

T: dividend cut history + ongoing debt reduction pressure
VZ: similar concerns, lower FCF growth trajectory
MO: sustainable today, but long-term business model risk warrants a separate decision
XOM: dividend is sound, but commodity exposure conflicts with an income-stability mandate
JNJ: recent Kenvue spinoff changes the historical comparability of dividend data

That's the kind of structured reasoning that goes into a real portfolio construction decision. Not a list of tickers with yield percentages attached.

What This Changes for Income Investors

The standard workflow for dividend analysis involves at least four separate tools: a screener for initial filtering, a financial data source for statements, a dividend history tracker, and something to cross-reference analyst ratings or macro context.

Each tool answers one question. Connecting the answers is manual work.

With EODHD + Claude, the connection happens in the conversation. You ask a question that spans multiple data types — yield, history, FCF, coverage ratio, sector context — and get a synthesized answer, not four separate outputs you have to reconcile yourself.

The cognitive load shift is significant.

You move from gathering to judging. The data assembly is automated. The actual investment thinking is what you're left with.

What You Can Build From Here

Once EODHD is connected, you can run:

Dividend growth screeners — identify companies with 10+ consecutive years of dividend increases, filtered by sector and payout ratio range
Yield trap detectors — flag stocks where high yield correlates with deteriorating FCF or rising debt
Dividend safety scores — build a composite of payout ratio, FCF coverage, and dividend history into a single reliability ranking
Pre-earnings dividend risk checks — before a quarterly report, pull the FCF trend and ask Claude whether the dividend coverage is at risk
Sector income comparisons — "Compare average dividend yield and payout ratios across consumer staples, utilities, and REITs"

The infrastructure is already there. The data is live. The interface is a question.

Most dividend investors don't lack access to data.

They lack time to connect it.

That's the problem this setup solves — and why the screener you build in a conversation is more useful than the one you build in a spreadsheet.

👉 Get started with EODHD here — clean dividend history, full fundamentals, and MCP support for AI agents.

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

The Hidden Cost of Bad Financial Data (And How to Fix It Before It Costs You Millions)

Kevin Meneses González — Sun, 03 May 2026 16:31:37 +0000

Introduction: The Problem Nobody Budgets For

Most companies carefully plan:

Infrastructure
Hiring
Product roadmap

But almost nobody plans for this:

The cost of bad financial data.

Not because it's irrelevant.
But because it's invisible… until it hits revenue.
And when it does, it's already too late.

The Silent Killer: Data That Looks Correct

Here's the dangerous part:

Your system works.

API responds ✔
Dashboard loads ✔
Charts look fine ✔

But underneath:

Prices are not adjusted for splits
Dividends are missing
Historical gaps exist
Data is inconsistent across endpoints

And that leads to one thing:

Wrong decisions, made confidently.

The Real Cost (This Is Where It Hurts)

This is not a "technical issue".
It's a business liability.

What actually happens:

Investment models produce false signals
KPIs become meaningless
Revenue opportunities are missed
Users lose trust in your product
Engineering time gets burned fixing data issues

Bad data doesn't crash your system. It corrupts your decisions.

Why This Happens (Even in Good Teams)

1. Financial data is harder than it looks

Corporate actions (splits, dividends, buybacks…) change everything.

If you don't handle them properly:
👉 Your historical data becomes useless

2. Internal pipelines become a trap

What starts as:
"Let's build it ourselves"

Ends as:

Complex ETL pipelines
Endless edge cases
High maintenance cost

3. AI without real data makes it worse

Many teams now rely on AI.
But here's the problem:

AI without real data is just guessing.

Models often generate convincing but incorrect analysis when they lack direct access to market data.

The New Layer: Why MCP Changes Everything

This is where things get interesting.

What is MCP (Model Context Protocol)?

Think of it like this:

MCP is the bridge between AI and real data.

Instead of AI guessing, it can:

Query APIs
Retrieve real-time data
Execute workflows

MCP is a standard that allows AI systems to securely access and use external data sources in a structured way.

Why this matters for decision makers:

Faster insights
Less manual work
More reliable outputs

Companies using MCP-like infrastructures report faster integrations, higher ROI, and better governance in AI workflows.

The Solution: A Reliable Data Architecture

Here's what a modern financial data stack should look like:

Where Most Systems Fail

👉 In the middle layers:

Poor data cleaning
Missing adjustments
Inconsistent formats

Where You Should Focus Instead

👉 The source of truth.

Using a provider like EODHD gives you:

Clean, adjusted data
Corporate actions handled
Consistent structure
Global coverage

How MCP + APIs Unlock a New Level

When you combine:

Reliable APIs
MCP layer
AI agents

You unlock something powerful:

👉 Data → Insight → Decision (automated)

For example:

AI pulls historical data
Adjusts for splits/dividends
Calculates indicators
Generates insights

All in seconds.

EODHD's MCP server exposes dozens of tools and datasets, enabling AI agents to access real-time and historical financial data directly.

Real Business Impact

Let's translate this into what matters:

	Without this setup	With this setup
Analysis	Slow	Faster decisions
Workflows	Manual	Automated
Results	Inconsistent	High confidence
Products	Prototype	Scalable

👉 That's the difference between a prototype… and a real business.

Build vs Buy (The Strategic Decision)

Here's the truth most CTOs already suspect:

You should not build your own financial data infrastructure from scratch.

Because:

It's not your core advantage
It's expensive
It doesn't scale well

What does create value:

Speed
Insights
Product differentiation

Final Thought

Most fintech products don't fail because of bad ideas.
They fail because they are built on data they shouldn't trust.

If you're building something serious:

👉 Don't optimize only your code
👉 Optimize your data layer
👉 And now… your AI layer too

Because the future is not APIs alone, or AI alone.

It's: APIs + AI + MCP working together.

👉 Start building with reliable financial data — EODHD — Clean, adjusted, global financial data with MCP support.

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

How I Built a Momentum Trading App with Claude Code and EODHD

Kevin Meneses González — Fri, 01 May 2026 11:53:59 +0000

Most developers lose the first three days of a project before writing a single line of business logic.

They're fighting environment setup. Hunting documentation. Debugging import errors at midnight.

If you're:

building algorithmic trading tools,
automating market analysis workflows,
or prototyping fintech products with real financial data,

This matters.

Because the bottleneck isn't your strategy. It's everything around it.

The Real Problem Isn't the Algorithm

Every developer I know who's tried to build a trading system has hit the same wall.

Not a math wall. A tooling wall.

You open a blank file. You know what you want to build — a momentum screener, a signal engine, a simple backtester. But before the strategy, you need to:

Find a reliable financial data API (and actually understand its endpoints)
Scaffold the project structure
Handle authentication, rate limits, and error responses
Write boilerplate that has nothing to do with trading logic

By the time you're ready to write the interesting part, you're already drained.

The real problem isn't complexity. It's context switching.

Claude Code Changes the Setup Equation

Claude Code is Anthropic's agentic coding tool. It runs in your terminal, reads your project, and executes real tasks — not just suggestions.

It doesn't autocomplete. It builds.

You describe what you want. Claude Code reads your files, runs commands, installs dependencies, and iterates based on actual output. It operates inside your codebase like a senior developer who never needs to ask where things are.

For trading projects specifically, this changes the dynamic entirely.

Instead of spending two hours on boilerplate, you spend twenty minutes describing your goal and reviewing the result.

If you're curious about the data layer powering the examples below, EODHD APIs offer one of the most complete financial datasets available for developers — EOD prices, fundamentals, and real-time feeds across 70+ exchanges. Start with a free API key here.

Claude Code: Commands, Tips, and Workflow Patterns

Before touching any trading logic, it's worth understanding how to use Claude Code effectively. There's a gap between "it works" and "it works fast."

Installation

npm install -g @anthropic-ai/claude-code
claude

Claude Code requires Node.js 18+. Once installed, you launch it from the root of your project directory. It reads the local filesystem from that point forward.

Key Commands to Know

Once you're inside a Claude Code session, these slash commands do the heavy lifting:

Command	What it does
`/init`	Generates a `CLAUDE.md` file — your project memory
`/compact`	Summarizes conversation history to save context window
`/clear`	Resets the session (useful when switching tasks)
`/cost`	Shows token usage for the current session
`Shift+Tab`	Toggles auto-accept mode — Claude executes without asking

The CLAUDE.md File — Your Most Underrated Tool

Run /init at the start of every project. Claude Code generates a CLAUDE.md file that captures your project structure, conventions, and dependencies.

Every subsequent session, Claude reads this file first.

That means you don't re-explain your codebase every time you open a new session. It knows where your modules live, what your naming conventions are, and what tools you're using.

For a trading project, add explicit notes:

## Project Context
- Uses EODHD API for all market data (EOD + intraday)
- Momentum strategy: 20-day vs 50-day SMA crossover + ROC filter
- Output: CSV signals + terminal summary
- Python 3.11, no external trading frameworks

This is the difference between a 10-minute session and a 40-minute session.

How to Prompt Claude Code for Technical Tasks

Claude Code responds better to task-oriented prompts than to questions.

Less effective:

"How do I fetch stock data from EODHD?"

More effective:

"Create a data_fetcher.py module that pulls 6 months of EOD data from EODHD for a given ticker. Use requests, handle HTTP errors, and return a pandas DataFrame sorted by date ascending."

Specificity reduces back-and-forth. Include: the module name, the library preference, the return type, and the error handling expectation.

Token Optimization Patterns

Claude Code sessions have a context window. If you're building something complex, manage it deliberately:

Use /compact before switching to a new feature — it keeps the memory without the noise
Break large tasks into stages: scaffold first, implement second, test third
If a session is drifting (Claude starts repeating itself or losing track), /clear and restart with a focused prompt

One more thing: Claude Code has a headless mode for automation.

claude -p "Run all tests in /tests and report which ones fail" --output-format json

Useful when you want to integrate it into a CI pipeline or a shell script that audits your project overnight.

EODHD: The Data Layer for Serious Projects

Financial data is the foundation of every trading system. And not all data providers are equal.

EODHD (End-Of-Day Historical Data) covers 70+ exchanges, with endpoints for EOD prices, fundamentals, intraday data, macroeconomic indicators, and more. It's built for developers — clean REST API, consistent JSON responses, and solid documentation.

For a momentum strategy, you'll primarily use two endpoints:

1. EOD Historical Data

GET https://eodhd.com/api/eod/{TICKER}.{EXCHANGE}?api_token=YOUR_KEY&fmt=json&from=2024-01-01

Returns daily OHLCV data. Clean, pageable, reliable.

2. Real-Time / Intraday Data

GET https://eodhd.com/api/intraday/{TICKER}.{EXCHANGE}?interval=1h&api_token=YOUR_KEY

For signal validation during market hours.

Why EODHD specifically for trading projects:

Coverage: 150,000+ tickers across equities, ETFs, indices, forex, and crypto
Historical depth: up to 30 years of daily data for most US equities
Fundamentals: P/E, EPS, revenue — available in the same API ecosystem
Rate limits: generous on paid plans; free tier covers basic EOD access for testing
Consistency: JSON structure doesn't change between tickers — you write the parser once

That last point matters more than it sounds. Inconsistent API responses are one of the most common sources of bugs in trading systems.

Building the Momentum App: Step by Step

A momentum strategy is one of the most empirically robust in quantitative finance. The premise: assets that have outperformed recently tend to continue outperforming over the next 1–12 months.

Our implementation uses:

20-day vs 50-day SMA crossover as the trend filter
Rate of Change (ROC-10) as the momentum signal
EODHD for all price data

Step 1: Project Setup with Claude Code

Open your terminal in a new project directory and launch Claude Code:

mkdir momentum-trader && cd momentum-trader
claude

Prompt:

Scaffold a Python project for a momentum trading screener. 
Create: main.py, data_fetcher.py, signals.py, config.py.
Add a requirements.txt with: requests, pandas, numpy, python-dotenv.
Add a .env.example with EODHD_API_KEY placeholder.

Claude Code will create all files, write placeholder structure, and set up the .env pattern. What would take 15 minutes manually happens in under two.

Step 2: Fetching Price Data from EODHD

In data_fetcher.py:

import os
import requests
import pandas as pd
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("EODHD_API_KEY")
BASE_URL = "https://eodhd.com/api/eod"

def get_eod_data(ticker: str, exchange: str = "US", period: str = "d", months: int = 6) -> pd.DataFrame:
    from datetime import datetime, timedelta
    start = (datetime.today() - timedelta(days=months * 30)).strftime("%Y-%m-%d")

    url = f"{BASE_URL}/{ticker}.{exchange}"
    params = {
        "api_token": API_KEY,
        "fmt": "json",
        "from": start,
        "period": period
    }

    response = requests.get(url, params=params)
    response.raise_for_status()

    df = pd.DataFrame(response.json())
    df["date"] = pd.to_datetime(df["date"])
    df = df.sort_values("date").reset_index(drop=True)
    return df[["date", "open", "high", "low", "close", "volume"]]

Clean. No external trading libraries. Just requests and pandas.

Step 3: Calculating Momentum Signals

In signals.py:

import pandas as pd
import numpy as np

def add_signals(df: pd.DataFrame) -> pd.DataFrame:
    df = df.copy()

    # Trend filter: SMA crossover
    df["sma_20"] = df["close"].rolling(window=20).mean()
    df["sma_50"] = df["close"].rolling(window=50).mean()
    df["trend_up"] = df["sma_20"] > df["sma_50"]

    # Momentum signal: Rate of Change (10 days)
    df["roc_10"] = df["close"].pct_change(periods=10) * 100

    # Combined signal
    df["signal"] = np.where(
        (df["trend_up"]) & (df["roc_10"] > 5),
        "BUY",
        np.where(
            (~df["trend_up"]) & (df["roc_10"] < -5),
            "SELL",
            "HOLD"
        )
    )

    return df

ROC > 5% + uptrend = BUY. ROC < -5% + downtrend = SELL. Everything else = HOLD.

Simple. Auditable. A solid base to extend.

Step 4: Running the Screener

In main.py:

from data_fetcher import get_eod_data
from signals import add_signals

WATCHLIST = ["AAPL", "MSFT", "NVDA", "TSLA", "META"]

def run_screener():
    results = []

    for ticker in WATCHLIST:
        df = get_eod_data(ticker)
        df = add_signals(df)
        latest = df.iloc[-1]

        results.append({
            "Ticker": ticker,
            "Close": round(latest["close"], 2),
            "ROC_10": round(latest["roc_10"], 2),
            "SMA_20": round(latest["sma_20"], 2),
            "SMA_50": round(latest["sma_50"], 2),
            "Signal": latest["signal"]
        })
        print(f"{ticker}: {latest['signal']} | ROC={latest['roc_10']:.1f}% | Close={latest['close']:.2f}")

    import pandas as pd
    pd.DataFrame(results).to_csv("signals_output.csv", index=False)
    print("\nSignals saved to signals_output.csv")

if __name__ == "__main__":
    run_screener()

Run it:

python main.py

Sample output:

AAPL: BUY | ROC=7.3% | Close=213.45
MSFT: HOLD | ROC=2.1% | Close=418.20
NVDA: BUY | ROC=12.8% | Close=875.60
TSLA: SELL | ROC=-6.4% | Close=172.30
META: BUY | ROC=9.1% | Close=521.80

From here you can extend this into:

a daily cron job that emails you the signals each morning
a backtester that runs this logic over 5 years of EODHD data
a Telegram bot that notifies you on BUY/SELL transitions
a web dashboard that visualizes signal history per ticker

Claude Code can scaffold any of those in a single session. That's the actual leverage.

FAQs

❓ Is Claude Code free to use?
✅ Claude Code is billed through your Anthropic API usage — there's no fixed subscription. You pay per token consumed during sessions. For a typical development session (1–2 hours of active work), costs are generally under $5. Heavy sessions with large codebases can go higher. Use /cost during sessions to monitor spend.

❓ Does EODHD offer a free tier for testing?
✅ Yes. EODHD provides a free API key that gives access to EOD historical data for a limited set of tickers. It's enough to run the momentum screener in this article and evaluate the API structure before committing to a paid plan. Register here.

❓ Can I use this momentum strategy in production?
✅ The code in this article is a working prototype, not a production system. For real deployment, you'd add position sizing, slippage estimates, portfolio-level risk controls, and a proper backtesting framework (Backtrader or VectorBT work well with EODHD data). Treat this as a tested starting point, not a finished product.

❓ What exchanges does EODHD cover beyond US equities?
✅ EODHD covers 70+ exchanges globally — including LSE, TSX, Euronext, ASX, NSE, Bovespa, and crypto markets. The same API structure applies across all of them, which means the code in this article works for European or Asian stocks by simply changing the exchange parameter (e.g., "LSE", "XETRA", "TSX").

❓ How does Claude Code handle large codebases?
✅ Claude Code reads your project directory recursively and uses the CLAUDE.md file as a persistent context anchor. For large projects, it's best practice to use /compact frequently, break tasks into isolated sessions, and keep your CLAUDE.md updated with current project state. It handles codebases of 50k+ lines reliably — the limiting factor is session context, not file size.

The Shift Has Already Happened

A year ago, "build a trading screener" meant a weekend project.

Today, with Claude Code and a solid data API, it's an afternoon.

The tools have changed. The bottleneck has moved from implementation to decision-making — what strategy to test, what data to trust, what signals to act on.

That's the right problem to have.

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: 👉 linkedin.com/in/kevin-meneses-gonzalez

Try EODHD APIs here

5 Best Proxies for Web Scraping in 2026

Kevin Meneses González — Thu, 30 Apr 2026 13:16:49 +0000

Most articles about proxies focus on IP pool size and price per GB.

That's the wrong question.

If you're:

building a price monitoring pipeline for your SaaS,
collecting competitor data without getting blocked,
or feeding an AI agent with live web data at scale,

The proxy you choose determines whether your system works reliably in production — not just in a demo.

The Real Problem With Proxy Comparisons

Here's what typically happens.

A developer finds a proxy provider, signs up, runs a few test requests, sees clean responses. Everything looks fine. Ships it.

Then, two weeks later:

The tool hits a Cloudflare Turnstile that the proxy can't bypass
The JS-rendered page returns empty HTML because the headless browser wasn't configured
The credit burn is 25x higher than the advertised price because of hidden multipliers
Rate limits kick in at the worst possible moment

The proxy worked in testing. It failed in production.

That's the gap this guide addresses.

How to Read This Comparison

Proxy and scraping API providers are not interchangeable. There are two fundamentally different categories:

Proxy-first providers (Decodo, Evomi) give you raw IP infrastructure. You bring your own scraper, manage rotation logic, handle retries, and deal with anti-bot detection yourself. Lower cost per GB. Higher engineering overhead.

Scraping API providers (ZenRows, Scrapfly, Scrape.do) handle everything behind a single endpoint — proxies, JS rendering, anti-bot bypass, retries. You send a URL and receive clean HTML. Higher cost per request. Zero infrastructure to manage.

Neither is better. The right choice depends on whether your bottleneck is budget or engineering time.

Each provider here is evaluated on:

Anti-bot performance — Cloudflare, DataDome, Akamai bypass
Pricing transparency — what you actually pay, not the headline number
Developer experience — setup speed, Python integration, documentation quality
Free tier honesty — what it actually lets you test
Best-fit use case — where it genuinely wins

1. ZenRows — Best for All-in-One Anti-Bot Bypass

ZenRows is a universal scraping API that bundles proxy rotation, JavaScript rendering, and anti-bot bypass into a single endpoint. Instead of managing separate tools for proxies, headless browsers, and CAPTCHA solvers, you configure one request.

The architecture is simple: you send a URL with parameters specifying what you need, and ZenRows routes it through the right infrastructure. Basic pages use datacenter IPs. Protected pages automatically trigger residential proxies and browser rendering. The decision happens server-side.

Here's what a basic integration looks like:

import requests

url = "https://www.amazon.com/dp/B09XYZ"
params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": url,
    "js_render": "true",       # Trigger headless Chrome
    "premium_proxy": "true",   # Use residential IPs
    "autoparse": "true",       # Return structured data
}

response = requests.get("https://api.zenrows.com/v1/", params=params)
print(response.text)

From here you can build:

Price monitoring pipelines for e-commerce sites
Competitor intelligence scrapers for SaaS companies
Lead generation tools that bypass login pages
AI training data collectors from protected domains

The Pricing Reality

ZenRows uses a multiplier system that's worth understanding before you commit. The base rate looks competitive — but the actual cost depends on what the target site requires:

Request type	Credits multiplier
Basic (datacenter, no JS)	1x
JS rendering only	5x
Premium proxies only	10x
Both (most protected sites)	25x

On the Business 300 plan ($299.99/month): a basic request costs $0.10/1K, but a fully protected request costs $2.50/1K. On many real-world targets (Amazon, LinkedIn, major e-commerce), the 25x multiplier applies automatically with no way to disable it.

This isn't a dealbreaker — it's just what production scraping costs. The issue is when teams budget based on the headline $0.10 figure and get surprised by the real invoice.

Plan	Price	Basic requests	Protected requests	Concurrent
Free trial	$0	1,000	40	5
Developer	$69.99/mo	250K	10K	20
Startup	$129.99/mo	1M	40K	50
Business	$299.99/mo	12.5M	480K	100

Annual discount: 10% off.

Pros:

55M+ residential IPs across 50+ geolocations
Scraping Browser with native Puppeteer and Playwright support
Integrates with n8n, Zapier, and Make natively
Only charges for successful requests (404s count as success)
Supports CSS selector extraction — returns structured data, not raw HTML

Cons:

$69.99/month entry point is the highest on this list
25x multiplier on protected sites creates unpredictable billing
10K protected requests on Developer plan is very tight for production testing
Success rate variance: 56% on some benchmarks, 92% on others — target-dependent

Best for: Teams that want a single API to handle everything and prioritize shipping speed over cost optimization. Particularly strong for browser automation workflows using Puppeteer or Playwright.

👉 Start your ZenRows free trial here — 1,000 free requests, no credit card required.

2. Scrapfly — Best for High-Stakes Anti-Bot Targets

Scrapfly is a French scraping API that consistently ranks first in independent benchmarks for anti-bot bypass. On Scrapeway's bi-weekly benchmark across 11 popular targets, Scrapfly holds a 98.8% success rate — the highest measured figure in the market.

What makes it technically distinctive is ASP (Anti-Scraping Protection) — a proprietary bypass engine built around two in-house tools: Curlium (byte-perfect Chrome on the wire) and Scrapium (an anti-detect Chromium patched at the C++ level). When you enable asp=True, Scrapfly detects the active anti-bot vendor, builds a coherent browser fingerprint, solves the challenge, and replays the request transparently.

Failed scrapes — including bot blocks and upstream errors — are not billed, unless your failed traffic exceeds 30% of requests within a one-hour window.

from scrapfly import ScrapflyClient, ScrapeConfig

client = ScrapflyClient(key="YOUR_API_KEY")

result = client.scrape(ScrapeConfig(
    url="https://www.zillow.com/homedetails/",
    asp=True,              # Anti-bot bypass engine
    render_js=True,        # Headless Chrome rendering
    proxy_pool="public_residential_pool",  # Route through residential IPs
    country="us",          # Geo-target
    cache=True,            # Cache identical requests
))

print(result.result.content)

From here you can build:

Real estate data pipelines for Zillow, Redfin, and similar protected sites
Price trackers for Amazon and heavily protected e-commerce
AI training data collectors with LangChain and LlamaIndex (native integrations)
Screenshot pipelines and PDF export workflows

The Credit Math

Scrapfly's credit system is flexible but requires attention:

Request type	Credits cost
HTTP (datacenter)	1 credit
Residential proxy	25 credits
+ JS rendering	+5 credits
+ ASP bypass	+10 credits
Max per protected request	30 credits

On the Discovery plan ($30/month, 200K credits): 200K ÷ 30 = ~6,666 fully protected requests. Not much. On the Pro plan (~$100/month, 1M credits): ~33,333 protected requests — workable for moderate production use.

The other important detail: credits don't roll over between months, and there are no annual plans. If your usage is variable, that's a real cost consideration.

Plan	Price	Credits/month	Concurrent
Free	$0	1,000	—
Discovery	$30/mo	200,000	5
Pro	~$100/mo	1,000,000	20
Startup	~$250/mo	3,000,000	25
Enterprise	Custom	Custom	Custom

Pros:

98.8% success rate — #1 in Scrapeway's independent benchmark
SOC 2 Type II + ISO 27001 + GDPR certified — the most complete compliance posture here
Native integrations with LangChain, LlamaIndex, n8n, Zapier, Make
AI extraction included: natural-language instructions return structured JSON
Screenshot API, Extraction API, and Crawler API included under same key

Cons:

Credit math complexity: easy to miscalculate actual cost before testing
Discovery plan has only 5 concurrent requests — hits a ceiling fast
No annual pricing or rollover credits
The jump from Discovery ($30) to Pro (~$100) has no intermediate tier
One user reported mid-contract price doubling — verify terms before scaling

Best for: Teams scraping heavily protected targets where success rate is the primary constraint — DataDome, PerimeterX, Kasada-protected sites. Also the strongest option for AI-powered extraction workflows.

3. Decodo — Best Proxy Infrastructure for Teams Scaling Beyond Basics

Decodo (formerly Smartproxy, rebranded 2025) is the most complete proxy-first platform on this list. Where ZenRows and Scrapfly handle everything through a managed API, Decodo gives you raw infrastructure — 125M+ ethically sourced IPs across residential, mobile, ISP, and datacenter pools — plus a Web Scraping API as a secondary product.

The architecture difference matters. If you already have a scraper and need reliable IP infrastructure behind it, Decodo is the cleaner choice. If you need anti-bot bypass handled automatically, ZenRows or Scrapfly will serve you better.

The residential proxy performance data is compelling: 99.86% success rate, 0.54s latency (Proxyway benchmark, fastest among all providers tested). Decodo consistently wins on raw proxy speed.

Here's how the residential proxy integration works in Python:

import requests

proxy_url = "http://user:password@gate.decodo.com:7000"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get(
    "https://example.com/product-page",
    proxies=proxies,
    timeout=30,
)

print(response.status_code)
print(response.text[:500])

For teams who want to skip the proxy configuration and use the Scraping API instead:

import requests

payload = {
    "url": "https://example.com",
    "headless": "html",   # JS rendering
}

response = requests.post(
    "https://scraper-api.decodo.com/v2/scrape",
    json=payload,
    auth=("YOUR_USERNAME", "YOUR_PASSWORD"),
)

print(response.json())

From here you can build:

Price monitoring systems with geo-targeted residential IPs
Multi-account management tools with sticky session support
SEO rank trackers pulling localized SERP results by city
Data pipelines that combine raw proxies with the Web Scraping API

Pricing — Residential Proxies:

Volume	Price/GB
Pay as you go	~$7/GB
3 GB	~$4/GB
25 GB (most popular)	~$2.20/GB
100+ GB	from $2/GB

Free trial: 100MB / 3 days. Card required, no charge upfront.

Pricing — Web Scraping API:

Tier	Price/1K requests
Core	$0.32/1K
Advanced	$0.88/1K

Pros:

125M+ IPs in 195+ countries — one of the largest pools on the market
99.86% success rate and 0.54s latency on residential proxies (Proxyway #1)
Proxies + Web Scraping API + SERP API + eCommerce API under one dashboard
Native n8n integration (launched 2026)
Pay-as-you-go available with no monthly commitment via Wallet
130K+ clients; robust documentation and 24/7 live support

Cons:

Web Scraping API success rate (~85.88%) trails Scrapfly and Scrape.do significantly
For Cloudflare/DataDome/Kasada bypass, the managed APIs above outperform
Pay-as-you-go residential costs ~$7/GB — significantly higher than subscription tiers
Free trial is only 100MB, which is too limited to properly evaluate production behavior

Best for: Teams who need the best raw proxy infrastructure at a competitive price — price monitoring, SEO tracking, account management, geo-targeted data collection. Also the right choice when you need a single vendor for multiple proxy types.

👉 Try Decodo free for 3 days — 100MB residential traffic, no upfront charge.

4. Evomi — Best Budget Proxy for Teams That Manage Their Own Scraper

Evomi is a Swiss proxy provider with the lowest published residential proxy price on the market: $0.49/GB on the Core plan. The proxies are ethically sourced from volunteer nodes, the company is GDPR-compliant by Swiss jurisdiction, and every plan includes a free trial without requiring a credit card.

It's the right choice for one specific situation: you already have a scraper that works, you're not hitting heavy anti-bot defenses, and you need to drive down your proxy cost.

import requests

# Evomi rotating residential proxy
proxy_url = "http://user:password@resi.evomi.com:1000"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

# Sticky session — same IP for up to 120 minutes
# proxy_url = "http://user-country-us-session-abc123:password@resi.evomi.com:1001"

response = requests.get(
    "https://example.com",
    proxies=proxies,
    timeout=20,
)

print(response.status_code)

From here you can build:

Price scrapers for lightly protected e-commerce sites
Content aggregators with basic geo-targeting needs
Research tools that require rotating IPs across 195+ countries
Data pipelines where cost per GB matters more than bypass capability

The Pricing Trap Worth Knowing

Evomi's $0.49/GB is the base rate on the Core plan — without any targeting filters. The moment you add geo-targeting at the city or ASN level, multipliers apply. At the maximum multiplier, the effective cost can reach $7.35/GB — comparable to premium providers and higher than Decodo's pay-as-you-go rate.

The Business plan has lower multipliers and is the more realistic option for teams that need consistent targeting.

Product	Base price
Residential proxies	$0.49/GB (Core, 100GB min)
Datacenter proxies	$0.30/GB
Mobile proxies	$2.20/GB
Static ISP proxies	$1.00/IP

Evomi also includes Evomium — a free antidetect browser — with every plan. For teams managing multiple accounts alongside scraping workflows, this is a meaningful addition.

Pros:

Cheapest published residential rate: $0.49/GB at volume without targeting filters
Free trial with no credit card required
Ethically sourced IPs (volunteer nodes, Swiss compliance)
HTTP, HTTPS, SOCKS5 support; sticky sessions up to 120 minutes
195+ countries, city + ASN + ZIP targeting options
Evomium antidetect browser included free

Cons:

IP pool is small: 5M residential IPs vs 125M for Decodo — impacts quality on high-trust targets
Core plan multipliers for targeting can reach 15x, eliminating the price advantage
No Scraping API — you manage all anti-bot handling yourself
Less documentation and community support than larger providers
Performance can degrade on heavily protected targets without dedicated bypass tooling

Best for: Teams with existing scrapers targeting unprotected or lightly protected sites, where cost per GB is the primary constraint and geo-targeting requirements are basic.

5. Scrape.do — Best Balance of Speed, Reliability, and Transparent Pricing

Scrape.do is a scraping API that consistently ranks second in independent benchmarks — 98.19% success rate, 4.7s average response time — at a lower entry price than most competitors.

What distinguishes it from ZenRows and Scrapfly is the pricing model. Parameters are opt-in by default. Residential proxies, JS rendering, and premium features only activate when you explicitly enable them. There are no automatic multipliers on certain domains, no forced feature combinations. You pay for what you turn on.

That's a meaningful operational difference. Teams who've been burned by ZenRows' automatic 25x multiplier on certain targets, or Scrapfly's 30-credit ceiling per request, consistently cite Scrape.do's pricing transparency as the reason they switched.

import requests

url = "https://api.scrape.do"

params = {
    "token": "YOUR_SCRAPE_DO_TOKEN",
    "url": "https://www.amazon.com/dp/B09XYZ",
    "render": "true",           # Enable JS rendering (opt-in)
    "super": "true",            # Enable residential proxies (opt-in)
    "geoCode": "us",            # Geo-target (opt-in)
    "output": "markdown",       # Return LLM-ready markdown
}

response = requests.get(url, params=params)
print(response.text)

For teams feeding scraped data into AI pipelines, the output=markdown parameter is particularly useful — it returns clean, structured text that feeds directly into LLM context without HTML parsing overhead.

From here you can build:

Price tracking systems with predictable monthly costs
AI data collectors that feed into LangChain or similar pipelines
Competitive intelligence tools with geo-targeted requests
High-volume scrapers where billing clarity is operationally important

Pricing:

Plan	Price	Requests	Price/1K
Free	$0	1,000	—
Starter	$29/mo	250K	$0.12/1K
Business	$99/mo	1.5M	$0.07/1K
Enterprise	Custom	Custom	Custom

No multipliers. All parameters are opt-in. Failed requests are not billed.

Pros:

98.19% success rate — second only to Scrapfly across independent benchmarks
4.7s average response time — fastest among all scraping APIs tested
Transparent opt-in pricing: no automatic feature triggers, no surprise multipliers
$29/month entry point — most accessible serious scraping API on the list
Markdown output mode for LLM-ready data without post-processing
No credit card required for the 1,000 free credits

Cons:

Smaller ecosystem than ZenRows or Scrapfly (less third-party documentation)
No dedicated proxy product — can't separate raw IP access from the managed API
Brand recognition lower than competitors — fewer community tutorials
Less feature richness for complex browser automation scenarios vs ZenRows

Best for: Teams that prioritize reliability + speed + budget predictability. The strongest entry point for scraping projects where you want production-grade performance without the financial risk of hidden multipliers.

👉 Start with Scrape.do — 1,000 free credits, no credit card

Quick Comparison Table

	ZenRows	Scrapfly	Decodo	Evomi	Scrape.do
Type	Scraping API	Scraping API	Proxy + API	Proxy only	Scraping API
Entry price	$69.99/mo	$30/mo	$2.20/GB	$0.49/GB	$29/mo
Free tier	1K requests	1K credits	100MB/3d	✅ no card	1K credits
Success rate	56–92%	98.8%	85.88%	N/A	98.19%
Response time	10–11s	8.1s	0.54s	N/A	4.7s
IP pool	55M+	Managed	125M+	5M	Managed
JS rendering	✅	✅	✅	❌	✅
Anti-bot bypass	✅ Strong	✅ #1	Basic	❌	✅ Strong
Pricing traps	⚠️ 25x multiplier	⚠️ Credit math	✅ Transparent	⚠️ Targeting filters	✅ Opt-in only
Python SDK	✅	✅	✅	❌	❌
n8n / Zapier	✅	✅	✅	❌	❌

The Decision Framework

The right tool depends on one question: where is your actual bottleneck?

If your bottleneck is...	Use this
Anti-bot bypass on the hardest targets	Scrapfly
Billing predictability at scale	Scrape.do
All-in-one with browser automation	ZenRows
Raw proxy infrastructure, lowest latency	Decodo
Cost per GB on unprotected sites	Evomi

A few additional rules worth internalizing:

Don't mix categories. Using a scraping API when you need a raw proxy (or vice versa) creates unnecessary cost. If you already manage your own scraper and just need rotating IPs, Decodo or Evomi will outperform ZenRows or Scrapfly on price.

Test on your actual targets. Benchmark success rates are averages across a fixed set of test sites. Your target might be in the 21% success group or the 99% group depending on which anti-bot vendor it uses. Always run a cost estimate against your real URLs before committing to a plan.

The free tier is a test, not a tier. Every provider on this list offers a free starting point. Use it specifically to test your actual target sites — not to build a production pipeline. The behavior on heavily protected targets often diverges significantly from what you see on the demo endpoints.

FAQs

What's the difference between a proxy and a scraping API?

A proxy is a raw IP you route your own requests through. You handle everything: rotation, headers, retry logic, JS rendering, CAPTCHA solving. A scraping API is a managed service that handles all of that behind a single endpoint. Proxies are cheaper per GB; scraping APIs save engineering time and handle anti-bot bypass automatically.

Which option has the best free tier?

Scrape.do offers 1,000 free credits with no credit card required. ZenRows gives 1,000 requests on a 14-day trial. Scrapfly gives 1,000 credits with no expiry. Evomi has a free trial for residential proxies with no card needed. Decodo offers 100MB for 3 days with card verification (no charge).

Can I use these with Python?

Yes, all five work with Python's requests library. Scrapfly also has a dedicated SDK (pip install scrapfly-sdk) with retry logic built in. ZenRows offers a Python SDK as well. Decodo and Evomi work through standard proxy authentication.

What's the actual cost for scraping Amazon at scale?

At 100K requests/month on heavily protected targets like Amazon: Scrapfly (~30 credits/request on $100 Pro plan) = ~3,333 requests before overage. Scrape.do (opt-in only, ~$0.12/1K on Starter) = roughly $12 for 100K basic requests, more if you enable all features. ZenRows (25x multiplier active) = $0.10 × 25 × 100 = $250 on Business plan. Run the math on your actual use case before choosing.

Do these work with AI agents and LLMs?

Yes. Scrapfly has native integrations with LangChain and LlamaIndex. ZenRows connects to n8n, Zapier, and Make. Scrape.do returns markdown output that feeds directly into LLM context. For MCP-based agent workflows, all five expose REST APIs that can be wrapped as MCP tools.

Final Thoughts

Most web scraping projects fail not because the code is wrong, but because the data layer wasn't production-tested.

The proxy choice determines whether your system hits a 98% success rate or a 55% success rate. Whether your monthly bill is what you budgeted or five times that. Whether your team is debugging proxy failures at 2am or shipping features.

If you need one place to start: Scrape.do for reliable, predictable scraping at the best entry price. Decodo if you need raw proxy infrastructure at scale. Scrapfly if success rate on the hardest targets is non-negotiable.

Test on your actual targets. Budget based on the real multipliers, not the headline rate. Ship something that works in production.

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

How I Automated My Investment Research With 50 Lines of Python

Kevin Meneses González — Wed, 29 Apr 2026 11:11:08 +0000

The Problem: Too Much Noise, Not Enough Signal

A while ago, my daily investment routine looked like this:

Open multiple tabs
Check stock prices
Compare volume
Look at charts
Scan for opportunities

Every day, the same process.

And the problem wasn't time alone.

It was inconsistency.

Some days I would miss good setups.
Other days I would overanalyze everything.

Because I was relying on manual effort.

The Shift: From Checking Stocks to Filtering Them

At some point, I realized something simple:

I don't need more information. I need better filtering.

Instead of checking stocks one by one, I decided to build a system that:

Monitors a list of stocks automatically
Applies predefined conditions
Shows only the ones worth analyzing

That's when I built a simple Python watchlist.

What This System Actually Does

The idea is straightforward:

Define a list of stocks you care about
Define conditions that matter to you
Let the script filter the market

Instead of asking:

"What should I check today?"

You get:

"These are the stocks that meet your criteria today."

Step 1: Define Your Watchlist

This is your universe of interest.

WATCHLIST = ["AAPL", "MSFT", "TSLA", "NVDA", "AMZN"]

This list can include:

Stocks you own
Stocks you are tracking
Potential opportunities
High-volume or trending assets

The watchlist gives structure to your process.

Step 2: Define Your Conditions

Now comes the key part.

You define what "interesting" means.

CONDITIONS = {
    "min_price": 100,
    "min_volume": 1_000_000,
    "min_change_percent": 2
}

This means:

Only stocks above $100
With significant volume
And at least 2% daily movement

You are encoding your thinking into rules.

Step 3: Fetch Real-Time Data

To make this work, we need reliable data.

This is where EODHD comes in.

import requests

API_KEY = "YOUR_API_KEY"

def get_stock_data(symbol):
    url = f"https://eodhd.com/api/real-time/{symbol}?api_token={API_KEY}&fmt=json"
    response = requests.get(url)
    return response.json()

This gives us:

Current price
Volume
Daily change

Everything needed to evaluate our conditions.

Step 4: Apply the Logic

Now we combine everything.

def meets_conditions(data):
    price = data.get("close", 0)
    volume = data.get("volume", 0)
    change_percent = data.get("change_p", 0)

    return (
        price >= CONDITIONS["min_price"] and
        volume >= CONDITIONS["min_volume"] and
        change_percent >= CONDITIONS["min_change_percent"]
    )

Step 5: Filter the Market

results = []

for symbol in WATCHLIST:
    data = get_stock_data(symbol)

    if meets_conditions(data):
        results.append({
            "symbol": symbol,
            "price": data.get("close"),
            "volume": data.get("volume"),
            "change_percent": data.get("change_p")
        })

Step 6: Get a Clean Output

if results:
    print("Stocks that meet your conditions:\n")

    for stock in results:
        print(f"{stock['symbol']}")
        print(f"Price: {stock['price']}")
        print(f"Volume: {stock['volume']}")
        print(f"Change %: {stock['change_percent']}")
        print("-" * 30)
else:
    print("No stocks matched your conditions today.")

What Changed for Me

Before this system:

I checked everything manually
I wasted time on irrelevant stocks
I had no consistent process

After:

I only see filtered opportunities
I focus on what matters
I save hours every week

The script doesn't make decisions for me.

It removes the noise before I make them.

The Hidden Cost of API Calls

This is something most people ignore.

When you build systems like this, API usage matters.

Let's say you track:

30 stocks
Every hour

That quickly becomes thousands of API calls per month.

And here's the problem:

Not all APIs handle this well.

Some have:

Strict limits
Unstable responses
Delayed data

So while they look "cheap", they cost you in:

Time
Errors
Missed opportunities

Why Data Quality Matters

In a system like this, everything depends on data.

If your data is wrong:

Your filters are wrong
Your signals are wrong
Your decisions are wrong

That's why using a provider like EODHD makes a difference.

Because it gives you:

Reliable real-time data
Clean and consistent responses
Coverage across multiple assets

This is what allows the system to actually work.

FAQs

Do I need advanced Python skills?

No. If you understand basic Python (loops, functions, variables), you can build this.

Can I change the conditions?

Yes. That's the core idea.

You can adapt the script to:

Momentum strategies
Long-term filters
Volatility setups

Is this a trading bot?

No.

This is a filtering system.

It helps you decide what to analyze, not what to buy.

Are free APIs enough?

For testing, yes.

For real systems, usually not.

Because reliability becomes critical.

Why use EODHD?

Because it allows you to:

Access real-time market data
Build consistent workflows
Scale your scripts without constant issues

Final Thought

Most people try to improve their investing by consuming more information.

But the real advantage comes from filtering better.

Because:

You don't need more data
You need less noise

If you want to build your own watchlist and automate your investment research with Python, the first step is having reliable data.

You can explore EODHD and start building your own system from scratch.

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

How I Built a Real-Time Crypto Dashboard with CoinStats API and React

Kevin Meneses González — Mon, 27 Apr 2026 08:45:59 +0000

Most crypto APIs are either free and broken, or reliable and expensive.

If you've tried to build something real with the usual suspects:

CoinGecko rate-limits you at 10–30 req/min before you even have a key,
CoinMarketCap puts historical data behind a $29+/month paywall,
Binance API only knows assets that trade on Binance.

You hit the wall before the first component renders.

I built a real-time crypto dashboard using CoinStats API — deployed, fully functional, four data sections running in parallel. This article covers the actual implementation: the endpoints I used, the decisions I made, and the bugs I hit that the documentation doesn't mention.

The full source is on GitHub: github.com/Kevinelectronics/cryptodashboard

Why the Usual Options Don't Work

Before the solution, the problem. Because the tradeoffs matter when you're architecting a dashboard with multiple data types running simultaneously.

API	Free Rate Limit	Historical Charts	News Feed	Global Stats
CoinGecko	~10–30 req/min, no key	✅ limited	❌	✅ `/global`
CoinMarketCap	Latest quote only	❌ paid	❌ free tier	✅
Binance	Exchange assets only	✅ OHLCV	❌	❌
CoinStats	100 req/min with key	✅ `/coins/{id}/charts`	✅ `/news`	✅ `/markets`

The news endpoint alone eliminates a second API integration. For a dashboard that needs coins + charts + market context + news from a single base URL, CoinStats is the only free-tier option that doesn't break the architecture.

What I Built

A single-page React app with four vertical sections:

Global Market Stats — 4 cards: Total Market Cap, 24h Volume, BTC Dominance, Alt Dominance
Coin Table — Top 50 coins, sortable by any column, with real-time search by name or symbol
Price Chart — Appears inline when you click a coin. Color and gradient change based on price direction. Period selector: 1D, 1W, 1M, 3M, 6M, 1Y
News Feed — 6 recent crypto news items with image, source, and timestamp

Stack: Vite 5 + React 19, JavaScript (no TypeScript), Tailwind CSS v4, Recharts. Dark mode only — GitHub-style #0d1117 background.

[Screenshot: full dashboard view — global stats cards at top, coin table below, news grid at bottom]

What the API Actually Returns

Real JSON shapes before any component code. Technical readers need to see the structure before trusting an API.

`GET /coins?limit=50`

{
  "result": [
    {
      "id": "bitcoin",
      "symbol": "BTC",
      "name": "Bitcoin",
      "icon": "https://static.coinstats.app/coins/1650455588819.png",
      "rank": 1,
      "price": 67420.34,
      "priceChange1h": 0.21,
      "priceChange1d": 2.14,
      "priceChange1w": -3.45,
      "volume": 28940000000,
      "marketCap": 1324000000000,
      "availableSupply": 19700000,
      "totalSupply": 21000000
    }
  ],
  "meta": { "itemCount": 50, "totalCount": 14000 }
}

Use priceChange1d and priceChange1w directly — they're already percentages. Don't compute (price - price24hAgo) / price24hAgo * 100 manually. The API does that for you.

`GET /markets`

{
  "totalMarketCap": 2340000000000,
  "totalVolume": 98700000000,
  "btcDominance": 52.4,
  "altDominance": 47.6,
  "marketCapChange": 1.8
}

⚠️ Gotcha — the endpoint is /markets, not /global. The docs reference a /global endpoint in older versions. It returns a 404. If you spend 20 minutes wondering why your global stats call keeps failing, this is why. The correct endpoint is /markets.

`GET /coins/{id}/charts?period=1w`

{
  "result": [
    [1714000000000, 62100.5, 0.00092, 31200000000],
    [1714086400000, 63450.2, 0.00094, 29800000000]
  ]
}

Each item is [timestamp, price, priceBtc, volume] — four values, not two. Most tutorials show data.map(([time, price]) => ...) and silently discard priceBtc and volume. That's fine if you only need price, but you should destructure explicitly so it's clear:

result.map(([time, price, priceBtc, volume]) => ({
  time: new Date(time).toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
  price,
  volume
}))

`GET /news?limit=6`

{
  "news": [
    {
      "id": "abc123",
      "title": "Bitcoin hits new monthly high amid ETF inflows",
      "description": "Spot ETFs saw $400M in net inflows...",
      "feedName": "CoinDesk",
      "imgUrl": "https://...",
      "link": "https://...",
      "shareURL": "https://...",
      "reactionsCount": 42,
      "publishedAt": "2024-04-26T08:00:00Z"
    }
  ]
}

imgUrl is ready to drop into an <img> tag. publishedAt is ISO 8601 — pass it to new Date() and format from there.

Project Setup

npm create vite@latest crypto-dashboard -- --template react
cd crypto-dashboard
npm install recharts
npm install -D tailwindcss @tailwindcss/vite

Tailwind v4 configuration in vite.config.js:

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import tailwindcss from '@tailwindcss/vite'

export default defineConfig({
  plugins: [react(), tailwindcss()]
})

In src/index.css:

@import "tailwindcss";

Create .env in the root:

VITE_COINSTATS_KEY=your_api_key_here

Access it everywhere as import.meta.env.VITE_COINSTATS_KEY.

The Data Hooks

Four endpoints, four hooks. Each follows the same pattern: loading state, error state, cleanup flag on unmount.

`useCoinList` — The main table data

// hooks/useCoinList.js
import { useState, useEffect } from 'react';

const BASE = 'https://openapiv1.coinstats.app';
const HEADERS = { 'X-API-KEY': import.meta.env.VITE_COINSTATS_KEY };

export function useCoinList(limit = 50) {
  const [coins, setCoins] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let cancelled = false;

    async function fetchCoins() {
      try {
        const res = await fetch(`${BASE}/coins?limit=${limit}`, { headers: HEADERS });
        if (!res.ok) throw new Error(`HTTP ${res.status}`);
        const { result } = await res.json();
        if (!cancelled) setCoins(result);
      } catch (err) {
        if (!cancelled) setError(err.message);
      } finally {
        if (!cancelled) setLoading(false);
      }
    }

    fetchCoins();
    return () => { cancelled = true; };
  }, [limit]);

  return { coins, loading, error };
}

The cancelled = true pattern is not optional. If the user navigates away or a parent re-renders before the fetch resolves, React throws a warning about setting state on an unmounted component. The cleanup function silences it by checking the flag before every setState call.

`useMarketStats` — Global market cards

// hooks/useMarketStats.js
import { useState, useEffect } from 'react';

export function useMarketStats() {
  const [stats, setStats] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    let cancelled = false;
    fetch('https://openapiv1.coinstats.app/markets', {
      headers: { 'X-API-KEY': import.meta.env.VITE_COINSTATS_KEY }
    })
      .then(res => res.json())
      .then(data => { if (!cancelled) { setStats(data); setLoading(false); } });
    return () => { cancelled = true; };
  }, []);

  return { stats, loading };
}

`useChartData` — Price history per coin

// hooks/useChartData.js
import { useState, useEffect, useCallback } from 'react';

const BASE = 'https://openapiv1.coinstats.app';
const HEADERS = { 'X-API-KEY': import.meta.env.VITE_COINSTATS_KEY };

export function useChartData(coinId, period = '1w') {
  const [chartData, setChartData] = useState([]);
  const [loading, setLoading] = useState(false);

  const fetchChart = useCallback(async () => {
    if (!coinId) return;
    setLoading(true);
    let cancelled = false;

    try {
      const res = await fetch(
        `${BASE}/coins/${coinId}/charts?period=${period}`,
        { headers: HEADERS }
      );
      const { result } = await res.json();
      const formatted = result.map(([time, price]) => ({
        time: new Date(time).toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
        price
      }));
      if (!cancelled) setChartData(formatted);
    } finally {
      if (!cancelled) setLoading(false);
    }

    return () => { cancelled = true; };
  }, [coinId, period]);

  useEffect(() => { fetchChart(); }, [fetchChart]);

  return { chartData, loading };
}

useCallback wraps the fetch function so it only recreates when coinId or period changes. Without it, every parent re-render generates a new function reference → triggers useEffect → fires another fetch → infinite loop. With the wrong deps array, your chart refetches on every keystroke in the search box.

`useNews` — News feed

// hooks/useNews.js
import { useState, useEffect } from 'react';

export function useNews(limit = 6) {
  const [news, setNews] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    let cancelled = false;
    fetch(`https://openapiv1.coinstats.app/news?limit=${limit}`, {
      headers: { 'X-API-KEY': import.meta.env.VITE_COINSTATS_KEY }
    })
      .then(res => res.json())
      .then(data => { if (!cancelled) { setNews(data.news); setLoading(false); } });
    return () => { cancelled = true; };
  }, [limit]);

  return { news, loading };
}

Section 1: Global Market Stats

[Screenshot: 4 stat cards — Total Market Cap, 24h Volume, BTC Dominance, Alt Dominance — on dark background]

// components/MarketStats.jsx
import { useMarketStats } from '../hooks/useMarketStats';

function StatCard({ label, value, change }) {
  return (
    <div className="bg-[#161b22] rounded-xl p-5 border border-[#30363d]">
      <p className="text-[#8b949e] text-sm mb-1">{label}</p>
      <p className="text-white text-2xl font-semibold">{value}</p>
      {change !== undefined && (
        <p className={`text-sm mt-1 ${change >= 0 ? 'text-green-400' : 'text-red-400'}`}>
          {change >= 0 ? '+' : ''}{change?.toFixed(2)}%
        </p>
      )}
    </div>
  );
}

export function MarketStats() {
  const { stats, loading } = useMarketStats();

  if (loading) return (
    <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
      {[...Array(4)].map((_, i) => (
        <div key={i} className="bg-[#161b22] rounded-xl p-5 h-24 animate-pulse border border-[#30363d]" />
      ))}
    </div>
  );

  return (
    <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
      <StatCard
        label="Total Market Cap"
        value={`$${(stats.totalMarketCap / 1e12).toFixed(2)}T`}
        change={stats.marketCapChange}
      />
      <StatCard
        label="24h Volume"
        value={`$${(stats.totalVolume / 1e9).toFixed(0)}B`}
      />
      <StatCard label="BTC Dominance" value={`${stats.btcDominance?.toFixed(1)}%`} />
      <StatCard label="Alt Dominance" value={`${stats.altDominance?.toFixed(1)}%`} />
    </div>
  );
}

The skeleton uses animate-pulse from Tailwind — same dimensions as the real card, no layout shift when data arrives. No spinners anywhere in the app. Spinners are disorienting because the user can't tell how much is loading. Skeletons show exactly what's coming.

Section 2: Coin Table with Sort and Search

[Screenshot: coin table with sortable headers, BTC row highlighted, search bar active]

// components/CoinTable.jsx
import { useState, useMemo } from 'react';
import { useCoinList } from '../hooks/useCoinList';

const COLUMNS = [
  { key: 'rank', label: '#' },
  { key: 'name', label: 'Name' },
  { key: 'price', label: 'Price' },
  { key: 'priceChange1h', label: '1h %' },
  { key: 'priceChange1d', label: '24h %' },
  { key: 'priceChange1w', label: '7d %' },
  { key: 'marketCap', label: 'Market Cap' },
];

export function CoinTable({ onSelectCoin }) {
  const { coins, loading } = useCoinList(50);
  const [query, setQuery] = useState('');
  const [sortKey, setSortKey] = useState('rank');
  const [sortDir, setSortDir] = useState(1); // 1 = asc, -1 = desc

  function handleSort(key) {
    if (key === sortKey) {
      setSortDir(sortDir * -1); // toggle direction
    } else {
      setSortKey(key);
      setSortDir(1);
    }
  }

  const filtered = useMemo(() => {
    const q = query.toLowerCase();
    return coins.filter(c =>
      c.name.toLowerCase().includes(q) || c.symbol.toLowerCase().includes(q)
    );
  }, [coins, query]);

  const sorted = useMemo(() => {
    return [...filtered].sort((a, b) => {
      const aVal = a[sortKey] ?? 0;
      const bVal = b[sortKey] ?? 0;
      if (typeof aVal === 'string') return sortDir * aVal.localeCompare(bVal);
      return sortDir * (aVal - bVal);
    });
  }, [filtered, sortKey, sortDir]);

  if (loading) return (
    <div className="space-y-2">
      {[...Array(10)].map((_, i) => (
        <div key={i} className="h-12 bg-[#161b22] rounded animate-pulse border border-[#30363d]" />
      ))}
    </div>
  );

  return (
    <div>
      <input
        type="text"
        placeholder="Search coin or symbol..."
        value={query}
        onChange={e => setQuery(e.target.value)}
        className="mb-4 w-full bg-[#161b22] border border-[#30363d] rounded-lg px-4 py-2 text-white placeholder-[#8b949e] focus:outline-none focus:border-blue-500"
      />
      <div className="overflow-x-auto">
        <table className="w-full text-sm">
          <thead>
            <tr className="text-[#8b949e] border-b border-[#30363d]">
              {COLUMNS.map(col => (
                <th
                  key={col.key}
                  onClick={() => handleSort(col.key)}
                  className="py-3 px-4 text-left cursor-pointer select-none hover:text-white transition-colors"
                >
                  {col.label}
                  {sortKey === col.key && (sortDir === 1 ? ' ↑' : ' ↓')}
                </th>
              ))}
            </tr>
          </thead>
          <tbody>
            {sorted.map(coin => (
              <tr
                key={coin.id}
                onClick={() => onSelectCoin(coin)}
                className="border-b border-[#21262d] hover:bg-[#161b22] cursor-pointer transition-colors"
              >
                <td className="py-3 px-4 text-[#8b949e]">{coin.rank}</td>
                <td className="py-3 px-4">
                  <div className="flex items-center gap-2">
                    <img src={coin.icon} alt={coin.name} className="w-6 h-6 rounded-full" />
                    <span className="text-white font-medium">{coin.name}</span>
                    <span className="text-[#8b949e]">{coin.symbol}</span>
                  </div>
                </td>
                <td className="py-3 px-4 text-white font-mono">
                  ${coin.price >= 1 ? coin.price.toLocaleString() : coin.price.toFixed(6)}
                </td>
                {['priceChange1h', 'priceChange1d', 'priceChange1w'].map(k => (
                  <td key={k} className={`py-3 px-4 font-mono ${coin[k] >= 0 ? 'text-green-400' : 'text-red-400'}`}>
                    {coin[k] >= 0 ? '+' : ''}{coin[k]?.toFixed(2)}%
                  </td>
                ))}
                <td className="py-3 px-4 text-[#8b949e]">
                  ${(coin.marketCap / 1e9).toFixed(1)}B
                </td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
    </div>
  );
}

sortDir * -1 toggles between ascending and descending with one multiplication. No switch statement, no ternary chain. useMemo on both filtered and sorted means the search and sort operations don't re-run on unrelated renders — only when coins, query, sortKey, or sortDir actually change.

Section 3: The Inline Price Chart

[Screenshot: price chart expanded below a coin row — green gradient, period selector 1W active]

The chart appears inline when the user clicks a coin row. It doesn't navigate anywhere. onSelectCoin in the parent sets a state variable; the chart renders conditionally below the table.

// components/PriceChart.jsx
import { useState, useMemo } from 'react';
import {
  AreaChart, Area, XAxis, YAxis, Tooltip,
  ResponsiveContainer, defs, linearGradient, stop
} from 'recharts';
import { useChartData } from '../hooks/useChartData';

const PERIODS = ['1d', '1w', '1m', '3m', '6m', '1y'];

export function PriceChart({ coin }) {
  const [period, setPeriod] = useState('1w');
  const { chartData, loading } = useChartData(coin.id, period);

  // Determine price direction for the selected period
  const isUp = useMemo(() => {
    if (chartData.length < 2) return true;
    return chartData[chartData.length - 1].price >= chartData[0].price;
  }, [chartData]);

  const color = isUp ? '#22c55e' : '#ef4444'; // green-500 / red-500

  return (
    <div className="bg-[#161b22] rounded-xl p-5 border border-[#30363d] mt-2">
      <div className="flex items-center justify-between mb-4">
        <div>
          <span className="text-white font-semibold text-lg">{coin.name}</span>
          <span className="text-[#8b949e] ml-2">{coin.symbol}</span>
        </div>
        <div className="flex gap-1">
          {PERIODS.map(p => (
            <button
              key={p}
              onClick={() => setPeriod(p)}
              className={`px-3 py-1 rounded text-sm uppercase transition-colors ${
                period === p
                  ? 'bg-blue-600 text-white'
                  : 'text-[#8b949e] hover:text-white'
              }`}
            >
              {p}
            </button>
          ))}
        </div>
      </div>

      {loading ? (
        <div className="h-64 animate-pulse bg-[#0d1117] rounded" />
      ) : (
        <ResponsiveContainer width="100%" height={260}>
          <AreaChart data={chartData}>
            <defs>
              <linearGradient id="chartGradient" x1="0" y1="0" x2="0" y2="1">
                <stop offset="5%" stopColor={color} stopOpacity={0.3} />
                <stop offset="95%" stopColor={color} stopOpacity={0} />
              </linearGradient>
            </defs>
            <XAxis
              dataKey="time"
              tick={{ fill: '#8b949e', fontSize: 11 }}
              axisLine={false}
              tickLine={false}
              interval="preserveStartEnd"
            />
            <YAxis
              domain={['auto', 'auto']}
              tick={{ fill: '#8b949e', fontSize: 11 }}
              axisLine={false}
              tickLine={false}
              tickFormatter={v => `$${v >= 1000 ? (v / 1000).toFixed(1) + 'k' : v.toFixed(2)}`}
            />
            <Tooltip
              contentStyle={{ background: '#161b22', border: '1px solid #30363d', borderRadius: 8 }}
              labelStyle={{ color: '#8b949e' }}
              formatter={v => [`$${v.toLocaleString()}`, 'Price']}
            />
            <Area
              type="monotone"
              dataKey="price"
              stroke={color}
              strokeWidth={2}
              fill="url(#chartGradient)"
              dot={false}
            />
          </AreaChart>
        </ResponsiveContainer>
      )}
    </div>
  );
}

The gradient ID chartGradient is static — if you render multiple charts at once, give each a unique ID. In this dashboard there's only one chart visible at a time, so it's not an issue.

isUp compares chartData[0].price against chartData[chartData.length - 1].price. When the user switches from 1W to 1M, the hook refetches, chartData updates, isUp recalculates, and the color flips automatically. No extra state needed.

Section 4: News Feed

[Screenshot: 2x3 news grid — dark cards, article images, source badge and timestamp]

// components/NewsFeed.jsx
import { useNews } from '../hooks/useNews';

function NewsCard({ item }) {
  const date = new Date(item.publishedAt).toLocaleDateString('en-US', {
    month: 'short', day: 'numeric', year: 'numeric'
  });

  return (
    <a
      href={item.link}
      target="_blank"
      rel="noopener noreferrer"
      className="bg-[#161b22] rounded-xl overflow-hidden border border-[#30363d] hover:border-blue-500 transition-colors flex flex-col"
    >
      {item.imgUrl && (
        <img
          src={item.imgUrl}
          alt={item.title}
          className="w-full h-40 object-cover"
          onError={e => { e.target.style.display = 'none'; }}
        />
      )}
      <div className="p-4 flex flex-col flex-1">
        <p className="text-white font-medium text-sm leading-snug line-clamp-2 mb-2">
          {item.title}
        </p>
        <div className="mt-auto flex items-center justify-between text-xs text-[#8b949e]">
          <span>{item.feedName}</span>
          <span>{date}</span>
        </div>
      </div>
    </a>
  );
}

export function NewsFeed() {
  const { news, loading } = useNews(6);

  if (loading) return (
    <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
      {[...Array(6)].map((_, i) => (
        <div key={i} className="h-64 bg-[#161b22] rounded-xl animate-pulse border border-[#30363d]" />
      ))}
    </div>
  );

  return (
    <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
      {news.map(item => <NewsCard key={item.id} item={item} />)}
    </div>
  );
}

onError on the image handles broken CDN URLs gracefully — hides the image element instead of showing a broken icon. Small detail, but news images break often enough that it matters in production.

Composing the App

// App.jsx
import { useState } from 'react';
import { MarketStats } from './components/MarketStats';
import { CoinTable } from './components/CoinTable';
import { PriceChart } from './components/PriceChart';
import { NewsFeed } from './components/NewsFeed';

export default function App() {
  const [selectedCoin, setSelectedCoin] = useState(null);

  return (
    <div className="min-h-screen bg-[#0d1117] text-white">
      <div className="max-w-7xl mx-auto px-4 py-8 space-y-10">

        <header>
          <h1 className="text-2xl font-bold">Crypto Dashboard</h1>
          <p className="text-[#8b949e] text-sm mt-1">Powered by CoinStats API</p>
        </header>

        <section>
          <h2 className="text-lg font-semibold mb-4">Market Overview</h2>
          <MarketStats />
        </section>

        <section>
          <h2 className="text-lg font-semibold mb-4">Top 50 Coins</h2>
          <CoinTable onSelectCoin={setSelectedCoin} />
          {selectedCoin && <PriceChart coin={selectedCoin} />}
        </section>

        <section>
          <h2 className="text-lg font-semibold mb-4">Latest News</h2>
          <NewsFeed />
        </section>

      </div>
    </div>
  );
}

No router. No context. No global state manager. One useState at the top level passes the selected coin down to PriceChart. For a single-page dashboard, this is exactly as complex as it needs to be.

How Many API Calls Does the Dashboard Make?

At cold load, before any user interaction:

Call	Endpoint	Fires
Market stats	`GET /markets`	On mount
Coin list	`GET /coins?limit=50`	On mount
News	`GET /news?limit=6`	On mount
Price chart	`GET /coins/{id}/charts?period=1w`	On coin click

3 calls on load. 1 additional on first coin click. 1 per period change.

CoinStats free tier allows 100 req/min. The dashboard at idle uses 3 calls total. Even with aggressive period switching (6 periods × 5 coins), you'd use ~33 calls — well within limits.

API Key Security

In a Vite app, VITE_ prefixed variables are bundled into the JavaScript. Anyone who opens DevTools → Sources can read your key.

For this dashboard as a demo project, that's an acceptable tradeoff.

For a public production deployment:

Option 1 — Cloudflare Worker proxy: Your frontend calls https://your-worker.workers.dev/coins, the worker injects X-API-KEY server-side and forwards to CoinStats. The key never appears in the browser bundle. Free tier is 100,000 requests/day.

Option 2 — Express backend: Same logic, more control, more infrastructure. Only worth it if you're already running a server.

The architecture change is minimal — replace the base URL constant in your hooks with your proxy URL. Everything else stays identical.

FAQ

Do I need a backend to use CoinStats API?

No. All four endpoints used in this dashboard work directly from the browser. A backend is only necessary if you want to keep your API key out of the JS bundle.

How do I protect the API key in production?

Use a Cloudflare Worker as a transparent proxy. It injects the key server-side before forwarding requests to CoinStats. Your frontend never sees the key. Setup takes about 15 minutes.

Why Recharts instead of Chart.js or D3?

Recharts is declarative and built for React. Chart.js requires an imperative configuration model that fights React's rendering cycle. D3 is powerful for custom visualizations but overkill for a standard price area chart. Recharts ships ResponsiveContainer which handles resize automatically — no ResizeObserver wiring needed.

Why no TypeScript?

Deliberate choice for this project. The API responses are well-structured and the codebase is small enough that the overhead of maintaining types doesn't pay off. In a larger app or a team project, TypeScript makes sense.

Does this work with React 19?

Yes. All hooks used — useState, useEffect, useMemo, useCallback — are stable across React 16+. The cancelled flag cleanup pattern works identically in React 19.

Can I add portfolio tracking without a backend?

Yes, for local tracking. Store holdings as { coinId, amount } in localStorage, fetch current prices from /coins, and compute portfolio value client-side with useMemo. For cross-device sync, you need a backend.

Wrapping Up

Four data sections. Four hooks. One API.

The architecture decisions here aren't clever — they're the minimum viable structure for a dashboard that doesn't fight React: custom hooks that own their fetch lifecycle, cleanup flags that prevent stale state updates, useMemo for derived data, and a single state variable to coordinate the chart.

CoinStats API handles the rest: coins, charts, market context, and news from one base URL, on a free tier that doesn't require a credit card.

The full source is available on GitHub — clone it, break it, and build something better: github.com/Kevinelectronics/cryptodashboard

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

How to Get Historical Stock Data for Free with Python (and Actually Use It)

Kevin Meneses González — Sat, 25 Apr 2026 09:51:28 +0000

Most people searching for free stock data end up in the same loop.

They find Yahoo Finance. The yfinance library seems perfect — until it breaks in production, returns inconsistent data, or silently changes its response format because it's scraping an unofficial endpoint.

Then they try pandas-datareader. Then Alpha Vantage with a key that throttles after 5 requests per minute. Then a random GitHub repo with 200 stars and no commits since 2022.

If you're:

building a backtesting engine,
training a financial ML model,
or just trying to get clean OHLCV data without paying enterprise prices,

this matters.

The real problem isn't that free historical stock data doesn't exist. It's that most free options are brittle — they work in a Jupyter notebook and fail the moment you put them in a real project.

Why Unofficial APIs Break (and What to Use Instead)

yfinance is the most-used Python library for historical stock data. It's also reverse-engineered from Yahoo Finance's internal API — which means Yahoo can break it without notice, and they do.

Here's what developers typically run into:

Responses return None on tickers that worked yesterday
Rate limits hit without clear error messages
Adjusted close calculations differ from official sources
No support, no SLA, no guarantee of tomorrow

It's fine for quick experiments. It's not fine for anything you're shipping.

The alternative is using an API designed for developers — with documented endpoints, stable JSON responses, and a free tier that's actually functional.

That's exactly what EODHD gives you.

What Is EODHD and What's Free

EODHD (End of Day Historical Data) is a financial data API covering 150,000+ tickers across 60+ global exchanges, including US stocks, ETFs, crypto, forex, and indices. It's been running for over 7 years with 24/7 live support.

The free plan gives you:

20 API calls per day — no credit card required
End-of-day OHLCV data for any ticker in the past year
Access to the full ticker universe (not just a handful of symbols)
A demo key that works immediately for AAPL.US, TSLA.US, AMZN.US, BTC-USD, and EUR-USD — useful for testing your code before registering

For developers building and testing locally, 20 calls/day is enough to pull a year of daily data for multiple tickers and validate your entire pipeline before upgrading.

👉 Get your free EODHD API key here — no credit card, instant access.

Getting Historical Stock Data in Python: Step by Step

All examples below use only requests and pandas — no custom library needed. Just your API key and standard Python.

1. The base request

import requests
import pandas as pd

API_KEY = "YOUR_API_KEY"  # get yours free at eodhd.com/register

def get_eod(ticker, start, end):
    url = f"https://eodhd.com/api/eod/{ticker}"
    params = {
        "api_token": API_KEY,
        "fmt": "json",
        "from": start,
        "to": end,
        "order": "a"   # ascending — oldest first
    }
    response = requests.get(url, params=params)
    response.raise_for_status()
    df = pd.DataFrame(response.json())
    df["date"] = pd.to_datetime(df["date"])
    df = df.set_index("date")
    return df

# Fetch one year of daily OHLCV for Apple
df = get_eod("AAPL.US", "2024-01-01", "2024-12-31")
print(df.head())

Output:

            open    high     low   close  adjusted_close      volume
date
2024-01-02  185.47  186.03  183.61  185.17  184.23          79013800
2024-01-03  183.80  184.40  182.00  184.25  183.33          55153200
2024-01-04  182.15  183.09  180.63  181.23  180.32          53307100

The response includes both raw close and adjusted_close — already corrected for splits and dividends. That field is the one you should always use for returns, backtesting, and ML features. Raw close without adjustment produces incorrect results around stock split events, and it's a silent bug that's easy to miss.

2. Build a multi-ticker price matrix

tickers = ["AAPL.US", "MSFT.US", "GOOGL.US", "NVDA.US"]
frames = {}

for ticker in tickers:
    df = get_eod(ticker, "2024-01-01", "2024-12-31")
    frames[ticker] = df["adjusted_close"]

prices = pd.DataFrame(frames)
print(prices.tail(3))

Output:

            AAPL.US   MSFT.US   GOOGL.US  NVDA.US
date
2024-12-26  258.60    432.10    192.34    134.25
2024-12-27  255.42    428.78    190.11    131.88
2024-12-28  253.12    426.45    189.08    129.64

3. Compute returns and volatility

# Daily returns
returns = prices.pct_change().dropna()

# Annualized volatility (252 trading days)
volatility = returns.std() * (252 ** 0.5)
print("Annualized Volatility:")
print(volatility.round(4))

# Cumulative return over the period
cumulative = (1 + returns).prod() - 1
print("\nCumulative Return 2024:")
print((cumulative * 100).round(2))

Output:

Annualized Volatility:
AAPL.US     0.2341
MSFT.US     0.2019
GOOGL.US    0.2678
NVDA.US     0.5812

Cumulative Return 2024:
AAPL.US      30.12
MSFT.US      17.84
GOOGL.US     35.47
NVDA.US     171.20

From here you can build correlation matrices, Sharpe ratios, or any portfolio analytics layer you need. The data is clean enough that none of this requires sanitization first. That's rare with free sources.

Why Data Quality Is Not a Detail — It's the Foundation

Here's something most tutorials skip entirely.

A backtesting model running on bad data doesn't tell you your strategy is wrong. It tells you the data is wrong. And you won't know which one it is until you've spent days debugging a problem that never existed in the first place.

Bad stock data comes in predictable forms.

Unadjusted splits. Apple did a 4:1 split in August 2020. If your data doesn't account for that, you'll see a sudden 75% price drop in your chart. Your model will flag it as a crash event. Your backtester will generate a massive false signal. Everything downstream breaks — quietly.

Survivorship bias. Many free datasets only include companies that still exist. Lehman Brothers, Enron, Bear Stearns — gone from the index, gone from the data. If your training set only has survivors, your model learns from a market that never actually existed. The result: systematically overoptimistic backtests that fall apart in live trading.

Timezone mismatches. A closing price timestamped ambiguously — UTC vs exchange local time — puts data from different sessions in the same row when you join two sources. This is the kind of bug that corrupts results in a way that's nearly impossible to catch visually.

Missing trading days. Some free sources skip market holidays or return empty rows instead of omitting those dates cleanly. A moving average computed across a gap behaves differently than one across a clean series — and the difference shows up as noise in your signals.

EODHD addresses all of these directly. Adjusted close prices are normalized for splits and dividends. Data gaps follow exchange convention. Timestamps are consistent. And the data is sourced from multiple providers and cross-validated — the same institutional-grade pipeline that powers financial products, accessible through a simple REST endpoint.

This is the difference between data that looks fine in a notebook and data you can actually trust in production.

Advanced Use Cases

Use Case 1: Correlation matrix for portfolio analysis

Understanding how assets move together is core to portfolio construction. A correlation matrix built on dirty data produces misleading diversification signals.

import matplotlib.pyplot as plt

# Daily returns matrix (already computed above)
corr = returns.corr()

fig, ax = plt.subplots(figsize=(7, 5))
im = ax.imshow(corr, cmap="coolwarm", vmin=-1, vmax=1)
plt.colorbar(im, ax=ax)

labels = [t.split(".")[0] for t in corr.columns]
ax.set_xticks(range(len(labels)))
ax.set_yticks(range(len(labels)))
ax.set_xticklabels(labels)
ax.set_yticklabels(labels)

for i in range(len(corr)):
    for j in range(len(corr)):
        ax.text(j, i, f"{corr.iloc[i, j]:.2f}", ha="center", va="center", fontsize=9)

plt.title("Return Correlation Matrix — 2024")
plt.tight_layout()
plt.savefig("correlation_matrix.png", dpi=150)

This outputs a clean matrix you can drop into a report or feed into mean-variance optimization. The correlation between NVDA and the other tech names in 2024 tells a clear story about factor exposure — something that only shows up cleanly with adjusted, consistent prices.

Use Case 2: RSI indicator from scratch

The Relative Strength Index (RSI) is one of the most common momentum indicators. Building it from raw OHLCV data — rather than relying on a TA library — gives you full control over the calculation and forces you to validate the underlying data at each step.

def compute_rsi(series, period=14):
    delta = series.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
    rs = avg_gain / avg_loss
    return 100 - (100 / (1 + rs))

df = get_eod("AAPL.US", "2024-01-01", "2024-12-31")
df["rsi_14"] = compute_rsi(df["adjusted_close"])

overbought = df[df["rsi_14"] > 70][["adjusted_close", "rsi_14"]]
oversold   = df[df["rsi_14"] < 30][["adjusted_close", "rsi_14"]]

print("Overbought periods:")
print(overbought.head())

print("\nOversold periods:")
print(oversold.head())

Output:

Overbought periods:
            adjusted_close  rsi_14
date
2024-03-05          169.12   71.34
2024-07-15          234.40   72.81

Oversold periods:
            adjusted_close  rsi_14
date
2024-04-19          165.00   28.42
2024-08-05          209.82   27.19

Clean adjusted prices matter here. If the data has a split event that isn't properly adjusted, the RSI values around that date will be meaningless — the price delta will look like a 75% single-day move and RSI will spike to extreme values for days, producing phantom overbought/oversold signals.

Use Case 3: Backtesting a moving average crossover

A classic entry point into systematic trading: go long when the 20-day SMA crosses above the 50-day, exit when it crosses back below.

df = get_eod("MSFT.US", "2023-01-01", "2024-12-31")

df["sma20"] = df["adjusted_close"].rolling(20).mean()
df["sma50"] = df["adjusted_close"].rolling(50).mean()

# Signal: 1 = long, 0 = flat
df["signal"]   = (df["sma20"] > df["sma50"]).astype(int)
df["position"] = df["signal"].shift(1)  # shift to avoid look-ahead bias

# Compare strategy vs buy-and-hold
df["market_return"]   = df["adjusted_close"].pct_change()
df["strategy_return"] = df["market_return"] * df["position"]

cumulative = df[["market_return", "strategy_return"]].dropna().cumsum()
cumulative.apply(lambda x: (1 + x).cumprod() - 1).plot(
    title="SMA Crossover vs Buy & Hold — MSFT 2023–2024",
    figsize=(10, 5)
)
plt.ylabel("Cumulative Return")
plt.tight_layout()
plt.savefig("backtest_result.png", dpi=150)

Note the shift(1) on the position — this prevents the strategy from using today's signal to trade at today's close, which would be look-ahead bias. Small detail. Large impact on results.

Two years of clean daily OHLCV. One API call. No parsing gymnastics.

Use Case 4: Multi-asset momentum ranking

Momentum strategies rank assets by recent return and rotate into top performers. This requires consistent, clean historical data across all assets in the universe — a place where data quality failures compound fast.

universe = [
    "AAPL.US", "MSFT.US", "GOOGL.US", "NVDA.US",
    "AMZN.US", "META.US", "TSLA.US", "JPM.US"
]

frames = {}
for ticker in universe:
    df = get_eod(ticker, "2024-01-01", "2024-12-31")
    frames[ticker] = df["adjusted_close"]

prices = pd.DataFrame(frames)

# 3-month momentum (~63 trading days)
momentum = prices.pct_change(63).iloc[-1].sort_values(ascending=False)

print("3-Month Momentum Ranking — end of 2024:")
print((momentum * 100).round(2).to_string())

Output:

3-Month Momentum Ranking — end of 2024:
NVDA.US     42.18
META.US     31.04
GOOGL.US    18.77
AAPL.US     12.43
AMZN.US     11.89
MSFT.US      8.21
TSLA.US      6.44
JPM.US       4.12

This ranking, run monthly on a broader universe, is the core of a momentum rotation strategy. The output is only as reliable as the price data underneath it. One ticker with a bad split adjustment skews the entire ranking.

Free vs Paid: What Changes When You Upgrade

Feature	Free (20 calls/day)	From $19.99/mo
Historical depth	1 year	30+ years
Daily call limit	20	100,000
Real-time WebSocket	❌	✅ (from $29.99)
Intraday data (1m, 5m)	❌	✅
Fundamental data (P/E, EPS)	❌	✅
Bulk exchange download	❌	✅
Crypto + Forex + ETFs	Limited	Full coverage
Splits & dividends history	1 year	Full history

For prototyping and learning, the free tier is genuinely enough. When you need production depth — multi-year histories, intraday resolution, or fundamentals for DCF models — the starter plan at $19.99/mo gives you 100,000 calls/day and removes every limitation that matters.

FAQs

❓ Is EODHD really free, or is there a catch?
✅ The free plan is real — 20 API calls per day after registration, no credit card required. There's also a demo key (no registration needed) limited to a handful of tickers like AAPL.US and TSLA.US, useful for testing your code structure before committing. The limitation is depth: the free tier returns data for the past year only, and 20 calls/day means you need to be deliberate about what you pull.

❓ How does EODHD compare to yfinance for historical data?
✅ EODHD is a purpose-built API with documented endpoints, stable JSON, and official support. yfinance scrapes Yahoo Finance's internal interface and breaks without warning. For anything beyond personal experiments, EODHD is significantly more reliable. It also returns adjusted close prices that match official exchange records, which yfinance sometimes gets wrong around split events — a silent error that corrupts backtest results.

❓ Do I need to install any special library to use EODHD with Python?
✅ No. All you need is requests and pandas — both are standard in any Python data environment. The EODHD REST API returns clean JSON that converts to a DataFrame in one line. No additional SDK required.

❓ Can I get historical data for international stocks, not just US?
✅ Yes. EODHD covers 60+ global exchanges. Tickers follow the format SYMBOL.EXCHANGE — for example, BARC.LSE for Barclays on the London Stock Exchange, or BMW.XETRA for BMW on Xetra. Non-US exchanges are covered from 2000 onward on most plans.

❓ Why does adjusted close matter so much for backtesting?
✅ When a company does a stock split, the raw price drops proportionally — a 4:1 split makes a $400 stock appear to close at $100 the next day. Without adjustment, your model sees a 75% single-day loss that never happened. Adjusted close normalizes all past prices to account for splits and dividends, giving you a historically continuous series that's valid for returns calculations.

❓ How many years of historical data can I get for free?
✅ The free plan returns up to 1 year of end-of-day historical data per ticker. Paid plans starting at $19.99/mo unlock 30+ years for US stocks (some tickers go back to 1972) and 20+ years for international markets.

❓ Can I use EODHD for crypto historical data too?
✅ Yes. EODHD covers 2,600+ crypto pairs. The endpoint format is the same — for Bitcoin in USD, use BTC-USD. The free plan gives access to 1 year of daily crypto OHLCV. Historical crypto data goes back to the asset's origin on paid plans.

❓ Is the free tier suitable for machine learning projects?
✅ It depends on your dataset size. 20 calls/day means you can pull 20 full-year price histories per day — enough to build and validate a model on a focused universe. For larger training sets spanning hundreds of tickers or multiple years, a paid plan is more practical. The free tier is ideal for development and prototyping.

Closing

Most developers waste weeks on brittle workarounds for something that should take an afternoon.

Clean, adjusted, production-grade historical stock data is not a premium feature. It's the minimum requirement for any analysis you'd trust with a real decision.

EODHD gives you that foundation for free — and a clear upgrade path when your project outgrows it.

👉 Get your free EODHD API key — 20 calls/day, no credit card, instant access.

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