DEV Community: Kevin Meneses González

21 Ways to Avoid Getting Blocked While Web Scraping

Kevin Meneses González — Thu, 22 Oct 2026 17:23:36 +0000

Your scraper doesn't fail because of your code.

It fails because it screams "I'm a bot" on every single request.

If you want to avoid getting blocked while web scraping, you need to understand one thing first: modern websites don't block scrapers, they block signals. A missing header. An IP from a datacenter. A request every 200 milliseconds, perfectly timed, 24 hours a day.

If you're:

scraping prices or product data,
building datasets for AI or RAG pipelines,
or monitoring competitors at scale,

this guide is for you.

Below are 21 techniques I use for web scraping without getting blocked, grouped into five blocks, each one with a short Python example you can copy.

TL;DR

Why you get blocked: anti-bot systems score four layers of every request: IP, HTTP headers, behavior and browser fingerprint.
Quick wins (free): real User-Agent, full browser headers, random delays, backoff on 429, caching, and hidden JSON APIs.
Medium effort: rotating proxies, residential IPs, geo-targeting and sticky sessions.
Hard part: TLS fingerprints, headless browser detection and CAPTCHAs.
Shortcut: a web scraping API like ZenRows handles proxies, fingerprints and anti-bot challenges in one request. mode=auto escalates only when needed, and the free plan includes 5,000 credits/month.

Why Websites Block Web Scrapers

Anti-bot systems like Cloudflare Bot Management, DataDome, Akamai or PerimeterX score every request. When the score crosses a threshold, you get a 403 Forbidden, a CAPTCHA, or worse: a 200 response with fake or empty data.

They look at four things:

Your IP: reputation, type (datacenter vs residential), request volume
Your HTTP identity: User-Agent, headers, header order, cookies
Your behavior: speed, timing patterns, navigation path
Your browser fingerprint: TLS handshake, JavaScript execution, canvas, WebGL

Fix one and ignore the others, and you still get blocked.

That's the real problem. Blocking is multi-layered, so your strategy to avoid getting blocked has to be too.

Block 1: HTTP Headers and Identity (Techniques 1–5)

1. Use a real, rotating User-Agent

The default python-requests/2.x User-Agent is the fastest way to get banned. Use real browser strings and rotate them.

import random
import requests

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15",
    "Mozilla/5.0 (X11; Linux x86_64; rv:131.0) Gecko/20100101 Firefox/131.0",
]

headers = {"User-Agent": random.choice(USER_AGENTS)}
r = requests.get("https://httpbin.io/headers", headers=headers)
print(r.json())

Keep the list updated. A Chrome version from three years ago is almost as suspicious as no User-Agent at all. 📖 MDN: User-Agent header

2. Send the full set of browser headers

A real browser never sends only a User-Agent. It sends Accept, Accept-Language, Accept-Encoding, Sec-Fetch-* and more.

headers = {
    "User-Agent": USER_AGENTS[0],
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Upgrade-Insecure-Requests": "1",
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Site": "none",
}

Tip: open httpbin.io/headers in your browser, then call it from your script. Compare both outputs. Every difference is a signal.

3. Keep headers consistent with the User-Agent

If your User-Agent says Firefox but you send Chrome-only headers like sec-ch-ua, you've just flagged yourself. Every header set should match the browser it claims to be.

A simple rule: build header profiles (one per browser) and rotate the full profile, never individual headers. 📖 MDN: Sec-CH-UA client hints

4. Set a realistic Referer

Real users arrive from somewhere. Usually Google, or another page of the same site.

headers["Referer"] = "https://www.google.com/"

For deep pages, set the Referer to the category or listing page that links to them.

5. Persist cookies with a session

Many sites set cookies on the first visit and expect them back. A scraper that never returns cookies looks like a thousand brand-new visitors.

session = requests.Session()
session.headers.update(headers)

session.get("https://example.com/")             # gets cookies
r = session.get("https://example.com/products") # sends them back

📖 Requests docs: Session objects

Headers alone won't help you avoid getting blocked, though.

If every request comes from the same IP, nothing else matters.

Block 2: Rotating Proxies and IPs (Techniques 6–9)

6. Use rotating proxies

Sending thousands of requests from one IP is the oldest red flag in web scraping. Use a proxy pool and rotate IPs.

import itertools

PROXIES = [
    "http://user:pass@proxy1.example.com:8000",
    "http://user:pass@proxy2.example.com:8000",
    "http://user:pass@proxy3.example.com:8000",
]
proxy_pool = itertools.cycle(PROXIES)

for url in urls:
    proxy = next(proxy_pool)
    r = requests.get(url, headers=headers, proxies={"http": proxy, "https": proxy}, timeout=30)

📖 Requests docs: Proxies

7. Use residential proxies for protected sites

Datacenter IPs are cheap and fast, and anti-bot systems know every one of their ranges. Residential proxies use IPs from real ISPs, so they carry much higher trust.

Use datacenter proxies for easy targets. Switch to residential proxies when you start seeing 403 Forbidden errors.

8. Match the IP's geolocation to the target

Scraping a Spanish e-commerce site from a Singapore IP looks odd. It can also return different prices, currencies or content. Pick proxies from the country your target expects.

9. Use sticky sessions for multi-step flows

Rotating proxies are great until you need to log in, paginate or keep a cart. Changing IP mid-session is a classic bot signal. Keep the same IP for the whole flow, then rotate.

Managing a residential proxy pool, geo-targeting and sticky sessions yourself is a real project.

This is where most people quietly give up.

Skip the proxy plumbing
ZenRows gives you rotating residential proxies (premium_proxy), country targeting (proxy_country) and sticky sessions (session_id) as simple API parameters.
→ Try ZenRows for free

Block 3: Scraping Behavior and Rate Limits (Techniques 10–14)

10. Throttle your request rate

Hammering a server is both rude and obvious. Limit concurrency and requests per second per domain.

import time

for url in urls:
    r = session.get(url)
    time.sleep(1.5)

11. Add random delays

Humans are irregular. Bots are perfectly regular. A fixed sleep(1) is a fingerprint in itself.

time.sleep(random.uniform(1.2, 4.5))

12. Back off on 429 and 503

When the server says "slow down", listen. Retrying instantly just confirms you're a bot and gets your IP blocked faster.

def fetch_with_backoff(url, max_retries=5):
    for attempt in range(max_retries):
        r = session.get(url, timeout=30)
        if r.status_code not in (429, 503):
            return r
        wait = int(r.headers.get("Retry-After", 2 ** attempt))
        time.sleep(wait + random.random())
    return r

📖 MDN: 429 Too Many Requests · MDN: Retry-After

13. Respect robots.txt and crawl-delay

Checking robots.txt keeps you away from the traps (honeypot URLs) and the areas the site watches most closely. It's also the ethical baseline for any web scraping project.

from urllib.robotparser import RobotFileParser

rp = RobotFileParser("https://example.com/robots.txt")
rp.read()
print(rp.can_fetch("*", "https://example.com/products"))
print(rp.crawl_delay("*"))

📖 Python docs: urllib.robotparser · Google: How robots.txt works

14. Scrape during off-peak hours

Your traffic stands out less when it's spread across the day, and you put less load on the site at night in its local time zone. Big batch jobs belong there.

Behavior is where most DIY scrapers improve the fastest.

But the hardest anti-bot layer is still ahead.

Block 4: Browser Fingerprint and Anti-Bot Detection (Techniques 15–18)

15. Use a headless browser with stealth patches

Plain headless Chrome leaks signals like navigator.webdriver = true. Use stealth patches to hide them.

# pip install playwright playwright-stealth
# playwright install chromium
from playwright.sync_api import sync_playwright
from playwright_stealth import Stealth

with Stealth().use_sync(sync_playwright()) as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

📖 Playwright for Python · playwright-stealth on PyPI

16. Fix your TLS fingerprint

This one surprises people. Even with perfect headers, the TLS handshake from Python's requests doesn't look like Chrome's. Anti-bot systems check it (JA3/JA4 fingerprints).

curl_cffi impersonates a real browser at the TLS level:

# pip install curl_cffi
from curl_cffi import requests as cffi_requests

r = cffi_requests.get("https://example.com", impersonate="chrome")
print(r.status_code)

📖 curl_cffi on GitHub

17. Render JavaScript only when you need it

Many sites load data with JavaScript, and some anti-bot challenges require JS execution to pass. But a headless browser is slow and expensive. Use it for the pages that need it, not for everything.

18. Avoid CAPTCHAs instead of solving them

If you're seeing CAPTCHAs, the anti-bot system already distrusts you. Solving services work, but they're slow and cost money per solve. Fixing the signals from techniques 1–17 is cheaper than solving the CAPTCHA they trigger.

Stealth browsers and TLS impersonation work.

Until the anti-bot vendor ships an update and you're back to debugging on a Friday night.

Block 5: Smart Scraping Architecture (Techniques 19–21)

19. Look for hidden APIs (XHR) first

Open DevTools → Network → Fetch/XHR and reload the page. Many sites load their data from a JSON endpoint. Calling it directly is faster, cleaner and lighter than parsing HTML.

r = session.get("https://example.com/api/products?page=1")
data = r.json()

📖 Chrome DevTools: Inspect network activity

20. Cache and deduplicate requests

The request you don't send can't get you blocked. Store responses, skip URLs you've already scraped and only refresh what changed.

# pip install requests-cache
import requests_cache

session = requests_cache.CachedSession("scrape_cache", expire_after=3600)

📖 requests-cache docs

21. Use a web scraping API

Techniques 1 to 18 are a full-time job: rotating proxies, header profiles, TLS impersonation, headless browsers, CAPTCHA handling, retries. And all of it breaks whenever the anti-bot vendors change their rules.

A web scraping API bundles all of that behind one request.

After testing several options, ZenRows is the one I reach for when a site fights back. Here's why:

Adaptive Stealth Mode (mode=auto) starts with the cheapest setup and escalates to JS rendering or premium proxies only when needed. You're billed only for the configuration that succeeds. Docs
Residential proxies with geo-targeting via premium_proxy=true and proxy_country (e.g. es, us, de). Docs
JS rendering (js_render=true) plus wait_for and js_instructions for dynamic pages.
Sticky sessions with session_id (any number from 1 to 99999), which keeps the same IP for 10 minutes. Docs
Managed browser headers: ZenRows sets User-Agent, Sec-Ch-Ua, Sec-Fetch-* and similar headers for you, so they always match the fingerprint.
Clean output: CSS extraction to JSON, or Markdown (response_type=markdown) for LLM pipelines.

That single technique covers most of the other 20.

Full Example: Scrape Without Getting Blocked (DIY vs ZenRows)

Let's use ZenRows' own test page, scrapingcourse.com/antibot-challenge, which is protected by an anti-bot challenge. First, the DIY version:

import requests

url = "https://www.scrapingcourse.com/antibot-challenge"
r = requests.get(url, headers={"User-Agent": USER_AGENTS[0]}, timeout=30)

print("Status:", r.status_code)
print("Bypassed:", "You bypassed the Antibot challenge" in r.text)

You'll get the challenge page instead of the content:

Bypassed: False

Now with ZenRows and Adaptive Stealth Mode:

# pip install requests
import requests

params = {
    "url": "https://www.scrapingcourse.com/antibot-challenge",
    "apikey": "YOUR_ZENROWS_API_KEY",
    "mode": "auto",
}

r = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)

print("Bypassed:", "You bypassed the Antibot challenge" in r.text)
print("Cost (USD):", r.headers.get("X-Request-Cost"))

Bypassed: True
Cost (USD): 0.025

No proxy list. No header profiles. No stealth patches.

The X-Request-Cost header shows what the request cost (0.001 USD = 1 credit), so you can see when the API had to escalate. Two details from the API reference: use a client timeout of 180 seconds, because protected pages can take a while, and don't send js_render or premium_proxy together with mode=auto. Auto mode manages those two for you.

Manual configuration: geo-targeted scraping with CSS extraction

Need control instead of automation? Set the parameters yourself:

params = {
    "url": "https://www.scrapingcourse.com/ecommerce/",
    "apikey": "YOUR_ZENROWS_API_KEY",
    "js_render": "true",
    "premium_proxy": "true",
    "proxy_country": "es",
    "wait_for": ".product",
    "css_extractor": '{"names": ".product-name", "prices": ".price", "links": "a.woocommerce-LoopProduct-link @href"}',
}

r = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
print(r.json())

A few rules worth knowing:

wait_for (and wait) only work with js_render=true.
proxy_country requires premium_proxy=true.
css_extractor returns JSON: one match comes back as a string, several as a list. Add @href or @src to grab attributes. Docs

Sending a Referer or cookies

ZenRows manages browser headers, but you can still send your own Referer or Cookie. Turn on custom_headers and pass them with the normal headers= argument:

params = {
    "url": "https://httpbin.io/anything",
    "apikey": "YOUR_ZENROWS_API_KEY",
    "custom_headers": "true",
}
headers = {"Referer": "https://www.google.com/"}

r = requests.get("https://api.zenrows.com/v1/", params=params, headers=headers, timeout=180)
print(r.text)

Headers like User-Agent or Sec-Fetch-* are ignored here on purpose, so they never contradict the browser fingerprint. Docs

Prefer an SDK?

# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_ZENROWS_API_KEY")
response = client.get("https://www.scrapingcourse.com/ecommerce/", params={
    "js_render": True,
    "premium_proxy": True,
    "proxy_country": "us",
})
print(response.text)

📖 ZenRows Python SDK quickstart

From here you can build:

price monitoring dashboards,
lead generation pipelines,
datasets for AI agents and RAG systems.

The 21 Techniques to Avoid Getting Blocked at a Glance

#	Technique	Layer	DIY difficulty	ZenRows
1	Real, rotating User-Agent	HTTP headers	Easy	✅ Managed
2	Full browser headers	HTTP headers	Easy	✅ Managed
3	Headers consistent with UA	HTTP headers	Medium	✅ Managed
4	Realistic Referer	HTTP headers	Easy	✅ `custom_headers`
5	Cookies and sessions	HTTP headers	Easy	Partial (send `Cookie` via `custom_headers`)
6	Rotating proxies	Proxies	Medium	✅ `premium_proxy`
7	Residential proxies	Proxies	Hard	✅ `premium_proxy`
8	Geo-targeted IPs	Proxies	Medium	✅ `proxy_country`
9	Sticky sessions	Proxies	Medium	✅ `session_id`
10	Rate limiting	Behavior	Easy	Your side
11	Random delays	Behavior	Easy	Your side
12	Backoff on 429/503	Behavior	Easy	Your side
13	Respect robots.txt	Behavior	Easy	Your side
14	Off-peak scraping	Behavior	Easy	Your side
15	Stealth headless browser	Fingerprint	Hard	✅ `js_render`
16	TLS fingerprint	Fingerprint	Hard	✅
17	Selective JS rendering	Fingerprint	Medium	✅ `mode=auto`
18	Avoid CAPTCHAs	Fingerprint	Hard	✅
19	Hidden APIs (XHR)	Architecture	Medium	Partial (`json_response`, needs `js_render`)
20	Caching	Architecture	Easy	Your side
21	Web scraping API	Architecture	Easy	✅

Key Takeaways

Anti-bot systems score signals across four layers (IP, headers, behavior, fingerprint). Fixing only one won't stop you from getting blocked.
Behavior and architecture (techniques 10–14, 19–20) are cheap wins you should always own.
For rotating proxies, fingerprints and CAPTCHAs, a web scraping API like ZenRows saves weeks of maintenance.

FAQs

❓ How do I avoid getting blocked while web scraping?
✅ Combine several techniques: real browser headers, rotating residential proxies, random delays with backoff on 429 errors, and a TLS fingerprint that matches a real browser. If the site uses serious anti-bot protection, a web scraping API like ZenRows handles those layers for you.

❓ Why do I get a 403 Forbidden error when web scraping?
✅ A 403 usually means the anti-bot system flagged your request. The most common causes are a default Python User-Agent, missing browser headers, a datacenter IP or a non-browser TLS fingerprint. Fix headers first, then move to residential proxies.

❓ Is web scraping legal?
✅ Scraping publicly available data is generally legal in many jurisdictions, but it depends on the data, the site's terms and local laws (personal data under GDPR, for example). Avoid scraping behind logins without permission, respect robots.txt and check with a lawyer for commercial projects.

❓ How many requests per second can I send without getting blocked?
✅ There's no universal number. Start around one request every 1–3 seconds per domain with random jitter, watch for 429 responses and adjust. Rotating proxies let you spread volume, but they don't make aggressive scraping invisible.

❓ Do I need residential proxies for web scraping?
✅ Not always. Datacenter proxies work fine for many sites. You need residential proxies when the target uses serious anti-bot protection (Cloudflare, DataDome, Akamai) or blocks datacenter IP ranges.

❓ Is there a free web scraping API?
✅ ZenRows has a free plan with 5,000 credits per month and no credit card required. A standard request costs 1 credit, JS rendering 5, premium proxies 10, and both together 25. See pricing.

Useful Resources

ZenRows API reference: every parameter, response header and error code
ZenRows: scraping protected sites: official recipe for anti-bot pages
MDN: HTTP headers: what each browser header means
Playwright for Python: headless browser automation
curl_cffi: browser TLS impersonation for Python
scrapingcourse.com: safe sandbox pages to practice web scraping

Final Thoughts

Avoiding blocks isn't about one clever trick.

It's about not giving the anti-bot system a single reason to doubt you. You can build that yourself, layer by layer, or hand the hardest layers to a web scraping API and focus on the data.

Stop fighting anti-bot systems
Rotating residential proxies, JS rendering and anti-bot bypass in one request. 5,000 free credits per month, no card required.
→ Start scraping with ZenRows

More practical guides on Python, APIs and automation
Tutorials, tools and real workflows for developers.
→ Visit kevinmeneses.com

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

Yahoo Finance Historical Data Download Is Now Paid: 7 Alternatives

Kevin Meneses González — Tue, 13 Oct 2026 20:30:44 +0000

Quick answer: Yahoo Finance historical data is still free to view, but downloading it as CSV now requires Yahoo Finance Gold ($479.40/year). The cheapest reliable replacement is an end-of-day data API: EODHD ($19.99/month, 30+ years, CSV or JSON) if you need many tickers or a script. Tiingo's free tier works for personal research, and Nasdaq.com or Stooq cover a quick one-off download for free. If you only need a few prices, yfinance still works, with rate limits and no guarantees.

You click "Download" on Yahoo Finance.

Nothing downloads.

You get an upgrade screen instead.

For years, Yahoo Finance was the default answer to "where do I get historical stock data?" Analysts used it for Excel models. Students used it for theses. Developers used it as a free backend.

If you're:

rebuilding a backtest that used to start with a Yahoo CSV,
maintaining a spreadsheet that pulled prices every month,
or running a Python script that suddenly returns empty DataFrames,

this matters.

What changed with Yahoo Finance historical data

Yahoo's own help page is explicit: "Downloading historical data is available with a Yahoo Finance Gold subscription." (Yahoo Help)

You can still open any ticker, go to Historical Data, pick a range and read the table in the browser. The Download button is the part behind the paywall.

Here's what each Yahoo plan includes, from Yahoo's plan page:

Plan	Price (billed yearly)	Historical data download
Free	$0	No (view only)
Bronze	$95.40/year ($7.95/mo)	No
Silver	$239.40/year ($19.95/mo)	No
Gold	$479.40/year ($39.95/mo)	Yes, CSV

Two more limits apply even with Gold. Yahoo says the feature "isn't available for all instruments due to data licensing restrictions," and the download is still one ticker at a time, by hand.

Paying $479 a year for a button is a lot.

Especially when the button doesn't scale.

The real problem isn't the paywall

Most people searching for this want a CSV.

What they actually need is a repeatable source of clean daily prices: same columns every time, adjusted for splits and dividends, available for hundreds of tickers, and not dependent on a website layout.

A manual download from any website, free or paid, fails that test the moment you need more than a few tickers.

So the question isn't "how do I get the Yahoo button back?"

It's "what replaces it for my volume?"

Yahoo Finance alternatives at a glance

Option	Free tier	Paid from	History depth	Access	Main catch
EODHD	20 calls/day, 1 year	$19.99/mo ($199/yr)	30+ years	API (CSV/JSON), Excel & Sheets add-ons	Free tier too small for real backtests
Tiingo	1,000 req/day, 500 symbols/mo	$30/mo	30+ years EOD	API	License is internal/personal use only
Alpha Vantage	25 req/day	$49.99/mo	Varies by endpoint	API	25 calls/day goes fast; some functions are premium
Financial Modeling Prep	250 calls/day	$19/mo (annual)	5 years on Basic and Starter	API	Short history on the cheaper plans
yfinance	Free	n/a	Whatever Yahoo serves	Python library	Unofficial, rate-limited, personal use
Nasdaq.com	Free	n/a	Up to 10 years	Browser	Manual, one ticker at a time
Stooq	Free	n/a	Long, varies by market	Browser, bulk files	Automated downloads unreliable in 2026

Which type of replacement do you need?

There isn't one best Yahoo Finance alternative. There's a best one for your volume.

One ticker, once: a free website (Nasdaq.com, Stooq) is enough.
A few tickers, regularly, personal project: yfinance or a free API tier (Tiingo).
Dozens to thousands of tickers, a backtest, or anything client-facing: a paid end-of-day API with clear licensing.

Pick your row. Then read only the options that fit it.

1. EODHD: best overall Yahoo Finance replacement for historical data

EODHD (EOD Historical Data) is an API built around exactly what the Yahoo download used to give you: daily open, high, low, close, adjusted close and volume. It covers 150,000+ tickers across global exchanges, with 30+ years of history on paid plans.

I use it in most of my fintech tutorials, so I'll show the exact code I run.

Key features

End-of-day prices with an adjusted_close field (adjusted for splits and dividends)
CSV or JSON output from the same endpoint (fmt=csv or fmt=json)
Delisted tickers keep their history, which matters for backtests
Excel and Google Sheets add-ons for non-coders

Replicate the Yahoo CSV in Python

The script below returns the same columns as the old Yahoo download, in the same order. The demo key works for AAPL.US, TSLA.US, AMZN.US and VTI.US, so you can run it before signing up.

pip install requests pandas

import os
import requests
import pandas as pd

API_TOKEN = os.getenv("EODHD_API_TOKEN", "demo")

def yahoo_style_history(ticker: str, start: str, end: str) -> pd.DataFrame:
    url = f"https://eodhd.com/api/eod/{ticker}"
    params = {"api_token": API_TOKEN, "from": start, "to": end, "period": "d", "fmt": "json"}
    response = requests.get(url, params=params, timeout=30)
    response.raise_for_status()

    df = pd.DataFrame(response.json())
    df = df.rename(columns={
        "date": "Date", "open": "Open", "high": "High", "low": "Low",
        "close": "Close", "adjusted_close": "Adj Close", "volume": "Volume",
    })
    return df[["Date", "Open", "High", "Low", "Close", "Adj Close", "Volume"]]

df = yahoo_style_history("AAPL.US", "2026-10-05", "2026-10-09")
df.to_csv("AAPL.csv", index=False)
print(df.to_string(index=False))

Output (real data, pulled October 13, 2026):

      Date   Open   High    Low  Close  Adj Close   Volume
2026-10-05 332.82 336.21 331.65 332.89     332.89 34400900
2026-10-06 332.28 334.38 330.62 333.63     333.63 30449000
2026-10-07 336.96 338.67 332.78 336.67     336.67 34147900
2026-10-08 336.82 341.57 335.90 340.42     340.42 35332400
2026-10-09 331.70 338.61 330.70 336.64     336.64 37881200

Same columns. Same format. Your old Excel model or pandas code reads it without changes.

History depth check

The same call with start="1980-12-01" returns Apple's first trading day, December 12, 1980 (close 28.74, adjusted close 0.0981). The adjusted column already accounts for every split since then.

Delisted tickers

Twitter (TWTR.US) was delisted in October 2022. Its history is still there:

      date  close    volume
2022-10-24  51.52  24296045
2022-10-25  52.78  37489316
2022-10-26  53.35  29698456
2022-10-27  53.70 198415408

If your backtest only uses companies that still exist, it's biased toward the winners. Keeping delisted tickers fixes that.

Download many tickers at once

tickers = ["AAPL.US", "TSLA.US", "AMZN.US", "VTI.US"]

for t in tickers:
    yahoo_style_history(t, "2016-01-01", "2026-10-09").to_csv(f"{t}.csv", index=False)

Swap the list for your own universe once you're on a paid key.

Pricing (verified October 2026)

Free: 20 API calls/day, 1 year of history
EOD Historical All-World: $19.99/month or $199/year, 100,000 calls/day, 30+ years
EOD + Intraday: $29.99/month

That's $199 a year against $479.40 for Yahoo Gold: about 58% less. And you get an API instead of a button.

👉 Try EODHD here. Code KEVIN10 gives 10% off.

What I liked

The CSV/JSON switch is a single parameter.
Delisted tickers and full split/dividend adjustment out of the box.
Annual plan is cheaper than any Yahoo tier that includes downloads.

Where it falls short

The free tier (20 calls/day, 1 year) is for testing, not for real research.
adjusted_close is recalculated when new dividends arrive, so don't use it as a fixed key in a database.
Fundamentals are a separate, more expensive plan.

Best for: anyone replacing Yahoo downloads at scale, from Excel analysts to Python backtests.

Skip if: you need fewer than five tickers, once.

2. Tiingo: best free tier for personal research

Tiingo gives you 30+ years of end-of-day prices on its free Starter plan, which is generous by any standard.

Pricing (verified October 2026)

Free: 50 requests/hour, 1,000/day, 500 unique symbols/month
Power: $30/month or $300/year for individuals

What I liked

Deep history on the free plan.
500 symbols a month covers most personal portfolios.

Where it falls short

Both tiers are licensed for "Internal Use Only": no displaying or sharing the data. Internal commercial use costs $50/month, and redistribution is priced separately.
50 requests per hour slows down bulk downloads.

Best for: personal backtests and study projects.

Skip if: you're building something other people will see.

3. Alpha Vantage: best known free API, smallest daily quota

Alpha Vantage is often the first API developers try. It covers time series, technical indicators, fundamentals and FX.

Pricing (verified October 2026)

Free: 25 API requests/day
Premium: from $49.99/month (75 requests/minute)

What I liked

Broad catalog beyond prices.
Plenty of community examples.

Where it falls short

25 requests a day means 25 tickers a day, at best.
Some functions are premium-only, so check each endpoint before you build on it.

Best for: small experiments and learning.

Skip if: you need more than a handful of tickers per day.

I compared Alpha Vantage with six other providers in this comparison of financial APIs.

4. Financial Modeling Prep: generous free calls, shorter history

FMP has a large API catalog, especially for fundamentals and financial statements.

Pricing (verified October 2026)

Basic (free): 250 calls/day, 5 years of EOD history
Starter: $19/month billed annually, also 5 years

What I liked

250 free calls a day is ten times Alpha Vantage.
Strong fundamentals coverage.

Where it falls short

5 years of history on the cheaper plans. Long-horizon backtests need a higher tier.

Best for: fundamentals-heavy projects with recent price history.

Skip if: you need decades of prices on a small budget.

5. yfinance: free, until it isn't

yfinance is a Python library that reads Yahoo's data. Many people still use it, and for a few tickers it often works.

But know what you're relying on. The project's own README says it is "not affiliated, endorsed, or vetted by Yahoo, Inc." and that the data is "intended for personal use only." (GitHub)

In 2025, users reported YFRateLimitError('Too Many Requests. Rate limited. Try after a while.') (issue #2422) and failed historical requests that they linked to the new paywall (issue #2340). Fixes usually meant upgrading the library or changing how requests are sent.

What I liked

Free and two lines of code.
Same data you saw on the Yahoo website.

Where it falls short

No SLA. A Yahoo change can break your pipeline overnight.
Rate limits hit hardest when you loop over many tickers.
Personal use only.

Best for: quick, personal checks.

Skip if: anything depends on the data arriving tomorrow.

6. Nasdaq.com: free and manual

Nasdaq's historical quotes page shows "up to 10 years of daily historical stock prices and volumes for each stock."

What I liked

Free, official exchange source.
Enough history for most one-off charts.

Where it falls short

10 years maximum.
Manual, one ticker at a time. No API.

Best for: a single chart or a quick sanity check.

Skip if: you need more than 10 years, or more than a few tickers.

7. Stooq: free bulk files, fragile automation

Stooq offers free historical files for many markets, including bulk daily packages.

What I liked

Free bulk downloads, no account needed for manual use.
Long histories for many markets.

Where it falls short

Automated access got shaky in 2026. Users of portfolio software reported empty responses from Stooq's historical servers starting in April 2026, while manual CSV downloads still worked (forum thread).
Licensing terms for reuse aren't clear, so treat it as personal research data.

Best for: a free bulk snapshot for personal research.

Skip if: your workflow depends on scheduled downloads.

Best Yahoo Finance alternative by use case

Use case	Pick	Why
Excel model with monthly price updates	EODHD (Excel add-on)	Same columns as Yahoo, no manual downloads
Backtest over 10+ years and hundreds of tickers	EODHD	30+ years, delisted tickers, 100k calls/day
Personal research, under 500 symbols	Tiingo free	30+ years at $0, personal-use license
Fundamentals plus recent prices	Financial Modeling Prep	Large fundamentals catalog, 250 free calls
One chart, one time	Nasdaq.com	Free, 10 years, no signup
Quick Python check on a few tickers	yfinance	Free, but expect rate limits

Can you still get Yahoo Finance historical data for free?

Partly. You can view the full historical table on any quote page and copy it into a spreadsheet by hand. For long ranges that means scrolling through thousands of rows, and Yahoo's data is meant for personal use.

It works for one ticker.

It doesn't work as a system.

If you're building anything bigger, I covered the full workflow for pulling and storing price history in API for Historical Stock Data: A Practical Guide. For options data, see I Pulled EODHD's Full Options History With Python.

FAQ

Is Yahoo Finance historical data free?
Viewing it is free. Downloading it as CSV requires Yahoo Finance Gold, which costs $479.40 per year billed annually.

Why can't I download historical data from Yahoo Finance?
Yahoo moved the Download button to the Gold plan. Some instruments can't be downloaded even with Gold because of data licensing restrictions.

How much is Yahoo Finance Gold?
$39.95 per month billed yearly, or $479.40 per year (October 2026). Bronze and Silver don't include downloads.

Does yfinance still work in 2026?
Often, yes, for small volumes. It's unofficial, intended for personal use, and has had rate-limit errors (YFRateLimitError) since 2025.

What is the best free alternative to Yahoo Finance for historical data?
Tiingo's free plan offers 30+ years of daily prices for up to 500 symbols a month, for personal use. For a single quick download, Nasdaq.com gives up to 10 years.

What is the cheapest paid alternative to Yahoo Finance Gold for downloads?
EODHD's end-of-day plan costs $199 per year (or $19.99/month) for 30+ years of global data via API, CSV, Excel or Google Sheets.

Can I use these alternatives in Excel or Google Sheets?
Yes. EODHD offers Excel and Google Sheets add-ons, and every API above returns CSV or JSON that Excel can import.

Verdict

Yahoo didn't remove historical data. It removed the free button.

For a one-off, use Nasdaq.com. For personal research, use Tiingo's free tier. For anything you'll run every week, or show to someone else, use an end-of-day API like EODHD at less than half the price of Yahoo Gold.

👉 Get EODHD here and use KEVIN10 for 10% off.

The data was never the hard part.

Getting it the same way every time is.

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.

7 Best Email APIs for Developers in 2026 (Compared)

Kevin Meneses González — Tue, 06 Oct 2026 10:47:01 +0000

Most developers pick an email API once and never think about it again.

Until a password reset lands in spam. Or the free tier disappears. Or the dashboard keeps logs for exactly one day, right when you need to debug a customer complaint.

If you're:

shipping a SaaS that sends login codes and receipts,
building an AI agent that needs to send or read email,
or migrating away from a provider that changed its pricing,

this matters.

Choosing the best email API for developers is not about who has the biggest feature list. It's about how fast you go from pip install to a delivered email, and how much the tool gets in your way after that.

I compared seven options: the established names developers already know (Resend, Postmark, Mailgun, SendGrid) and three smaller, newer players worth watching (Plunk, Lettermint, Sendkit). Here's what each one is actually good at.

The email API market changed in 2025

For years the default answer was simple: use SendGrid, it's free to start.

That's no longer true.

In 2025 SendGrid retired its permanent free plan. New accounts now get a time-limited trial, and after that you pay. That single change pushed a lot of indie developers and startups to look for SendGrid alternatives.

At the same time, three things happened:

AI coding tools made "time to first email" a real competitive factor
Agents started needing email as a tool, not just apps
A new wave of small, developer-first providers raised the bar on docs, SDKs and pricing

The old question was "which provider has the best deliverability?"

The new question is "which one fits the way I build software today?"

What actually matters in an email API

Before the list, here's the scoring lens I used. No marketing checklist, just the things that hurt in production:

Time to first email. Minutes from signup to an email in your inbox.
SDK quality. Is the Python/Node SDK idiomatic, typed and maintained?
Free tier you can actually build on. Not a trial that expires mid-project.
Debuggability. Log retention, webhooks, clear error messages.
Pricing at 50k emails/month. Where most growing products land.

Transactional email is infrastructure.

Infrastructure should be boring.

1. Resend — The developer-first email API

Resend was built by developers who were tired of fighting legacy email dashboards. It's also the team behind React Email, the open-source library for building email templates with React components.

The difference shows from minute one. The docs read like a modern dev tool, the SDKs exist for every major language, and the API surface is small and predictable.

Here's a complete working example in Python:

pip install resend

import os
import resend
from resend.exceptions import ResendError

resend.api_key = os.environ["RESEND_API_KEY"]

params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Your login code",
    "html": "<p>Your code is <strong>482913</strong></p>",
}

try:
    email = resend.Emails.send(params)
    print(email)  # {'id': '...'}
except ResendError as error:
    print(error)

That's it. No nested JSON objects, no region configuration, no sandbox approval process.

Resend has also moved fast on AI. In April 2026 it launched an official MCP server that gives agents in Claude Code, Cursor or Codex access to sending, inbound email, contacts, broadcasts, domains and webhooks.

Pros

Fastest setup in this list: a test address (delivered@resend.dev) lets you send before verifying a domain
React Email integration for templates written as components, not HTML tables
Free tier of 3,000 emails/month (100/day) with no expiry date
Official MCP server for AI agents, plus inbound email on every plan

Cons

Younger company than Postmark or SendGrid, so fewer third-party integrations
The 100/day limit on the free plan can bite during launches

Pricing: Free (3,000/month). Pro at $20/month for 50,000 emails. Scale at $90/month for 100,000.

Best for: Startups, indie hackers and teams building with Next.js, Python or AI agents who want email to just work.

👉 If you want to try it, start with the Resend Python docs. You'll send your first email in under five minutes.

2. Postmark — The deliverability specialist

Postmark has been doing one thing for over a decade: getting transactional email into inboxes fast. It separates transactional and broadcast traffic into different "message streams" so marketing sends don't damage your password-reset reputation.

Pros

Strong reputation for delivery speed on transactional mail
Message streams keep transactional and bulk traffic isolated
45-day log retention on Basic, configurable up to 365 days on Pro

Cons

Free plan is only 100 emails/month, enough to test and not much more
Overage pricing adds up quickly past 10,000 emails

Pricing: Free (100/month). Basic from $15/month for 10,000 emails, then $1.80 per 1,000.

Best for: Products where a delayed email is a business problem: fintech, healthcare, B2B SaaS logins.

3. Mailgun — The flexible workhorse

Mailgun is a mature API with powerful routing and inbound parsing. It's a common choice for apps that need to receive and process email, not just send it.

You don't even need an SDK. Plain requests works:

import os
import requests

DOMAIN = "mg.yourdomain.com"

requests.post(
    f"https://api.mailgun.net/v3/{DOMAIN}/messages",
    auth=("api", os.environ["MAILGUN_API_KEY"]),
    data={
        "from": f"Acme <hello@{DOMAIN}>",
        "to": ["user@example.com"],
        "subject": "Your login code",
        "text": "Your code is 482913",
    },
)

Pros

Mature inbound routing and email parsing
Plain REST API, easy to call without an SDK
EU region available

Cons

Only 1 day of log retention on Free and Basic plans
Dashboard feels dated compared to newer tools

Pricing: Free (100 emails/day). Basic from $15/month for 10,000 emails. Foundation $35/month for 50,000.

Best for: Apps that need inbound email processing and flexible routing rules.

4. Plunk — The open-source option

Plunk is a small, open-source email platform that combines transactional email, marketing broadcasts and automation workflows in one tool. The code is AGPL-3.0 licensed, so you can run it yourself with Docker Compose.

That's rare in this space.

Pros

Open source and self-hostable: full data ownership, no per-email cost when self-hosted
Transactional, campaigns and workflows in a single product
EU-hosted and GDPR compliant, with SDKs for Node.js and Python

Cons

Free plan includes Plunk branding in emails
Smaller team and community than the established players

Pricing: Free (1,000 emails/month). Paid is pure pay-as-you-go at $0.001 per email, with an optional monthly spend cap.

Best for: Developers who want to own their email stack, or startups that need transactional and marketing email without paying for two tools.

5. Lettermint — The European alternative

Lettermint is a young transactional email provider built entirely on EU infrastructure, with ISO 27001 certification. If your customers or your legal team ask where data lives, this answers the question before it's asked.

Pros

EU-based infrastructure, GDPR compliant and ISO 27001 certified
REST API, SMTP relay, batch sending, webhooks and a CLI on every tier
Python SDK available, plus 28-day data retention on all plans

Cons

Free tier is small: 300 emails/month and 1 domain
Inbound email only on paid plans

Pricing: Free (300/month). Paid plans from €10/month for 10,000 emails, with overage from €1.10 per 1,000.

Best for: European SaaS companies and agencies where data residency is a requirement, not a nice-to-have.

6. Sendkit — The all-in-one for startups

Sendkit is a newer platform that bundles transactional email, campaigns, automations, email validation and SMTP relay. Like Resend, it ships an MCP server (with 39 tools) so AI agents can manage email operations directly.

Pros

Free tier of 3,000 emails/month, matching Resend
Marketing plan charges for emails sent, not contacts stored
MCP server for AI agent workflows

Cons

Young platform with a short track record on deliverability
Only 1 sending domain and 3 templates on the free plan

Pricing: Free (3,000/month, 100/day). Transactional from $15/month, Marketing from $30/month. Overage at $1 per 1,000 emails.

Best for: Early-stage startups that want transactional and marketing email from one vendor.

7. SendGrid — The enterprise default

SendGrid, now fully part of Twilio, is still one of the biggest senders on the planet. If your company already runs on Twilio, keeping email in the same account makes procurement easy.

Pros

Huge scale and long track record
Email API plus marketing campaigns in one platform
Fits naturally into the Twilio ecosystem (SMS, WhatsApp, Verify)

Cons

Permanent free plan retired in 2025, replaced by a time-limited trial
Developer experience shows its age: complex dashboard, heavier SDKs

Pricing: Essentials starts around $19.95/month for 50,000 emails after the trial.

Best for: Enterprises already standardized on Twilio.

Email API comparison table

Provider	Free tier	~50k emails/month	Open source	Best for
Resend	3,000/month, no expiry	$20 (Pro)	React Email (templates)	Modern dev teams, AI agents
Postmark	100/month	~$87 (Basic + overage)	No	Critical transactional mail
Mailgun	100/day	$35 (Foundation)	No	Inbound processing
Plunk	1,000/month	~$50 (pay-as-you-go)	Yes (AGPL-3.0)	Self-hosting, all-in-one
Lettermint	300/month	~€59–70 (base + overage)	No	EU data residency
Sendkit	3,000/month	From $15 + overage	No	Transactional + marketing
SendGrid	Trial only	~$19.95 (Essentials)	No	Twilio-based enterprises

Pricing from each provider's public pricing page, October 2026. Estimates at 50k: Postmark $15 + 40,000 × $1.80/1,000; Plunk 50,000 × $0.001; Lettermint base plan + 40,000 × overage rate. Always check current pricing before committing.

How to choose the right email API

Feature matrices all look the same after a while. Every provider has an API, SMTP, webhooks and DKIM.

The real differences show up in five decisions.

1. Start with what you're sending

Transactional email (password resets, receipts, login codes) and marketing email (newsletters, product updates) are different problems.

Transactional only: Resend, Postmark or Mailgun.
Both, in one tool: Plunk or Sendkit. Resend also covers broadcasts on every tier.
Strict isolation between the two: Postmark's message streams were designed for exactly this.

Mixing marketing and transactional traffic on the same domain is how password resets end up in spam.

2. Decide where your data has to live

If you sell to European companies, someone will eventually ask where email logs are stored.

EU infrastructure by default: Lettermint and Plunk.
EU region as an option: Mailgun.
Full control: self-host Plunk.

Answer this before you integrate. Migrating later is always more painful than choosing right the first time.

3. Be honest about your volume

Free tiers matter at the start. Overage pricing matters after product-market fit.

Under 3,000 emails/month: Resend and Sendkit cover you for free, with no expiry.
Around 50,000/month: Resend Pro at $20 is hard to beat among managed services.
Unpredictable spikes: Plunk's pay-per-email model with a spend cap removes surprises.

Run the math at 10x your current volume, not today's.

4. Check how well it fits your stack

This is where hours get won or lost.

React or Next.js: Resend, because React Email lets you write templates as components.
AI agents: Resend and Sendkit both ship MCP servers, so Claude or Cursor can send and manage email directly.
Already on Twilio: SendGrid keeps everything under one contract.
Heavy inbound processing: Mailgun's routing rules are the most mature.

5. Test debuggability before you need it

Send a few emails to a bad address on purpose. Then try to find out what happened.

Log retention ranges from 1 day (Mailgun Free/Basic) to 45 days (Postmark Basic). When a customer says "I never got the email," that window decides whether you can answer them.

The short version

Want to ship today and forget about email? Start with Resend.
Delivery speed is revenue? Postmark.
Need inbound parsing and routing? Mailgun.
Want open source or self-hosting? Plunk.
EU data residency is mandatory? Lettermint.
Transactional and marketing from one small vendor? Sendkit.
Locked into Twilio? SendGrid.

For most developers reading this, it's the first one.

Key takeaways

The best email API for developers in 2026 is the one with the shortest path from code to inbox. Resend leads there.
SendGrid's free plan is gone. Resend and Sendkit offer the most generous no-expiry free tiers (3,000/month).
Smaller players like Plunk and Lettermint win on specific needs: open source and EU data residency.

FAQs

❓ What is the best email API for developers?
✅ For most developers and startups, Resend offers the best balance of developer experience, free tier and price. Postmark is stronger for strict transactional delivery, and Mailgun for inbound processing.

❓ Is there a free email API?
✅ Yes. Resend and Sendkit include 3,000 emails/month for free, Plunk 1,000/month, Lettermint 300/month and Mailgun 100/day. SendGrid replaced its free plan with a trial in 2025.

❓ What's the best SendGrid alternative?
✅ It depends on why you're leaving. For better developer experience and a real free tier, Resend. For deliverability focus, Postmark. For open source, Plunk. For EU hosting, Lettermint.

❓ Is there an open-source email API?
✅ Plunk is open source (AGPL-3.0) and can be self-hosted with Docker Compose. Resend maintains React Email, an open-source library for building email templates.

❓ Can I send email with Python without SMTP?
✅ Yes. Email APIs like Resend and Mailgun let you send over HTTPS with a few lines of Python. That avoids SMTP ports, connection handling and most of the boilerplate of smtplib.

Final thoughts

Email used to be a deliverability problem.

Today it's a developer-experience problem.

The providers that win the next five years won't be the ones with the most features, but the ones that disappear into your workflow, whether that workflow is a Python script, a Next.js app or an AI agent.

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

I Asked Claude to Invest $10,000. Then I Changed the Starting Date

Kevin Meneses González — Sun, 04 Oct 2026 11:42:47 +0000

The portfolio was never the biggest risk.

The date was.

Three weeks ago I asked Claude to build a $10,000 allocation for a friend who'd had cash sitting in a savings account for eight months. Five positions, each one backed by real numbers pulled from a live data feed. The piece did well. The replies were mostly the same question, worded fifty different ways:

"OK, but would it have worked?"

My friend asked a sharper version. She runs financial models for a living, so she went straight to the weak spot:

"What if I'd done this in January 2022, right before everything fell?"

Fair question. So I ran a market timing backtest. Same portfolio, same $10,000, but instead of one start date I tested 105 of them: every month from January 2015 to September 2023, each one held for three years.

Then I compared every single run against the S&P 500, a classic 60/40 fund, and the portfolio most people actually want to own right now: the Magnificent 7.

If you're:

sitting on cash and waiting for "a better moment" to invest,
building a backtesting tool or an AI agent that reasons over market data,
or reading performance charts that conveniently start at the bottom,

this is worth your ten minutes.

Every backtest you've seen has one start date

And the person who wrote it picked that date.

That's the quiet problem with most "I invested $X in Y" content. One entry point. One exit point. One number at the end that looks like evidence.

It isn't. It's an anecdote with a chart attached.

Shift the start by six months and the same strategy can look brilliant or broken. Most authors don't do it on purpose. They pick a round date like January 1st, run the numbers once, and publish whatever comes out.

Here's the uncomfortable part: when you run the first article's portfolio from January 2019, $10,000 becomes $19,135 in three years. Start it in January 2022 and the exact same allocation ends at $12,382.

Same stocks. Same weights. Same rebalancing rule.

$6,753 of difference, and none of it came from the portfolio.

A single start date is an anecdote. A distribution is evidence.

The fix is called rolling-window backtesting.

Instead of asking "what did this portfolio return?", you ask "what did this portfolio return for every possible entry date?" You get a distribution instead of a number. And a distribution tells you three things a single backtest can't:

how bad your luck can realistically get,
how often the strategy beats a simple benchmark,
whether the edge is in the returns or somewhere else.

That third point turned out to be the whole story.

The setup: rolling 3-year windows on real adjusted prices

Four portfolios, $10,000 each, rebalanced back to target weights every 12 months:

Portfolio	Holdings
Claude's portfolio (from the first article)	35% VOO, 20% MSFT, 20% JNJ, 15% GLD, 10% SHY
Magnificent 7 (popular stocks)	Equal weight AAPL, MSFT, NVDA, AMZN, GOOGL, META, TSLA
S&P 500 benchmark	100% VOO
60/40 benchmark	100% AOR (iShares Core 60/40 allocation ETF)

Start dates: the first trading day of every month from January 2015 to September 2023. That's 105 entry points, and every window closes by September 2026.

The data comes from EODHD's end-of-day API, using the adjusted_close field. That matters more than it sounds. Adjusted prices fold in dividends and splits, so JNJ's 2–3% yield and NVDA's and TSLA's stock splits are reflected correctly. Using raw closing prices would quietly understate the dividend payers and wreck the split stocks.

One API key covered all twelve tickers back to 2014, on the same endpoint and in the same JSON shape.

→ If you want to reproduce this, EODHD's free tier is enough to start.

The code: a rolling-window backtest in Python

About 50 lines. One function downloads prices, one simulates a portfolio from any start date, and a loop runs all 105 windows.

pip install requests pandas

import os
import requests
import pandas as pd

API_TOKEN = os.environ["EODHD_API_KEY"]

PORTFOLIOS = {
    "Claude": {"VOO": .35, "MSFT": .20, "JNJ": .20, "GLD": .15, "SHY": .10},
    "Mag7":   {t: 1/7 for t in ["AAPL", "MSFT", "NVDA", "AMZN", "GOOGL", "META", "TSLA"]},
    "VOO":    {"VOO": 1.0},
    "60/40":  {"AOR": 1.0},
}
YEARS = 3

def get_prices(ticker):
    url = f"https://eodhd.com/api/eod/{ticker}.US"
    params = {"api_token": API_TOKEN, "fmt": "json", "from": "2014-01-01"}
    df = pd.DataFrame(requests.get(url, params=params).json())
    return df.set_index(pd.to_datetime(df["date"]))["adjusted_close"]

tickers = {t for w in PORTFOLIOS.values() for t in w}
prices = pd.DataFrame({t: get_prices(t) for t in tickers}).dropna()

def simulate(weights, start, capital=10_000):
    """Buy on `start`, rebalance every 12 months, hold YEARS years."""
    window = prices.loc[start:start + pd.DateOffset(years=YEARS), list(weights)]
    cuts = [window.index.searchsorted(start + pd.DateOffset(years=y)) for y in range(YEARS)]
    cuts.append(len(window) - 1)
    value, path = capital, []
    for a, b in zip(cuts, cuts[1:]):
        seg = window.iloc[a:b + 1]
        shares = pd.Series(weights) * value / seg.iloc[0]
        curve = (seg * shares).sum(axis=1)
        path.append(curve if not path else curve.iloc[1:])
        value = curve.iloc[-1]
    return pd.concat(path)

rows = []
for start in pd.date_range("2015-01-01", "2023-09-01", freq="MS"):
    for name, weights in PORTFOLIOS.items():
        curve = simulate(weights, start)
        rows.append({
            "start": start.date(),
            "portfolio": name,
            "final": round(curve.iloc[-1]),
            "max_drawdown": round((curve / curve.cummax() - 1).min() * 100, 1),
        })

results = pd.DataFrame(rows)
final = results.pivot(index="start", columns="portfolio", values="final")
print(final.describe(percentiles=[.1, .5, .9]).T.round(0))
print("Claude beats VOO in", f"{(final['Claude'] > final['VOO']).mean():.0%}", "of start dates")

Output:

           count     mean     std      min      10%      50%      90%      max
portfolio
60/40      105.0  12326.0  1261.0  10387.0  10779.0  12187.0  14190.0  15312.0
Claude     105.0  15055.0  1662.0  12382.0  12936.0  14879.0  17207.0  19135.0
Mag7       105.0  27870.0  8738.0  16639.0  18374.0  25574.0  39156.0  59977.0
VOO        105.0  14920.0  1764.0  11098.0  13109.0  14473.0  17526.0  20004.0
Claude beats VOO in 54% of start dates

One detail in simulate() is easy to get wrong. If the anniversary falls on a weekend, the rebalance has to happen on the next trading day, and the portfolio value has to be measured on that same day. Measure value on Friday and buy at Monday's prices, and you silently drop a day of returns at every rebalance. My first version had exactly that bug. It moved some results by more than $1,000.

From here you can build:

a "what if I'd started earlier" widget for any watchlist,
a risk report that shows the worst 10% of entry dates instead of the average,
an agent that answers "should I wait to invest?" with a distribution instead of an opinion.

Five start dates with names

Before the full distribution, here are the dates people actually ask about. Value of $10,000 after three years, with the worst peak-to-trough drop along the way:

Entry date	Claude's portfolio	S&P 500 (VOO)	60/40 (AOR)	Magnificent 7
Jan 2018 (before the Q4 selloff)	$15,743 / −22.8%	$14,736 / −34.0%	$12,422 / −22.9%	$38,183 / −34.9%
Feb 2020 (pre-COVID peak)	$12,926 / −22.9%	$13,308 / −34.0%	$11,250 / −22.9%	$19,987 / −50.7%
Apr 2020 (after the COVID crash)	$15,371 / −18.3%	$17,448 / −24.5%	$13,112 / −21.7%	$29,128 / −49.8%
Jan 2022 (market peak)	$12,382 / −17.2%	$12,839 / −24.5%	$10,789 / −21.5%	$18,006 / −49.0%
Oct 2022 (near the bear market low)	$17,839 / −10.3%	$19,043 / −18.7%	$15,312 / −9.8%	$36,297 / −31.2%

Read the Claude column top to bottom. The same portfolio ranges from $12,382 to $17,839 depending only on the month you clicked "buy."

Now read across any row. Claude vs. the S&P 500 is usually a few hundred dollars apart.

The month mattered far more than the portfolio did.

What 105 start dates actually show

1. Timing luck is about 10× bigger than portfolio choice

Across all 105 windows, the median gap between Claude's portfolio and the S&P 500 was $637.

The gap between Claude's best and worst start date was $6,753.

That ratio is the headline. If you spend three weeks optimizing what to buy and zero minutes thinking about how you'll handle a bad entry, you've put your effort in the wrong place.

2. On returns alone, Claude's portfolio was a coin flip against the S&P 500

It finished ahead of VOO in 54% of start dates. Median ending value: $14,879 vs. $14,473.

That's not an edge. That's noise.

If the only goal was "beat the S&P 500," the honest conclusion would be: just buy VOO.

3. The edge was in the drawdowns

This is where the two portfolios stopped looking alike.

Across all 105 start dates	Claude's portfolio	S&P 500 (VOO)	60/40 (AOR)	Magnificent 7
Median ending value	$14,879	$14,473	$12,187	$25,574
Worst ending value	$12,382	$11,098	$10,387	$16,639
Median max drawdown	−17.7%	−24.5%	−21.7%	−36.0%
Worst max drawdown	−23.5%	−34.0%	−22.9%	−50.7%
Avg. months below $10,000	2.8	3.9	6.3	3.6
Beats VOO (share of start dates)	54%	n/a	0%	100%

Claude's portfolio delivered roughly the same return as the S&P 500 with drawdowns about a third smaller. Its worst entry still ended higher than VOO's worst entry.

That's what the gold, JNJ and short-term treasuries were doing. They didn't add return. They made the bad start dates less bad.

And that matters more than it looks on a spreadsheet. A −34% drop is the point where real people sell. A −23% drop is the point where they complain and hold.

The 60/40 fund made an interesting control. In this specific decade, it never beat the S&P 500 over a 3-year window, and its typical drawdown (−21.7%) was deeper than Claude's (−17.7%). The 2022 bond crash hit it from both sides.

The popular-stocks portfolio: huge returns, huge hindsight

The Magnificent 7 portfolio beat the S&P 500 in 100% of start dates. Median ending value: $25,574. Best case, starting January 2019: $59,977.

Before you sell everything and buy seven tickers, look at two numbers.

The range. Same seven stocks, same weights. Starting in January 2019 gave you $59,977. Starting in February 2021 gave you $16,639. That's a $43,339 difference driven only by the entry month. The more concentrated the portfolio, the more the calendar decides your outcome.

The drawdowns. The median window included a −36% drop. The worst included −50.7%. Half your money, gone on paper, at least once. Most people who say they'd hold through that haven't had to.

Then there's the problem no backtest fixes on its own: look-ahead bias.

Nobody called these seven companies "the Magnificent 7" in 2015. That name dates from 2023. I picked them in 2026 because they won. Running them back to 2015 is like betting on a race after reading the results.

The same caveat applies, more mildly, to Claude's portfolio. MSFT and gold were picked with today's information too. A rolling backtest removes start-date bias. It does not remove selection bias.

Lump sum vs. dollar-cost averaging: the obvious fix that mostly isn't

If the entry date is the risk, the natural reaction is to spread it out. Instead of investing $10,000 on day one, invest $1,667 a month for six months.

I ran that too, on Claude's portfolio, with uninvested cash earning zero:

	Lump sum	6-month DCA
Median ending value	$14,879	$14,697
Worst ending value	$12,382	$12,030
Best ending value	$19,135	$17,803
Wins (share of 105 start dates)	78%	22%
Feb 2020 start (pre-COVID)	$12,926	$13,338
Jan 2022 start (market peak)	$12,382	$12,763

DCA won in only 22% of start dates. It helped when you started right at a peak: about $400 better in February 2020 and in January 2022. Averaged over the 10 worst lump-sum start dates, though, the two came out essentially tied ($12,555 vs. $12,564). And it cost real money in the windows where markets simply went up.

This matches what Vanguard and others have published for decades: lump sum wins about two-thirds of the time because markets rise more often than they fall. In this decade it won even more often.

DCA isn't a return strategy. It's a regret strategy. If investing $10,000 the day before a crash would make you sell everything, the six-month version is worth its cost. If it wouldn't, it isn't.

The honest caveats

This was a good decade. Not one of the 420 windows (105 dates × 4 portfolios) lost money over three years. Run the same test starting in 2000 or 2007 and that changes fast. EODHD has 30+ years of history if you want to stress-test it.
No taxes, no trading costs. Annual rebalancing in a taxable account has a cost this backtest ignores.
Overlapping windows. 105 windows over ~11 years aren't 105 independent experiments. Neighboring months share most of their data.
Three years is short. It's the horizon where timing hurts most. Over 10–15 years, entry dates matter less. They don't stop mattering.

Key takeaways

Your entry date moved the result about 10× more than your portfolio choice did. $6,753 between best and worst start, vs. a $637 median gap to the S&P 500.
A diversified portfolio's real job is shrinking the worst case, not beating the index. Claude's allocation matched VOO on returns and cut the median drawdown from −24.5% to −17.7%.
Concentration amplifies timing. The Magnificent 7 turned a $10,000 timing gap into a $43,000 one, and its 100% win rate rests on hindsight.

FAQs

Does market timing matter for long-term investing?

Yes, more than most people expect over 3–5 year horizons. In a rolling backtest of 105 start dates between 2015 and 2023 using EODHD price data, the same $10,000 portfolio ended anywhere from $12,382 to $19,135 after three years, depending only on the entry month. The effect shrinks over longer horizons, but it doesn't disappear.

How much does the start date change a portfolio's returns?

In this test, entry timing changed 3-year results by up to $6,753 on a $10,000 diversified portfolio and up to $43,339 on a concentrated Magnificent 7 portfolio. The difference between the diversified portfolio and the S&P 500 was much smaller: a median of $637.

Is lump sum investing better than dollar-cost averaging?

Usually, yes. In this backtest, investing $10,000 at once beat a 6-month dollar-cost averaging plan in 78% of start dates. DCA only helped when the lump sum landed right before a crash, such as February 2020 or January 2022. It reduces regret more than it improves returns.

Did the Magnificent 7 beat the S&P 500?

Yes. From 2015 to 2026, an equal-weight Magnificent 7 portfolio beat the S&P 500 in every 3-year window tested, with a median ending value of $25,574 vs. $14,473 per $10,000. But the result has strong look-ahead bias: the group was selected for having already won, and it suffered drawdowns of up to −50.7%.

Is a 60/40 portfolio still worth it?

Between 2015 and 2026, a 60/40 fund (AOR) never beat the S&P 500 over a 3-year window, and the 2022 bond selloff left its median drawdown (−21.7%) deeper than that of a stock-heavy portfolio with gold and short-term treasuries (−17.7%). Its value is in lower volatility in most periods, not higher returns.

How do I backtest a portfolio with different start dates in Python?

Download adjusted daily prices (for example from EODHD's /api/eod/ endpoint), write a function that simulates the portfolio from a given start date, then loop it over every monthly start date and collect the ending value and maximum drawdown. Use adjusted prices so dividends and splits are included, and rebalance on the first trading day on or after each anniversary.

Can Claude backtest an investment portfolio?

Claude can write and run the backtesting code, and with a market data connection such as EODHD's MCP server or REST API, it can work with real historical prices instead of remembered ones. The output is only as reliable as the data and assumptions behind it, so ask it to show the exact numbers and start dates it used.

The real question was never what to buy

My friend read the results and said something I hadn't expected:

"So I've been waiting eight months for the right moment, and the moment matters more than anything I was researching."

Yes. Which is exactly why waiting doesn't solve it. Nobody knows which month will be the January 2019 and which will be the January 2022.

What you can choose is a portfolio whose worst start date you could live with.

Run the backtest yourself with EODHD's API. The free tier covers every endpoint used here, including adjusted end-of-day prices with 30+ years of history.

This is not financial advice, and I'm not a financial advisor. Past performance, across 105 start dates or one, doesn't guarantee future results.

This article ran 420 backtests before writing a single claim. That's how I write for fintech and API companies: real calls, real data, numbers your readers can reproduce.

→ See more of my work at kevinmeneses.com

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

How to Choose the Best Stock API in 2026

Kevin Meneses González — Tue, 29 Sep 2026 10:23:25 +0000

Most developers pick a stock API the way they pick a restaurant on a trip.

The first result that looks decent. A quick glance at the free tier. Done.

Then, three months into the project, the problems show up:

the backtest needs 20 years of history and the plan gives you five,
the app needs European stocks and the API only covers the US,
the "real-time" feed turns out to be 15 minutes delayed.

Switching providers at that point means rewriting ticker mappings, re-validating historical data and re-testing every pipeline that touches prices.

That's why choosing the best stock API is a decision worth an hour of your time, not five minutes.

If you're:

building a backtesting engine or a quant research notebook,
shipping a portfolio tracker, screener or finance dashboard,
or wiring market data into an AI agent,

this guide walks you through the criteria that actually matter and the trade-offs behind each one.

Why Most Stock API Comparisons Don't Help

Search "best stock market API" and you'll find the same format everywhere. A top 10 list. A feature table. A winner.

The problem is that feature tables treat every checkbox as equal.

"Real-time data: ✅" means nothing if real-time starts at $199 a month and you only need end-of-day prices.
"Historical data: ✅" means nothing if the prices aren't adjusted for splits and your backtest shows fake 90% crashes.

Tables tell you what a provider has. They don't tell you what you're giving up.

And every choice here gives something up.

There Is No Best Stock API

There's the best API for the trade-off you're willing to make.

A provider optimized for US real-time streaming spends its engineering budget on latency and exchange feeds. A provider optimized for global historical coverage spends it on 60+ exchanges, corporate actions and fundamentals. Both are good. They're good at different things.

So the real question isn't "which API is best?"

It's "what does my project need, and what can it live without?"

Let's break that down into six criteria, plus one that nobody reads until it's too late.

Criterion 1: Coverage

Coverage has three dimensions, and most comparisons only look at one.

Markets. US-only or global? If there's any chance your product will serve users outside the US, check coverage for London, Frankfurt, Tokyo or whatever markets your users actually trade. Adding a second provider later just for international stocks is painful.

Asset classes. Stocks, ETFs, mutual funds, indices, forex, crypto, bonds, options. A portfolio tracker needs most of them. A trading bot might need one.

Datasets. Prices are only the start. Fundamentals, ETF holdings, dividends, splits, earnings calendars, insider trades and news are often sold separately or unlocked on higher tiers.

What to check before paying:

Request your actual watchlist, not AAPL. Every provider covers AAPL.
Check a small-cap, a foreign listing and an ETF.
Confirm which datasets your plan includes, not the provider's whole catalog.

Criterion 2: Pricing

Stock API pricing looks simple until you compare two providers side by side. They rarely charge for the same thing.

Some price by rate limit (more requests per minute, higher tier). Some price by dataset (prices in one plan, fundamentals in another). Some price by market (stocks, options and crypto each have their own ladder). Some price by license (personal vs commercial).

Three pricing traps to watch:

Annual prices shown as monthly. Several providers display the annual-billing price per month. The month-to-month price can be noticeably higher.
The real-time jump. Entry tiers are often 15-minute delayed. Real-time US data usually starts two or three tiers up.
Dataset add-ons. A cheap price plan plus a separate fundamentals plan can cost more than an all-in-one bundle.

Compare total cost for your use case, not entry price.

Criterion 3: Rate Limits

Rate limits decide whether your pipeline runs in 5 minutes or 5 hours.

Look at three things:

Per-minute vs per-day limits. A free tier of 25 requests per day is a very different product from one with 60 requests per minute. The first is for learning. The second can run a small live dashboard.

Weighted calls. Some providers count heavier endpoints (fundamentals, bulk downloads) as multiple calls. Your "100,000 calls a day" might be fewer in practice.

Bulk endpoints. This is the most underrated feature in the category. If you refresh 5,000 tickers every evening, an API that returns an entire exchange's end-of-day data in one request changes everything. Without bulk, that's 5,000 requests.

Quick math before you commit: estimate requests per run, multiply by runs per day, add 30% for retries and new tickers. That number decides your tier.

Criterion 4: Historical Depth

How far back you need depends on what you're building.

A price chart for a mobile app: 1 to 5 years is usually enough.
A backtest that includes 2008: you need 20+ years.
Factor research or long-horizon studies: 30+ years if you can get it.

But depth alone isn't enough. Quality matters more.

Adjusted prices. Splits and dividends distort raw prices. NVIDIA's 10-for-1 split in June 2024 looks like a 90% crash in unadjusted data. If your provider doesn't give you an adjusted series, you'll spend days rebuilding one.

Delisted tickers. If your historical universe only includes companies that exist today, your backtest suffers from survivorship bias. The companies that went bankrupt disappear from the data, and your strategy looks better than it would have been. Check whether delisted stocks are available and on which plan.

Free tier history. Free plans often cap history at one or two years. Fine for testing the API. Useless for testing a strategy.

Criterion 5: Real-Time Data

This is where budgets blow up. So start with an honest question.

Do you actually need real-time?

You need it for:

trading bots that act on intraday price moves,
live alerting on price thresholds,
apps where users expect ticking quotes.

You probably don't need it for:

backtesting,
portfolio analytics and risk reports,
screeners that run once a day,
most dashboards and research tools.

If you do need it, check the details:

Delayed vs real-time. "Live" often means 15-minute delayed.
REST polling vs WebSocket. Polling a quote every second burns rate limits. WebSockets push updates instead.
Symbol limits on streams. Some plans cap how many symbols you can subscribe to at once.
Market scope. Real-time US equities is common. Real-time international equities is rarer and more expensive.

End-of-day data covers more use cases than most developers assume, and it costs a fraction of real-time.

Criterion 6: Developer Experience

Two APIs with identical data can feel completely different to build with.

What separates good DX from bad:

Consistent ticker format. Something like SYMBOL.EXCHANGE across every market saves hours of mapping logic.
Clear documentation with real examples, not just parameter lists.
Predictable errors. A 404 for an unknown ticker is fine. An empty 200 response is a debugging nightmare.
Official SDKs for your language, or at least a clean REST design that doesn't need one.
AI-ready access. In 2026, several providers (including EODHD, FMP and Alpha Vantage) ship MCP servers, so tools like Claude can query market data directly. If you're building agents, this matters.

The best DX test is simple: time how long it takes you to get a clean DataFrame of your watchlist from a fresh account.

The Hidden Criterion: Licensing

Nobody reads the terms. Everyone should.

Most self-serve plans are licensed for personal use. The moment you display that data to paying users, redistribute it, or build a commercial product on top, you usually need a business or enterprise plan.

This isn't a technicality. Commercial plans often cost several times more than personal ones.

If you're building a product, not a personal tool, factor the commercial license into your budget from day one.

The 5 Trade-Offs You'll Actually Face

Here's where the criteria collide.

1. Breadth vs depth

Global providers cover dozens of exchanges and many asset classes. US specialists go deeper on one market: tick data, options chains, sub-second aggregates.

Pick breadth if your users are international or your product spans asset classes. Pick depth if you're building US trading infrastructure.

2. Real-time vs budget

Real-time US equities typically starts around $99 to $199 a month on individual plans. End-of-day data starts around $20.

If real-time isn't core to your product, don't pay for it yet.

3. Generous free tier vs a clear path to scale

Some providers have very generous free tiers. Others keep the free tier tight but have better value on paid plans.

The free tier helps you build the prototype. The paid tier is what you'll live with. Evaluate both.

4. One provider vs a stack

Using one provider for prices, fundamentals and ETF data means one ticker format, one adjustment methodology and one bill. Stacking specialists gives you best-in-class for each dataset, but you'll maintain the glue between them forever.

For most projects, one strong provider beats three perfect ones.

5. Personal vs commercial

Same data, different license, different price. Decide early which one you are.

Stock API Comparison: 6 Providers Worth Your Shortlist

List prices, individual plans, checked September 2026. Always confirm on the provider's site before buying, because this category changes often.

Provider	Free tier	Paid from	Strength
EODHD	20 calls/day, 1 year of history	$19.99/mo (EOD, all world)	Global EOD, fundamentals, 30+ years
Massive (formerly Polygon.io)	5 calls/min, 2 years, EOD	$29/mo (15-min delayed)	US real-time and streaming
Alpha Vantage	25 calls/day	$49.99/mo (75 calls/min, delayed)	Technical indicators, simple API
Financial Modeling Prep	250 calls/day	$22/mo billed annually (US)	Deep US fundamentals
Twelve Data	800 calls/day	$29/mo	Multi-asset, one API for everything
Finnhub	60 calls/min, US real-time	$49.99/mo	Free real-time US, alternative data

Now the trade-offs behind each.

EODHD

Pros

30+ years of end-of-day data across 150,000+ tickers on 60+ exchanges, with adjusted prices and delisted tickers on paid plans.
Prices, fundamentals, ETF holdings, dividends and splits from one API with one ticker format.
100,000 calls per day on paid plans, plus bulk endpoints for whole-exchange downloads and an MCP server for AI workflows.

Cons

The free tier (20 calls/day, 1 year) is only good for testing.
Fundamentals are a separate plan ($59.99/mo) or part of the All-In-One bundle ($99.99/mo).
Standard plans are personal use; commercial products need a business plan.

Best for: backtesting, portfolio analytics, global dashboards and anyone who wants one provider for prices and fundamentals.

Try EODHD with 10% off
30+ years of global market data, fundamentals and ETF holdings in one API. Use code KEVIN10.
→ Get your EODHD API key

Massive (formerly Polygon.io)

Polygon.io rebranded to Massive in October 2025. Existing keys and the old endpoint still work.

Pros

Strong US market infrastructure: WebSockets, trades, quotes and options.
Unlimited calls from the $29 Starter tier.
20+ years of history on the $199 Advanced plan.

Cons

Stock data on the $29 and $79 plans is 15-minute delayed. Real-time starts at $199.
US-focused. International equities aren't the core product.
Each asset class has its own pricing ladder.

Best for: US trading bots, streaming apps and options-heavy projects.

Alpha Vantage

Pros

Very simple API, great for learning.
50+ technical indicators computed server-side.
Official MCP server.

Cons

The free tier dropped to 25 requests per day, which disappears fast.
The $49.99 entry plan is delayed. Real-time US data starts at $99.99.
No WebSocket streaming.

Best for: students, prototypes and indicator-driven research.

Financial Modeling Prep

Pros

Deep US fundamentals, ratios and financial statements.
High rate limits (300 to 3,000 calls/min depending on plan).
Official MCP server.

Cons

The Starter plan covers the US with up to 5 years of history. 30 years needs Premium.
Global coverage, ETF holdings and transcripts sit on the Ultimate tier ($149/mo billed annually).
Listed prices are annual billing; monthly is higher.

Best for: US fundamental analysis, valuation models and equity research tools.

Twelve Data

Pros

The most usable free tier for general development (800 requests/day).
Stocks, forex, crypto, ETFs and fundamentals under one API.
No daily limits on paid plans.

Cons

Production WebSocket streaming starts on the Pro plan ($99/mo).
Credit-based limits take some getting used to.

Best for: multi-asset apps that want one API from prototype to production.

Finnhub

Pros

60 calls per minute and real-time US trades over WebSocket on the free tier.
Interesting alternative datasets (insider trades, lobbying, supply chain).

Cons

The free tier is non-commercial and US-focused.
Paid plans are split by dataset, so costs add up if you need several.

Best for: real-time hobby projects and apps that use alternative data.

What about Yahoo Finance? Libraries like yfinance are great for a quick notebook. But they rely on unofficial endpoints with no SLA and no license for products. They break without warning. Don't build anything that matters on them.

How to Test a Stock API Before You Commit

Marketing pages all look the same. Data doesn't.

Before paying, run the same three checks against every provider on your shortlist using its free tier or trial:

Coverage: does it return your actual watchlist?
Depth: how far back does each ticker go?
Quality: are prices adjusted correctly around a known split?

Here's the script I use, shown with EODHD. The logic ports to any provider in a few lines.

pip install requests pandas

Check 1 and 2: coverage, depth and latency

import time
import requests
import pandas as pd

API_KEY = "YOUR_EODHD_API_KEY"
BASE = "https://eodhd.com/api"

# Your real watchlist: US, Europe, Asia, an ETF and crypto
WATCHLIST = ["AAPL.US", "NVDA.US", "SPY.US", "SAP.XETRA", "VOD.LSE", "7203.TSE", "BTC-USD.CC"]

def check(symbol):
    t0 = time.perf_counter()
    r = requests.get(
        f"{BASE}/eod/{symbol}",
        params={"api_token": API_KEY, "fmt": "json", "from": "1980-01-01"},
        timeout=30,
    )
    latency = round(time.perf_counter() - t0, 2)
    if r.status_code != 200 or not r.json():
        return {"symbol": symbol, "available": False, "latency_s": latency}
    df = pd.DataFrame(r.json())
    return {
        "symbol": symbol,
        "available": True,
        "first_date": df["date"].iloc[0],
        "rows": len(df),
        "latency_s": latency,
    }

report = pd.DataFrame([check(s) for s in WATCHLIST])
print(report.to_string(index=False))

The output gives you one row per ticker: whether it exists, when its history starts, how many daily bars you get and how long the request took. Run it on each shortlisted provider and compare the tables side by side. Missing tickers and short histories jump out immediately.

Check 3: adjusted prices around a split

r = requests.get(
    f"{BASE}/eod/NVDA.US",
    params={"api_token": API_KEY, "fmt": "json", "from": "2024-06-05", "to": "2024-06-12"},
)
df = pd.DataFrame(r.json())[["date", "close", "adjusted_close"]]
print(df.to_string(index=False))

NVIDIA split 10-for-1 on June 10, 2024. In the close column, the price drops by roughly 10x overnight. In the adjusted_close column, the series stays continuous.

If a provider gives you only the first column, every return, drawdown and correlation you calculate across that date will be wrong.

From here you can extend the script to:

test fundamentals for the same watchlist,
measure how your request volume maps to each provider's rate limits,
log results over a week to check reliability.

An hour of testing now saves weeks of migration later.

Which Stock API Should You Choose? A Decision Framework

Match your project to its non-negotiables.

Building a backtesting engine or doing quant research?
Prioritize historical depth, adjusted prices and delisted tickers. Real-time is irrelevant. EODHD fits well here, and Massive's higher tiers do for US-only work.

Building a portfolio tracker or finance dashboard?
Prioritize global coverage, ETFs, fundamentals and cost. End-of-day or delayed data is almost always enough. EODHD or Twelve Data for global scope, FMP if the product is US fundamentals-first.

Building a real-time trading bot for US stocks?
Prioritize WebSocket streaming and latency. Budget for real-time from the start. Massive, Finnhub or Twelve Data Pro.

Learning, teaching or prototyping?
Prioritize the free tier. Twelve Data, Finnhub or Alpha Vantage get you started without a card. Just don't build your production pipeline on assumptions from a free plan.

Building a commercial product?
Everything above still applies, plus: talk to sales about the commercial license before you write your first line of production code.

Key Takeaways

There's no best stock API, only the best one for your trade-offs. Define your non-negotiables first.
Real-time data is the biggest cost driver. Most projects run fine on end-of-day data.
Test with your own watchlist and a known split before paying. Data quality problems don't show up in feature tables.

FAQs

❓ What is the best stock API in 2026?
✅ It depends on the project. For global historical data and fundamentals from one provider, EODHD is a strong choice. For US real-time streaming, Massive (formerly Polygon.io) and Finnhub are specialists. For free prototyping, Twelve Data and Finnhub have the most usable free tiers.

❓ Is there a free stock API with real-time data?
✅ Finnhub's free tier includes real-time US trades over WebSocket for personal, non-commercial use. Most other providers reserve real-time data for paid plans.

❓ What's the difference between real-time and end-of-day stock data?
✅ Real-time data updates during market hours, trade by trade or second by second. End-of-day data gives you one bar per day (open, high, low, close, volume). End-of-day is enough for backtesting, portfolio analytics and daily screeners, and it costs much less.

❓ Can I use a stock market API with Python?
✅ Yes. All the providers in this guide offer REST APIs that return JSON, which you can load into pandas with a few lines using requests. Several also offer official Python SDKs.

My Personal Pick: EODHD

Everything above is meant to help you decide for yourself. But people always ask me which one I actually use.

For most of my projects, it's EODHD.

Not because it wins every category. It doesn't. If I were building a US options trading bot, I'd look at a specialist.

I choose it for two reasons.

Ease of use. One ticker format for every market. One API key. Prices, fundamentals and ETF holdings that come back in a clean JSON I can drop into pandas in a couple of lines. I rarely open the docs twice for the same endpoint.

Versatility. In the last year I've used the same API for a portfolio risk analysis, a dividend screener, backtests going back to the 1990s, European and Asian stocks, crypto, and AI agents that query market data through its MCP server. I never had to add a second provider or rewrite my ticker mapping.

That's the trade-off I care about most: one provider that covers 90% of what I build, instead of three providers that each cover 100% of one thing.

If your projects look like mine (analytics, research, dashboards, AI workflows), it's where I'd start.

Final Thoughts

The expensive mistake isn't picking the wrong API.

It's finding out you picked the wrong one after you've built on top of it.

Decide what you can't live without. Test it. Then commit.

Start with 30+ years of global market data
Prices, fundamentals, ETF holdings and bulk downloads from one API, plus an MCP server for AI workflows. 10% off with code KEVIN10.
→ Try EODHD APIs

More tutorials on Python, APIs and fintech at kevinmeneses.com.

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

End-of-Day Stock Data API in Python: Full Guide (2026)

Kevin Meneses González — Wed, 02 Sep 2026 16:05:22 +0000

Good decisions come from good data. Bad decisions come from a CSV you scraped off a website that changed its layout three weeks ago.

That's the part nobody tells you when you start building anything that touches stock prices: getting the numbers is easy. Getting numbers you can actually trust, at scale, for years of history, without your script breaking every time a website updates its frontend, is a different problem.

If you're:

backtesting a trading strategy,
building a portfolio tracker,
or feeding price history into an AI agent,

this is the part of your stack that decides whether the rest of it means anything.

Why web scraping isn't a real solution

The instinct is understandable. Yahoo Finance shows the price right there in the browser. Why not just scrape it?

Because that price on the page isn't built for you. It's built for a human reading a chart, and the moment you try to automate against it, you inherit every problem that comes with scraping a site that was never designed to be an API.

The layout changes without notice. Your parser breaks on a Tuesday and you don't find out until your backtest returns garbage numbers. Rate limits and IP blocks show up with no warning and no documentation to check against. And free sources like Yahoo Finance don't guarantee you're getting the same adjusted price twice: request the same historical date on two different days and you can get two different numbers, because the adjustment recalculates as new splits and dividends occur.

None of this is a minor inconvenience. If your backtest is quietly using unadjusted closes for half your date range, your Sharpe ratio is a work of fiction.

There are three mistakes almost everyone makes the first time they touch stock data programmatically:

Mixing up close and adjusted_close. The raw close doesn't account for splits or dividends. If you compute returns from raw close, a stock that did a 4:1 split shows up as an 75% crash on your chart. It didn't crash. Your data did.
Ignoring pagination and date ranges on long history pulls. Thirty years of daily bars for one ticker is over 7,500 rows. Pull it wrong and you'll silently truncate history without an error telling you so.
Hardcoding the API token in the script. It ends up in a GitHub commit within a month. Every time.

The real problem is reliability, not access

Getting stock prices was never the hard part. Getting consistent, correctly adjusted, well-documented stock prices, for enough history to build something real, is what actually matters.

This is where a proper data API earns its keep.

EODHD's End-of-Day API

EODHD covers more than 150,000 tickers across stocks, ETFs, funds, indices, forex, and crypto, with history going back over 30 years for many US symbols (Ford's data starts in June 1972). Bars are available daily, weekly, or monthly, and every request returns the full price series for a symbol, or a sliced date range if you set one.

You can test it right now without registering. The DEMO key gives full, unrestricted access to a handful of tickers: AAPL.US, TSLA.US, VTI.US, AMZN.US, BTC-USD.CC, and EURUSD.FOREX.

If you're already testing something with a client, drop the affiliate link and this CTA here as a soft nudge:

Try it before you build on it
Test the End-of-Day API right now with the free DEMO key, no signup required.
→ Get your API token

EODHD vs web scraping vs Yahoo Finance

1. EODHD — structured API, paid tiers

A REST API with documented parameters, consistent adjusted pricing, and 30 years of depth for major US tickers.

Pros

Consistent adjusted_close calculated the same way every time you query it
150,000+ tickers across stocks, ETFs, forex, and crypto, one auth method for all of them
Official libraries for Python, R, Node, PHP, and an MCP server for AI agents

Cons

Free plan caps at 20 calls/day and one year of history
Paid plans start at $19.99/month, which is a real cost for a side project

Best for: anything that needs to run unattended, backtests, dashboards, agents, and can't tolerate silent data errors.

2. Web scraping — free, fragile

Parsing HTML off a finance site instead of calling an API it wasn't built to expose.

Pros

No cost, no signup
Works on literally any page with visible data

Cons

Breaks the moment the site changes its markup, with no warning and no changelog to check
No guarantee the adjusted price is calculated consistently between two requests
Sits in a legal gray zone against most sites' terms of service

Best for: a one-off manual check. Nothing you plan to run twice.

3. Yahoo Finance (unofficial endpoints) — free, unstable

The most common free fallback, usually accessed through unofficial wrappers rather than a supported API.

Pros

Free, and covers a huge range of tickers
Widely documented in tutorials, easy to get something running fast

Cons

No official API. Every wrapper depends on endpoints Yahoo can change or kill without notice
Historical adjusted prices have been reported to shift retroactively between pulls
No SLA, no support channel, no changelog when something breaks

Best for: quick prototyping when correctness doesn't matter yet.

Getting the data with Python

There are two ways to do this. Raw requests, or the official eodhd library.

Option 1: Raw requests

import requests

url = "https://eodhd.com/api/eod/MCD.US"
params = {
    "api_token": "YOUR_TOKEN",
    "from": "2024-01-02",
    "to": "2024-01-05",
    "period": "d",
    "fmt": "json"
}

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

print(data)

Output:

[
  {
    "date": "2024-01-02",
    "open": 295.05,
    "high": 297.28,
    "low": 295.05,
    "close": 297.04,
    "adjusted_close": 279.9221,
    "volume": 4458400
  },
  {
    "date": "2024-01-03",
    "open": 297,
    "high": 297.99,
    "low": 294.25,
    "close": 294.39,
    "adjusted_close": 277.4248,
    "volume": 3114800
  }
]

Notice the gap between close and adjusted_close. That's not a bug, it's McDonald's dividend history baked into the price. close is the raw traded price. adjusted_close accounts for both splits and dividends, and volume is adjusted for splits. If you need OHLC adjusted for splits only (not dividends), that's a separate call to the Technical Indicators endpoint with function=splitadjusted.

Key parameters worth knowing:

period: d, w, or m for daily, weekly, monthly bars
order: a for oldest-first, d for newest-first
filter: skips the whole series and returns one bare value instead, last_close, last_volume, and similar options exist. Useful if you just need today's number for a spreadsheet function and don't want to parse an array for it

Option 2: The official eodhd Python library

pip install eodhd -U

from eodhd import APIClient

api = APIClient("YOUR_TOKEN")
resp = api.get_eod_historical_stock_market_data(
    symbol="MCD.US",
    period="d",
    from_date="2024-01-02",
    to_date="2024-01-05",
    order="a"
)

print(resp)

Same data, less boilerplate. The library also wraps fundamentals, intraday data, splits, dividends, screener queries, and technical indicators under one client, so if this is the first of several EODHD endpoints you'll be touching, it's worth installing from the start.

Turning the response into something usable

A raw JSON array is fine for a script. For anything you're going to analyze, you want it in pandas.

import pandas as pd
import requests

url = "https://eodhd.com/api/eod/AAPL.US"
params = {
    "api_token": "YOUR_TOKEN",
    "from": "2025-01-01",
    "period": "d",
    "fmt": "json"
}

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

annual_return = (df["adjusted_close"].iloc[-1] / df["adjusted_close"].iloc[0]) - 1
print(f"AAPL return: {annual_return:.2%}")

Nine lines, and you've got a proper time-indexed DataFrame with a return calculation that actually accounts for corporate actions. Try the same thing with a raw close from a scraped page and watch your number quietly drift every time there's a split.

From here you can build:

a stock screener that filters by return over a custom window
a risk model comparing volatility across a basket of tickers
a scheduled job that refreshes a portfolio dashboard every night after market close

Where this fits into agentic workflows

The EOD endpoint on its own is a data pull. Wire it into an MCP server or a connector API, and it becomes something an AI agent can query on its own, without you writing a new integration every time you want to ask a different question.

EODHD ships an official MCP server with two versions: v1 authenticates with an API key in the URL and works with ChatGPT, Claude Code, and custom agents. v2 runs OAuth 2.1 with dynamic client registration, built for Claude Desktop and other MCP clients with native OAuth support. Either version exposes 72 read-only tools across market data, fundamentals, news, and technicals, plus over 100 pages of API documentation embedded as MCP resources, so an agent can look up parameter names and plan coverage without spending an API call to do it.

In practice, that means you can point an agent at the server and ask a question in plain language instead of writing a new integration for it. Here's what that looks like calling Claude directly with the EODHD MCP server attached:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcp.eodhd.com/v2/mcp",
            "name": "eodhd-mcp"
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Pull McDonald's daily closes for Q1 2024 and flag any day where volume was 3x the 30-day average."
        }
    ]
)

print(response.content)

No hardcoded ticker logic, no separate script for volume spikes. The agent calls the EOD tool, pulls the window it needs, computes the rolling average, and flags the outliers, all inside one request. Change the question next week ("do the same for AAPL and TSLA, compare them") and there's no new code to write, just a different prompt.

That's the shift agentic AI brings to financial data: the API doesn't just answer one hardcoded question, it becomes something an agent can reason over.

If you're building or advising on this kind of stack, this is worth testing directly:

Building an AI agent that needs financial data?
The EODHD MCP server gives your agent structured access to 30+ years of price history, no custom API wrapper required.
→ Explore the MCP server

Key takeaways

adjusted_close is the number you want for return calculations, not close. Confusing the two is the single most common mistake in this space.
The filter parameter (last_close, last_volume, etc.) skips full-series parsing when you only need one number.
Web scraping and free sources like Yahoo Finance trade reliability for convenience. That trade gets expensive the moment your analysis needs to be reproducible.

FAQs

❓ Is there a free end-of-day stock data API?
✅ Yes. EODHD's free plan includes the End-of-Day API with 20 calls per day, limited to the past year of history. The DEMO key gives unlimited access to six test tickers with no signup at all.

❓ What's the difference between close and adjusted_close?
✅ close is the raw traded price for that day. adjusted_close factors in every split and dividend since, so historical prices stay comparable across time. Always use adjusted_close for return calculations and charting.

❓ Can an AI agent query this data directly?
✅ Yes, through EODHD's official MCP server. It exposes 72 tools over the Model Context Protocol so agents like Claude can request market data, fundamentals, and technicals directly in a conversation, without a custom API integration.

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

Want to see more breakdowns like this?
I write about fintech APIs, Python, and AI agent tooling.
→ Visit kevinmeneses.com

Build an AI Financial Agent with EODHD's MCP Server

Kevin Meneses González — Fri, 14 Aug 2026 17:48:59 +0000

Most people building financial AI agents connect four or five APIs by hand.

One for prices. One for fundamentals. One for news. One for earnings dates.

The problem isn't lack of data. It's fragmentation.

If you're:

building a research copilot for equities,
automating pre-earnings screening,
or designing an agent that reasons across price, fundamentals, and sentiment,

this matters.

Here's how to build an AI financial agent that pulls all four together, using EODHD's financial data API as the backbone.

The Traditional Financial Data API Approach Breaks Down Fast

Here's what building a financial agent usually looks like with a plain REST API.

You write a function to fetch prices. Another to fetch fundamentals. Another for news. Then you write orchestration logic so your agent knows which endpoint to call, in what order, and how to merge the responses into something the model can reason about.

Each new data type means a new wrapper function.

Each wrapper function is a new failure point.

And every time the agent needs to answer a question that spans two data types, like "is this company's fundamentals strong enough to justify holding through earnings," you're the one stitching the context together, not the model.

Developers usually discover this the hard way. The agent works fine in a demo with one data source. Then a real question comes in that needs prices, fundamentals, and news at once, and the whole orchestration layer has to be rebuilt.

The Real Problem Is Context, Not Data

Financial agents don't need more APIs.

They need a way to reach every data type through one consistent interface, so the model can decide what to call and combine it, instead of you hardcoding that logic in advance.

That's what MCP (Model Context Protocol) is built for.

What an MCP Server Changes for Financial Data APIs

MCP (Model Context Protocol) standardizes how an AI model discovers and calls external tools. Instead of you writing a custom wrapper for every endpoint, the model sees a list of available tools with their schemas, and decides which ones to call based on the question it's answering. It's the same underlying idea as Claude function calling, just extended to a whole catalog of tools instead of one function at a time.

For financial data, this matters because a single question rarely maps to a single endpoint.

EODHD ships an official MCP server with over 70 tools covering fundamentals, historical and real-time prices, earnings calendars, news, and sentiment. You point your agent at the server, and it gets access to all of it without you writing a single API wrapper.

Skip the wrapper functions
EODHD's MCP server exposes 70+ financial data tools out of the box, ready for Claude and other AI agents.
→ Get your EODHD API key

Building the AI Financial Agent with EODHD's MCP Server

Let's build an agent that can answer a question spanning multiple data types in a single call: fundamentals, upcoming earnings, and recent price action for a given ticker.

Setup

pip install anthropic

You'll need an EODHD API token and an Anthropic API key. EODHD's MCP server is available as a hosted endpoint, so there's no server to run yourself.

Connecting the agent to EODHD's MCP server in Python

EODHD's MCP server has two versions: v1 takes your API key directly in the URL, v2 uses OAuth 2.1 for clients that support it (like Claude Desktop). For a server-side script like this one, v1 is simpler.

import anthropic

client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_API_KEY")

EODHD_API_KEY = "YOUR_EODHD_API_TOKEN"

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1500,
    messages=[
        {
            "role": "user",
            "content": (
                "Give me a quick pre-earnings health check on AAPL: "
                "key fundamentals, the next earnings date, and how the "
                "stock has moved over the last month."
            )
        }
    ],
    mcp_servers=[
        {
            "type": "url",
            "url": f"https://mcp.eodhd.com/v1/mcp?apikey={EODHD_API_KEY}",
            "name": "eodhd-mcp"
        }
    ]
)

for block in response.content:
    if block.type == "text":
        print(block.text)

What's actually happening here

The mcp_servers parameter is the whole trick. You're not calling three endpoints and merging the results yourself. You're handing the model a connection to EODHD's tool catalog and letting it decide what it needs.

For this one prompt, the model will typically:

Call a fundamentals tool to pull margins, revenue growth, and valuation ratios
Call an earnings calendar tool to find the next reporting date
Call a historical prices tool to compute the recent price move

Three tool calls, one conversation, zero orchestration code written by you.

Reading the response

The API returns a mix of content blocks: text for the model's answer, mcp_tool_use for each tool it called, and mcp_tool_result for the raw data. If you want to inspect what the agent actually pulled (useful for debugging or logging), filter by block type instead of assuming a fixed order:

tool_calls = [
    {"name": b.name, "input": b.input}
    for b in response.content
    if b.type == "mcp_tool_use"
]

for call in tool_calls:
    print(call["name"], call["input"])

This is worth doing early. It shows you exactly which tools the model reached for, which helps you spot when it's calling something unnecessary or missing a data type your prompt implied.

Scoring Stock Opportunities with EODHD's Financial Data API

The MCP agent above decides on its own which EODHD tools to call. That's convenient, but it also hides what's happening. If you want to actually understand (and customize) the logic behind "which stocks look like good opportunities," it helps to call the same EODHD endpoints directly and build the scoring yourself.

This is also useful if you want a scheduled script that scans the market every morning instead of waiting for you to ask a chat agent.

Let's build that: a short pipeline that pulls candidates from the Screener API, pulls fundamentals and recent price action for each one, checks the news sentiment, and combines all of it into a single opportunity score.

Step 1: Shortlist candidates with the Screener API

Instead of pulling fundamentals for thousands of tickers, start narrow. The Screener API filters the entire market down to a shortlist in one request.

import requests

API_TOKEN = "YOUR_EODHD_API_TOKEN"

def get_candidates():
    url = "https://eodhd.com/api/screener"
    params = {
        "api_token": API_TOKEN,
        "sort": "market_capitalization.desc",
        "filters": '[["market_capitalization",">",1000000000],'
                   '["exchange","=","us"],'
                   '["sector","=","Technology"]]',
        "limit": 20,
        "fmt": "json",
    }
    response = requests.get(url, params=params)
    return response.json()["data"]

candidates = get_candidates()
tickers = [c["code"] for c in candidates]
print(tickers)

This pulls US tech stocks above $1B market cap, sorted by size. Swap the filters for whatever criteria define a "good price" to you: low P/E, high dividend yield, positive EPS growth, or a 52-week low signal.

Step 2: Pull fundamentals for each candidate

Once you have a shortlist, fetch the fundamentals for each ticker. This is where you check whether the price is actually backed by solid financials, not just cheap for a reason.

def get_fundamentals(symbol):
    url = f"https://eodhd.com/api/fundamentals/{symbol}.US"
    params = {"api_token": API_TOKEN, "fmt": "json"}
    data = requests.get(url, params=params).json()

    highlights = data.get("Highlights", {})
    return {
        "pe_ratio": highlights.get("PERatio"),
        "peg_ratio": highlights.get("PEGRatio"),
        "profit_margin": highlights.get("ProfitMargin"),
        "eps_growth": highlights.get("EPSEstimateNextYear"),
    }

Step 3: Check recent price action

Fundamentals tell you if a company is healthy. Price history tells you if the market has already priced that in, or if there's a gap worth paying attention to.

import pandas as pd
from datetime import date, timedelta

def get_price_trend(symbol):
    url = f"https://eodhd.com/api/eod/{symbol}.US"
    params = {
        "api_token": API_TOKEN,
        "period": "d",
        "order": "d",
        "from": (date.today() - timedelta(days=90)).isoformat(),
        "fmt": "json",
    }
    prices = requests.get(url, params=params).json()
    df = pd.DataFrame(prices)

    last_close = df.iloc[0]["close"]
    month_ago_close = df.iloc[21]["close"] if len(df) > 21 else df.iloc[-1]["close"]
    change_pct = ((last_close - month_ago_close) / month_ago_close) * 100

    return {"last_close": last_close, "change_30d_pct": round(change_pct, 2)}

A stock with strong fundamentals that just dropped 15% in a month is a very different opportunity than one that already ran up 40%.

Step 4: Read the news sentiment

Price and fundamentals don't tell you why a stock moved. Sentiment fills that gap, and it's often what separates a real opportunity from a value trap.

def get_sentiment(symbol):
    url = "https://eodhd.com/api/sentiments"
    params = {
        "s": f"{symbol}.US",
        "api_token": API_TOKEN,
        "from": (date.today() - timedelta(days=14)).isoformat(),
        "fmt": "json",
    }
    data = requests.get(url, params=params).json()
    entries = data.get(f"{symbol}.US", [])
    if not entries:
        return {"avg_sentiment": None}

    avg = sum(e["normalized"] for e in entries) / len(entries)
    return {"avg_sentiment": round(avg, 3)}

Step 5: Combine everything into a single score

This is the part a raw API can't do for you. Each endpoint gives you one dimension. Deciding what a "good opportunity" means is a judgment call, and it belongs in your code, not buried in someone else's black-box score.

def score_opportunity(symbol):
    fundamentals = get_fundamentals(symbol)
    price = get_price_trend(symbol)
    sentiment = get_sentiment(symbol)

    score = 0

    if fundamentals["pe_ratio"] and fundamentals["pe_ratio"] < 25:
        score += 1
    if fundamentals["profit_margin"] and fundamentals["profit_margin"] > 0.10:
        score += 1
    if price["change_30d_pct"] < -5:
        score += 1
    if sentiment["avg_sentiment"] and sentiment["avg_sentiment"] > 0.15:
        score += 1

    return {
        "symbol": symbol,
        "score": score,
        **fundamentals,
        **price,
        **sentiment,
    }

results = [score_opportunity(t) for t in tickers]
ranked = sorted(results, key=lambda r: r["score"], reverse=True)

for r in ranked[:5]:
    print(r["symbol"], "score:", r["score"], "| P/E:", r["pe_ratio"],
          "| 30d change:", r["change_30d_pct"], "%",
          "| sentiment:", r["avg_sentiment"])

Four data points, one loop, one ranked list. Reasonable valuation, healthy margins, a recent dip, and improving sentiment together are a much stronger signal than any one of them alone.

This scoring logic is intentionally simple. You'll want to weight it differently depending on your strategy: a value investor cares more about P/E and margins, a swing trader cares more about the price drop and sentiment shift. The point is that the four EODHD endpoints give you the raw material, and the decision logic is yours to tune.

None of this is financial advice. It's a framework for turning scattered data into a shortlist worth researching further, not a signal to buy.

Wiring this back into the agent

Once this scoring pipeline works as a standalone script, you can expose it to your MCP agent as a custom tool alongside EODHD's built-in ones. Then a prompt like "find me tech stocks that dropped recently but still look fundamentally solid" runs your exact scoring logic instead of the model guessing at criteria on its own.

That's the real advantage of combining direct API calls with MCP: you get full control over the decision logic, and the model still handles the natural-language layer on top of it.

This is, in practice, what it means to build an AI financial agent: not a single clever prompt, but a data layer you trust plus a model that knows when to reach for it.

From Here You Can Build

Once the agent can combine fundamentals, prices, earnings, and news on its own, the use cases stop being single-question demos.

pre-earnings screeners that flag weak fundamentals before a reporting date
sentiment-aware alerts that combine news tone with price moves
research copilots that answer multi-part questions without a rigid script

None of this requires new wrapper code. It requires better prompts and, occasionally, a narrower system prompt telling the agent which tools to prioritize.

Key Takeaways

Traditional REST integrations force you to write and maintain orchestration logic for every combination of data types
MCP moves that orchestration into the model itself, so one conversation can span fundamentals, prices, earnings, and news
Combining the Screener, fundamentals, price, and sentiment endpoints directly gives you full control over what counts as a "good opportunity," instead of relying on a single metric
EODHD's MCP server gives you 70+ financial tools without writing a single wrapper function, and you can add your own scoring logic as a custom tool on top of it

FAQs

❓ Do I need to run my own MCP server to use EODHD's tools?
✅ No. EODHD hosts the MCP server, so you connect to it with a URL and your API token, the same way you'd call a REST endpoint.

❓ Does MCP replace the EODHD REST API?
✅ No, it sits on top of it. The REST API still powers every tool call, MCP just gives the AI model a structured way to discover and use those endpoints without custom wrapper code.

❓ Can I limit which tools the agent has access to?
✅ Yes. You can scope the system prompt or restrict the conversation to specific tool categories if you don't want the agent reaching for endpoints outside a given use case, like keeping it to fundamentals and earnings only.

❓ Is this approach only useful with Claude?
✅ No. MCP is an open protocol, so EODHD's server works with any MCP-compatible client, including ChatGPT, Cursor, and Windsurf, not just Claude.

❓ How many API calls does a scan like this use?
✅ It depends on your shortlist size. Each screener request counts as 5 calls, and each fundamentals, price, or sentiment call for a ticker counts as 1. Scanning 20 candidates works out to roughly 65 calls, well within EODHD's free tier for occasional runs.

❓ Can I use this scoring script to automate actual trades?
✅ The script only ranks and prints candidates. Connecting it to a broker's execution API is a separate step, and it's worth adding manual review before any live-money decision, no matter how the shortlist was generated.

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.

Want more content like this?
Python, APIs, fintech, and AI agent tutorials for developers.
→ Visit kevinmeneses.com

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

Best 5 Browser Automation API for AI Agents in 2026

Kevin Meneses González — Thu, 06 Aug 2026 08:04:53 +0000

Every team building browser automation hits the same fork in the road. Manage headless Chrome yourself, or hand the whole problem to an API.

Browserless.io built this category. It turned "run a headless browser at scale" from a DevOps project into a single endpoint.

The question worth asking in 2026 isn't whether Browserless works. It's what actually competes with it, and when one of those alternatives fits your stack better.

If you're:

scraping data at scale,
running AI agents that need to browse the web,
or automating screenshots, PDFs, and testing pipelines,

this comparison is for you.

What a Managed Headless Browser API Actually Needs to Solve

A "headless browser API" sounds simple on paper. Send a URL, get back HTML, a screenshot, or a PDF.

In production, the real problems show up fast:

Browsers crash and leak memory under load
Websites detect and block automated traffic
CAPTCHAs interrupt otherwise working scripts
Sessions need to be debugged when an agent silently fails
Scaling from 10 to 10,000 concurrent sessions breaks naive setups

Every vendor in this space is really selling the same thing: someone else managing that complexity so you don't have to.

The Real Differentiator Isn't the Feature List

Most comparison articles line up checkboxes. Stealth mode, yes or no. CAPTCHA solving, yes or no. Proxy rotation, yes or no.

That's not where these tools actually diverge.

The real differentiator is production reliability, plus how a vendor responds when something breaks at 2am on a Sunday. A landing page can promise stealth browsing. It can't promise someone will answer your support ticket in twenty minutes.

That's the lens for this comparison.

5 Headless Browser APIs Worth Evaluating in 2026

1. Browserless.io

Browserless.io provides managed headless browser infrastructure built specifically for developers and engineering teams.

Its core offerings are BrowserQL (a stealth-first query language for bot bypass and structured data extraction), Browsers as a Service (a pooled cloud of Chromium, Firefox, and WebKit instances compatible with Puppeteer and Playwright), and straightforward REST APIs for screenshots, PDFs, and scraping. It also solves CAPTCHAs automatically, including reCAPTCHA, hCaptcha, and Cloudflare Turnstile.

The platform abstracts away browser lifecycle management: version updates, memory leaks, scaling, and detection avoidance become one API endpoint instead of a maintenance burden.

Pros

BrowserQL gives you stealth and structured extraction without hand-rolling anti-detection logic
Supports Puppeteer, Playwright, and Selenium with a one-line connection change
Self-hosting is available (through providers like Sliplane) if you want fixed infrastructure costs instead of per-unit billing

Cons

Paid plans range from $25/month (Prototyping) up to $350/month (Scale), and cost can climb quickly with concurrency
The free tier caps out at 1,000 units/month, which disappears fast in a real scraping job

Best for: teams that need full headless browser control (Puppeteer or Playwright scripts, PDF generation, multi-page navigation flows) without building that infrastructure themselves.

Looking for technical content that explains your API like this?
I write educational, SEO-optimized articles for developer tools and infrastructure companies, not marketing fluff.
→ Let's talk on LinkedIn

2. Hyperbrowser.ai

Hyperbrowser.ai positions itself as internet infrastructure built specifically for AI agents rather than general-purpose scraping.

It provides instant, scalable browser infrastructure with built-in CAPTCHA solving, proxy management, and anti-bot detection, plus HyperAgent, an AI-native automation framework that layers natural language commands (page.ai(), page.extract()) on top of standard Playwright.

Pros

Built around agent workflows from day one, not scraping retrofitted for agents
Falls back to regular Playwright when you don't need the AI layer, so you're not locked into one paradigm
Backed by Y Combinator, Accel, and SV Angel, with active engineering hiring

Cons

Small team (4 employees as of 2026), which means less dedicated support bandwidth than a larger vendor
Younger platform with a smaller track record at large scale compared to Browserless

Best for: teams building AI agents that need to browse and extract data using natural language instructions instead of brittle selector-based scripts.

3. Steel.dev

Steel.dev is an open-source browser API purpose-built for AI agents, with a clear focus on speed and observability.

Its published lifecycle benchmark shows Steel completing a create-connect-navigate-release cycle in an average of 0.89 seconds, which the team reports as 1.70x to 8.95x faster than other providers tested under the same conditions. It adds live session viewers, MP4 replays, and Agent Logs, a timeline of every click, navigation, and scroll an agent takes.

Pros

Open source, so you can self-host and audit exactly what's running
Agent Logs and session replay make debugging failed automation runs far less painful
Fast session starts matter directly for agent workloads that spin up and tear down browsers repeatedly

Cons

Early-stage company; smaller team and less enterprise track record than Browserless
Fewer built-in integrations outside the core Puppeteer/Playwright/Selenium compatibility layer

Best for: teams that want an open-source, self-hostable browser API and care about debugging tools as much as raw automation.

4. Surfsky.io

Surfsky.io is built around one specific problem: bypassing advanced anti-bot systems that block most standard headless browser setups.

It targets CAPTCHA, WAF, and bot-detection bypass as its primary differentiator, positioning itself directly against Browserbase and ZenRows on bypass reliability rather than general feature parity. The platform offers an API-first architecture designed to integrate with existing automation frameworks.

Pros

Purpose-built for the hardest scraping targets: sites with aggressive anti-bot protection
Cloud-based infrastructure designed for scale without manual proxy management
API-first design means less glue code to plug it into an existing pipeline

Cons

Narrower focus than Browserless. Less useful if PDF generation, screenshots, or general testing automation are your primary use case
Smaller, less established brand compared to the other tools on this list

Best for: teams whose main blocker is bypassing sophisticated bot detection on specific high-value targets, not general-purpose browser automation.

5. Gaffa

Gaffa is a lightweight API for web scraping and browser automation aimed at developers who want one API call instead of managing browser infrastructure.

It handles residential proxies, scaling, and failure recovery internally, and supports actions like scrolling, clicking, and extracting page data as images, Markdown, HTML, or LLM-structured JSON. Credits are charged for actual browser execution time and bandwidth, with no fixed infrastructure costs.

Pros

Simple, single-endpoint design with low setup overhead
Native output as clean Markdown or JSON, useful for feeding LLM and RAG pipelines directly
Pay-for-usage pricing with no fixed infrastructure fees

Cons

Indie, early-stage project with a very small team, so support and roadmap velocity are unproven at scale
Fewer public case studies or production references compared to established vendors

Best for: solo developers or small teams that want a minimal, low-overhead scraping and automation API without evaluating a full enterprise platform.

Headless Browser API Comparison Table

Tool	Team size	Pricing model	Stealth / anti-bot	Self-host option	Best for
Browserless.io	Established	$25 to $350/month tiers, free tier (1,000 units)	BrowserQL stealth mode, CAPTCHA solving	Yes (via Sliplane, ~€9/month)	Full Puppeteer/Playwright control at production scale
Hyperbrowser.ai	~4 employees	Usage-based, free to start	Built-in CAPTCHA + anti-bot	No	AI-agent-native automation with natural language commands
Steel.dev	Early-stage	Open source, self-hosted or managed	Stealth browsing patches	Yes (open source)	Self-hosted browser API with strong debugging tools
Surfsky.io	Small	Not publicly listed	Advanced anti-bot / WAF bypass	No	Bypassing aggressive bot detection on specific targets
Gaffa	Indie / micro-team	Pay-per-execution, no fixed cost	Stealth mode with residential proxies	No	Solo devs needing a simple, low-overhead API

Key Takeaways

Browserless.io remains the safest default pick if you need full browser control (Puppeteer, Playwright, PDF generation) at production scale, backed by a mature platform and a self-hosting path.
If your workload is AI-agent-specific, Hyperbrowser.ai and Steel.dev are worth testing for their agent-native tooling and debugging features.
If bot detection bypass is your single hardest problem, Surfsky.io is a narrower but more targeted option than a general-purpose platform.

The smaller vendors on this list (Hyperbrowser, Steel.dev, Surfsky.io, Gaffa) can move faster on support and roadmap requests precisely because they're small. That's a real advantage, but it comes with less production history than Browserless.io has built over time.

For most teams evaluating a headless browser API in 2026, that trade-off, and not the feature list, is the decision that actually matters.

Building a developer tool in this space?
I create technical, SEO-optimized content like this comparison for API and infrastructure companies. If that's useful for your product, let's talk.
→ Connect with me on LinkedIn

More technical writing and projects:
→ kevinmeneses.com

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

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

Kevin Meneses González — Wed, 05 Aug 2026 13:52:53 +0000

Most trading bots are just if-statements wearing a costume.

RSI below 30, buy. Moving averages cross, sell. That works fine until the market does something the rules didn't anticipate, and then the bot keeps executing the same logic anyway, because it can't actually think.

If you're:

building AI agents that need to reason over structured data,
exploring what LLMs can actually do in a finance context,
or evaluating how to combine market data with automated decision-making,

this is for you.

The problem with rule-based bots

A rule-based bot doesn't understand the market. It pattern-matches against a formula someone wrote months ago.

Earnings surprise. A sudden news event. A sector rotation nobody coded for. The bot has no way to account for any of it, because it was never built to interpret context, only to check conditions.

Developers usually discover this the hard way. They backtest a strategy, watch it perform well on historical data, deploy it, and then spend the next few months tweaking thresholds every time the market shifts. The bot isn't wrong. It's just blind.

There's also the data problem underneath all of this. Plenty of hobby projects lean on scraped Yahoo Finance endpoints or free tiers that cap out fast, and both tend to fail exactly when you need them most.

The real problem

A trading bot doesn't need more rules. It needs reasoning.

That's a different kind of system entirely. Instead of "if X then Y," you want something closer to "given this data, what would a reasonable analyst conclude, and why."

Large language models are good at exactly that kind of contextual judgment, as long as you feed them clean, structured data instead of asking them to guess.

The stack

This tutorial combines two pieces:

EODHD API for market data. End-of-day prices, real-time quotes, fundamentals, and historical data through a single REST interface, without maintaining scrapers that break every time a website changes its HTML.

Claude for the reasoning layer. Given a snapshot of price action, volume, and basic fundamentals, Claude produces a structured decision (buy, hold, sell) along with the reasoning behind it, in a format your code can actually parse and act on.

You could swap either piece out. The point isn't "use these exact two tools forever," it's showing how the pattern works so you can adapt it.

Want reliable market data without building your own scraping layer?
EODHD covers over 150,000 tickers with a generous free tier and no rate-limit surprises mid-project.
Get your free EODHD API key →

Setting up

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

pip install requests anthropic python-dotenv

Store your keys in a .env file:

EODHD_API_KEY=your_eodhd_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Step 1: Pull market data from EODHD

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

import os
import requests
from dotenv import load_dotenv

load_dotenv()
EODHD_KEY = os.getenv("EODHD_API_KEY")

def get_market_data(ticker: str, exchange: str = "US"):
    symbol = f"{ticker}.{exchange}"

    # Last 30 days of end-of-day prices
    eod_url = f"https://eodhd.com/api/eod/{symbol}"
    eod_params = {
        "api_token": EODHD_KEY,
        "period": "d",
        "fmt": "json",
        "order": "d",
    }
    eod_resp = requests.get(eod_url, params=eod_params).json()[:30]

    # Live quote
    quote_url = f"https://eodhd.com/api/real-time/{symbol}"
    quote_params = {"api_token": EODHD_KEY, "fmt": "json"}
    quote_resp = requests.get(quote_url, params=quote_params).json()

    return {
        "ticker": ticker,
        "current_price": quote_resp.get("close"),
        "change_pct": quote_resp.get("change_p"),
        "volume": quote_resp.get("volume"),
        "recent_history": eod_resp,
    }

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

Step 2: Ask Claude to reason over the data

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

import json
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def get_trading_decision(market_data: dict) -> dict:
    prompt = f"""You are a trading analyst reviewing market data for {market_data['ticker']}.

Current price: {market_data['current_price']}
Change today: {market_data['change_pct']}%
Volume: {market_data['volume']}
Recent 30-day history: {json.dumps(market_data['recent_history'][:10])}

Based on this data, provide a trading decision. Respond ONLY with valid JSON in this exact format:
{{
  "decision": "buy" | "hold" | "sell",
  "confidence": 0.0 to 1.0,
  "reasoning": "2-3 sentence explanation grounded in the data provided"
}}"""

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=300,
        messages=[{"role": "user", "content": prompt}],
    )

    raw_text = response.content[0].text.strip()
    return json.loads(raw_text)

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

Step 3: Wire it together

def run_analysis(ticker: str):
    data = get_market_data(ticker)
    decision = get_trading_decision(data)

    print(f"\n{ticker} — Decision: {decision['decision'].upper()}")
    print(f"Confidence: {decision['confidence']}")
    print(f"Reasoning: {decision['reasoning']}")

    return decision


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

Sample output:

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

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

Testing it without risking real money

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

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

import alpaca_trade_api as tradeapi

alpaca = tradeapi.REST(
    os.getenv("ALPACA_API_KEY"),
    os.getenv("ALPACA_SECRET_KEY"),
    "https://paper-api.alpaca.markets",
)

def execute_paper_trade(ticker: str, decision: dict):
    if decision["decision"] == "hold":
        print(f"No action for {ticker}, holding position.")
        return

    side = "buy" if decision["decision"] == "buy" else "sell"

    alpaca.submit_order(
        symbol=ticker,
        qty=1,
        side=side,
        type="market",
        time_in_force="day",
    )
    print(f"Paper {side} order submitted for {ticker}.")

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

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

From here you can build:

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

Key takeaways

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

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

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

FAQs

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

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

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

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

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

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

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

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

7 Best OCR Tools with AI in 2026 (Compared)

Kevin Meneses González — Tue, 04 Aug 2026 08:18:47 +0000

Every "best OCR tool" article online is one of two things: a vendor's own product page, or a listicle that copied the same five names from another listicle. Neither tells you which tool actually fits what you're building.

This one does.

If you're:

digitizing scanned paperwork for a small team,
building a document pipeline that needs to run unattended,
or deciding whether an OCR API is worth the integration work,

this comparison is built around those three decisions, not around which vendor has the biggest marketing budget.

OCR still fails in predictable ways

Optical character recognition has gotten good enough that most people assume it just works now. Feed it a document, get clean text back.

That assumption breaks down fast on three kinds of input: a photo taken at an angle under bad light, a PDF with a table instead of plain paragraphs, and anything with handwriting. Vendor pages rarely mention this. They quote a single accuracy number, usually from a clean, high-resolution test document that looks nothing like what actually lands in most inboxes.

The other thing nobody advertises up front: uploading a document to a free online OCR tool means sending its content to someone else's server. For a random screenshot, that's irrelevant. For an ID, a payslip, or a signed contract, it's the first question you should be asking, not the last.

The real decision isn't "which OCR is best"

It's whether you need a one-off web tool, an API you call from code, or something self-hosted that never leaves your machine.

That single choice determines cost, speed, and how much control you have over where your data goes, more than any accuracy benchmark does.

Approach	How it works	Best for	Typical cost
Web tool (Adobe, Google Lens)	Upload a file, it's processed on the vendor's server, download the result	One-off use, low volume	Free with limits, or a paid plan for full features
API (Google Vision, Mistral OCR, Mindee, Unstract)	You call it from your own app or pipeline	Volume, automation, product integration	Per page or per call, usually a few cents
Self-hosted (Tesseract)	Runs on your own machine or server, nothing gets uploaded	Full data control, no recurring fee	Free, but you handle setup and tuning

Once you know which lane you're in, picking between tools gets a lot faster. Here are the 7 worth knowing.

1. Google Cloud Vision API: the default cloud OCR

Vision API is Google's general-purpose image analysis service, and text detection is one feature inside it, alongside label and object detection.

Google Vision is built for general OCR and image analysis, while specialized services like AWS Textract focus on structured document extraction such as tables and invoices. That distinction matters: Vision reads text well, but it returns raw text and bounding boxes, not structured fields. Pricing runs on a free tier of 1,000 images a month, then roughly $1.50 per 1,000 images for standard text detection, with a separate and considerably more expensive Document AI product for forms and tables.

Pros

Backed by Google's infrastructure, so uptime and language coverage are strong
Cheap at low-to-mid volume for plain text extraction
Well-documented Python SDK

Cons

Billing is split across features and products, and it's easy to underestimate cost once you add Document AI for tables
No built-in structured output for invoices or forms without the pricier add-on

Best for: developers who need reliable text extraction from images or scans and are comfortable managing a GCP project.

cloud.google.com/vision

2. Mistral OCR: the AI-native option built for RAG pipelines

Mistral built its OCR model specifically around modern document AI use cases: feeding clean, structured text into retrieval pipelines and AI agents.

Mistral OCR handles complex document elements including interleaved images, mathematical expressions, tables, and layouts like LaTeX formatting, and supports over 170 languages. It's priced per page rather than per token, which keeps costs predictable at scale, and a self-hosted deployment option exists for organizations that need to keep sensitive documents off shared infrastructure.

Pros

Markdown output with reconstructed tables, ready to drop into a RAG pipeline
Flat per-page pricing instead of token-based billing
Self-hosting available for privacy-sensitive workloads

Cons

Newer product, so community resources and third-party tutorials are thinner than Google's or AWS's
Overkill if you just need plain text from a handful of documents

Best for: teams building AI agents or RAG systems that need documents converted into clean, structured markdown.

mistral.ai

3. ABBYY: the enterprise veteran

ABBYY has been in document recognition longer than most of the other names on this list, and it shows in how many languages and document types it handles out of the box.

Its FineReader Engine SDK targets developers building OCR into desktop or server applications, while FineReader PDF is the consumer-facing product for individuals converting scans into editable files. Pricing for the SDK is quote-based and depends on volume and deployment, so there's no flat number to point to. The consumer product runs in the low hundreds of dollars per year.

Pros

Recognition quality across a very wide set of languages and scripts
Long track record in regulated industries like finance and legal

Cons

SDK pricing requires a sales conversation, which slows down evaluation for smaller teams
Feels dated next to API-first competitors built around REST and JSON from day one

Best for: enterprises with existing document workflows in legal, finance, or healthcare that need broad language support and are willing to go through a sales process.

abbyy.com

4. Mindee: developer-first document extraction

Mindee sits closer to Mistral than to Google: it's built for developers who want structured fields back, not just raw text.

It ships pre-trained models for invoices, receipts, IDs, and bank statements, so instead of parsing raw OCR output yourself, you get named fields like supplier name or total amount directly in the response. Pricing is usage-based, with a free tier for testing and a per-page rate that scales down as volume increases.

Pros

Pre-built models for common document types cut integration time significantly
Clear, transparent per-page pricing published on the site
EU-based, which matters for teams with GDPR requirements

Cons

Less flexible than a general OCR API if your documents don't fit the pre-trained categories
Custom document types require more setup than the ready-made models

Best for: teams processing a specific, repeatable document type (invoices, receipts, IDs) who want structured JSON without building their own parsing logic.

mindee.com

5. Unstract: open-source, no-code document pipelines

Unstract takes a different approach entirely: instead of a fixed OCR model, you define what you want extracted using prompts, test them against sample documents, then deploy the result as an API or an automated pipeline.

It's open source under AGPL-3.0, available self-hosted through Docker, as a managed cloud service, or on-premise for enterprise deployments. Its OCR preprocessor, LLMWhisperer, is built to preserve the layout of tables and columns before handing the text to an LLM, which is exactly the kind of detail that matters when a document isn't just paragraphs of text.

Pros

Prompt-based extraction adapts to new document layouts without retraining
Open-source option removes vendor lock-in entirely
Built-in connectors for ingesting from S3, Dropbox, or a data lake

Cons

The no-code/prompt-based workflow has a learning curve if you're used to a simple REST call
Best results depend on which underlying LLM you pair it with, which adds a decision on top of the tool itself

Best for: teams that need to extract structured data from varied or changing document layouts without hand-coding a parser for each one.

unstract.com

6. Adobe Acrobat: the one everyone already has

More people search for Adobe's OCR than for any other tool on this list, mostly because Acrobat is already installed somewhere in every office.

OCR only ships in the Pro tier, not the free Reader. It converts scanned files into editable, searchable PDFs and can batch-process folders through Action Wizard. Adobe doesn't publish a specific accuracy figure the way ABBYY does, but it covers 50-plus languages with automatic detection, and the Pro plan runs close to $20 a month.

Pros

Already familiar to most office workers, so there's no learning curve
Batch processing across folders is straightforward
Output stays inside the PDF workflow most teams already use

Cons

No API for automated, high-volume processing, it's a desktop tool
OCR is locked behind the paid Pro tier, not available in free Reader

Best for: individuals or small teams doing occasional OCR inside a document workflow they already run through Acrobat.

adobe.com/acrobat

7. Tesseract: free, self-hosted, no data leaves your machine

Tesseract is the answer for anyone who read the privacy section above and decided nothing should leave their own infrastructure.

It's open source under the Apache 2.0 license, was originally developed at HP and later taken over by Google, and has a fully featured API that can be compiled for a wide range of targets, including Android and iPhone. It supports over 100 languages out of the box and runs entirely on your own hardware. Python developers usually reach it through the pytesseract wrapper.

Pros

Completely free, no per-page or per-call cost ever
Nothing gets uploaded anywhere, which settles the privacy question by design
Actively maintained, wide language support

Cons

Accuracy on messy scans or handwriting lags noticeably behind AI-native APIs
You own the image preprocessing and language-model tuning yourself, that work doesn't disappear, it just moves to you

Best for: developers who need full control over where documents are processed and are willing to handle image preprocessing themselves.

github.com/tesseract-ocr/tesseract

What no one else covers: what happens to your document

Every free online OCR tool works the same way behind the scenes: your file gets uploaded to a server, processed, and the result gets sent back. What happens to the file after that depends entirely on the vendor's retention policy, and most people never check.

Before uploading anything sensitive (an ID, a payslip, a signed contract) to a free web tool, three questions are worth answering:

Does the provider delete the file immediately after processing, or keep it for some retention window? Where are the servers located, which matters for GDPR if you're in the EU and for general data-handling expectations everywhere else? And does the free tier reuse uploaded documents to train future models?

If you can't find a clear answer to those three on the vendor's own site, treat that as the answer. For anything sensitive, either pick a tool with a documented deletion policy or process it locally with Tesseract, where the question doesn't even come up.

Need a technical writer who actually tests the tools?
I write developer-focused comparisons and tutorials for API and document-processing companies, not marketing copy dressed up as content.
→ Connect on LinkedIn

Three things to take away

Volume decides more than accuracy does: below a few hundred documents a month, a free web tool or Tesseract covers it, above that, an API pays for itself in time saved.

The advertised accuracy number is almost never the number you'll get on a bad scan or a handwritten form, budget for that gap when picking a tool for production use.

Privacy isn't a footnote, it's a selection criterion. Know where your document goes before you upload it, not after.

FAQs

What is OCR and what is it used for?
OCR (optical character recognition) extracts text from images or scanned documents so it can be edited, searched, or processed by software. It's used for digitizing paperwork, converting scanned PDFs into searchable files, and automating data entry from invoices, receipts, and forms.

What's the difference between traditional OCR and AI-powered OCR?
Traditional OCR matches character shapes against a fixed pattern library, which struggles with handwriting, unusual fonts, and messy scans. AI-powered OCR uses machine learning models trained on huge datasets, which handles those same cases far better and can also understand document structure like tables and forms.

Is it safe to upload documents to an online OCR tool?
It depends on the provider's data retention policy. Free tools don't always delete files immediately or disclose where they're processed. For sensitive documents, check the vendor's privacy policy first or use a self-hosted option like Tesseract.

What's the best free OCR tool?
Tesseract is the strongest free option if you're comfortable with some setup, since it runs entirely on your own machine. Google Vision and Mistral OCR both offer a limited free tier for testing before you need to pay.

When should I use an OCR API instead of a web tool?
Once you're processing documents regularly, automatically, or as part of a larger workflow, an API replaces manual uploads with a single function call and scales with your volume without extra manual work.

Is Tesseract still a good option in 2026?
Yes, for teams that prioritize cost and data privacy over top-tier accuracy on difficult documents. It's less accurate than AI-native APIs on handwriting or low-quality scans, but it's free, self-hosted, and actively maintained.

Looking for technical content like this for your company?

I write comparisons and tutorials for API and document-processing companies.
→ More about my work

5 Best Free AI Courses in 2026 (With Certificates)

Kevin Meneses González — Sat, 01 Aug 2026 11:22:26 +0000

Most people assume learning AI seriously means paying for a bootcamp or a $200 certification program.

That's not true anymore.

Open any search for "AI courses" and you'll land on the same problem every time: dozens of tabs, half of them paywalled, half of them outdated, and no clear sense of which one actually matches your level. You start an advanced course with zero foundations. You finish a beginner course you'd already outgrown. You bookmark five links and never open them again.

That's not a knowledge problem.

It's a filtering problem.

Most "best AI courses" roundups make it worse. They repeat the same generic Coursera or edX links, list them in no particular order, and never tell you whether a course assumes you can code or whether it teaches anything you couldn't already find in the docs for free.

The real problem isn't finding a course. It's finding the right one for where you actually are, in the right order.

That's what this list solves. Five free courses, all with certificates, ordered from complete beginner to advanced developer.

If you're:

starting from zero and just want to understand what AI actually is,
a developer wanting to build with LLMs and tools like Claude,
or already technical and looking to go deeper into Transformers and NLP,

there's a course below built for exactly that.

1. Anthropic Academy - Claude 101

Anthropic is the company behind Claude, one of the most capable AI models available today, with a rapidly growing set of tools around it.

Claude 101 is the foundational course inside Anthropic Academy. It covers what Claude actually is, how to start a conversation, and how to write better prompts to get more reliable results.

It also goes further than most beginner courses by introducing Projects, Skills, and MCP (Model Context Protocol), which is how Claude connects to external tools and data sources to extend what it can do.

The course includes a certificate you can add to LinkedIn or your resume.

→ Start Claude 101 on Anthropic Academy

Pros

Covers both fundamentals and practical prompt optimization
Introduces MCP, a concept most beginner courses skip entirely
Certificate included at no cost

Cons

Focused specifically on the Claude ecosystem, not model-agnostic

Best for: anyone starting from zero who wants a foundation built around a real, production-grade AI tool instead of abstract theory.

Anthropic Academy also offers a follow-up course on Claude Code, aimed at developers who want to use AI for programming tasks. Worth checking once you finish Claude 101.

2. AI For Everyone - Andrew Ng

If there's one instructor almost universally recommended for AI fundamentals, it's Andrew Ng.

AI For Everyone is a beginner-level course, roughly 7 hours long, that covers what AI actually is, the terminology you'll keep running into, and the practical differences between AI models. It also walks through small projects so the concepts don't stay purely theoretical.

Like the first course on this list, it's free and includes a certificate.

→ Start AI For Everyone on Coursera

Pros

Taught by one of the most recognized instructors in the field
Clear, jargon-light explanations of AI terminology
Includes practical mini-projects, not just lectures

Cons

Intentionally high-level. Not for anyone wanting technical depth

Best for: complete beginners who want a solid conceptual map before touching any code.

3. Hugging Face - NLP Course

Hugging Face functions as the GitHub of AI models. If you're building anything involving language models, you'll end up there eventually.

This course is more technical and assumes you already have some AI foundation. It covers Transformers, NLP fundamentals, tokenization, and how to fine-tune and optimize models so they work well with your own data.

→ Start the NLP Course on Hugging Face

Pros

Deep, hands-on coverage of Transformers and tokenization
Directly applicable to real model fine-tuning work
Free, with strong community support around it

Cons

Not beginner-friendly. Requires prior AI/ML context

Best for: developers ready to move from "using AI tools" to actually building and customizing models.

4. Google - Generative AI Learning Path

Google's ecosystem includes Gemini, one of the leading models alongside Claude and ChatGPT.

This learning path covers the fundamentals of generative AI, how Google's infrastructure supports these models, and how to build applications ranging from image generation to voice. It also explains what an LLM actually is and how to make use of the resources Google makes available to developers.

→ Start the Generative AI Learning Path on Google Skills

Pros

Covers multiple modalities: text, image, and voice generation
Backed by Google's own infrastructure and documentation
Multiple course tracks depending on your interest

Cons

Broader scope means less depth per topic compared to Hugging Face's course

Best for: developers who want to understand the infrastructure side of generative AI, not just the model layer.

5. ChatGPT - Building Agents and Workflows

The last course on this list focuses on something increasingly relevant in 2026: agents and workflow automation.

This free course, built around the ChatGPT ecosystem, takes about 90 minutes and covers how to build agents and automated workflows to handle repetitive tasks and improve your daily productivity.

→ Start Agents and Workflows on OpenAI Academy

Pros

Short and focused. Around 90 minutes total
Directly applicable to automating real tasks
Free, no certificate paywall

Cons

Shorter format means less depth than the other courses on this list

Best for: anyone who already understands AI basics and wants to start automating tasks with agents right away.

How to Choose Your Path

You don't need all five. Pick based on where you are:

Starting from zero? Anthropic Academy's Claude 101, then Andrew Ng's course.
Already technical, want to build models? Hugging Face's NLP course.
Interested in the infrastructure behind generative AI? Google's learning path.
Want to automate tasks right now? The ChatGPT agents course.

Want a personalized AI roadmap instead of a generic course list?
I offer 1:1 consulting sessions based on your specific goals and current AI setup.
→ Book a consultation

Key Takeaways

The best AI courses in 2026 are free and include certificates, no need to pay for a bootcamp to start.
Level matters more than course popularity. Match the course to where you actually are, not where you want to be.
MCP, agents, and workflow automation are now core topics, not optional extras, for anyone learning AI in 2026.

FAQs

❓ Are there really free AI courses with certificates in 2026?
✅ Yes. Anthropic Academy, Andrew Ng's AI For Everyone, and Google's Generative AI Learning Path all offer free certificates you can add to LinkedIn or your resume.

❓ What's the best AI course for complete beginners?
✅ Start with Anthropic Academy's Claude 101 or Andrew Ng's AI For Everyone. Both are designed for zero prior knowledge and take just a few hours to complete.

❓ Do I need to know how to code to take these courses?
✅ No. Courses 1, 2, 4, and 5 on this list require no coding background. Only Hugging Face's NLP course assumes prior technical experience.

Are you a software or API company that needs technical content, not marketing fluff?
I write SEO-optimized articles, tutorials, and video content that actually explain your product to developers.
→ Get in touch on LinkedIn

Want more AI and fintech content like this?
→ Explore more articles

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

How I Built a Portfolio Risk & Return Tracker with EODHD

Kevin Meneses González — Sat, 25 Jul 2026 10:33:40 +0000

Most retail investors track their portfolio in a spreadsheet.

Some upgrade to a free app that shows total value and daily change. That's it.

Neither tells you the numbers that actually matter: your annualized volatility, your Sharpe ratio, your beta against the market, your maximum drawdown, how correlated your positions really are with each other.

Institutional investors have had this for decades. Retail investors get a pie chart.

If you're:

managing your own portfolio across multiple brokers,
building a fintech side project,
or just tired of guessing how risky your holdings actually are,

this matters.

The spreadsheet problem

Excel is where most portfolios go to die.

You start with a clean sheet. One column per position, one row per transaction. It works — for about three months.

Then you add a new broker account. Then you start tracking dividends separately. Then a formula breaks because you inserted a row in the wrong place, and you don't notice until your total is off by 4%.

Spreadsheets don't calculate volatility, beta, or drawdown by default. You'd have to build those formulas yourself, pull historical prices manually, and keep them updated — forever, by hand.

Most people don't. So they end up managing a portfolio without knowing its actual risk profile.

The paid-tool problem

The other option is a paid portfolio tracker or a Bloomberg-style terminal.

These solve the calculation problem. They don't solve the trust problem.

Your position sizes, tickers, and entry prices sit on a third-party server.
You pay a monthly fee for metrics that are, mathematically, not complicated.
Many of these tools are optimized to upsell you into their brokerage or premium tier, not to give you a neutral view of your risk.

Sharpe ratio, beta, drawdown, correlation — these aren't proprietary black-box models. They're well-defined formulas. Paying $30/month to have someone else run them on your data, on their servers, is a trade-off a lot of people make without questioning it.

The real problem isn't a lack of financial data. It's a lack of a tool that computes real risk metrics, locally, without asking you to hand your portfolio to a third party.

Vault: a portfolio tracker that runs in your browser

I built Vault, an open source portfolio tracker with React 19 and Vite that uses the EODHD API to pull real market data and calculate six metrics that any serious investor should be tracking:

Returns — portfolio performance vs. S&P 500, indexed and per-position
Diversification — position weights and concentration (Herfindahl-Hirschman Index)
Risk — annualized volatility, Sharpe ratio, beta vs. market, 95% daily VaR
Drawdown — underwater curve and maximum historical drawdown
Correlations — Pearson correlation matrix between your holdings
Sector exposure — GICS sector breakdown from EODHD fundamentals

No backend. No account. No server storing your positions.

Everything runs in the browser, and your portfolio is saved in localStorage — on your machine, not on mine.

A quick note on EODHD

I've used EODHD across several projects before this one, mainly because of three things:

One API key covers historical prices, fundamentals, and search — no juggling three different providers
The free tier is generous enough to actually build and test a real project on it
Response format is consistent across endpoints, which cuts down on glue code

If you want to follow along or fork Vault, you'll need a key — get one free here.

How the calculations actually work

All the math lives in a single file: src/utils/finance.js. No external statistics libraries — every formula is implemented from scratch.

Time-weighted returns

Each day is weighted by the previous day's closing value. This matters more than it sounds: without it, adding a new position mid-month distorts your daily portfolio return.

Volatility and Sharpe ratio

Standard deviation of daily returns, annualized with √252, then converted to a Sharpe ratio against a configurable risk-free rate.

Here's the core of it, simplified to Python for clarity:

import numpy as np

def annualized_volatility(daily_returns):
    return np.std(daily_returns) * np.sqrt(252)

def sharpe_ratio(daily_returns, risk_free_rate=0.02):
    excess_returns = np.array(daily_returns) - (risk_free_rate / 252)
    return (np.mean(excess_returns) / np.std(daily_returns)) * np.sqrt(252)

Beta

Covariance of portfolio returns against the S&P 500 (GSPC.INDX on EODHD), divided by the benchmark's variance.

Drawdown

Percentage drop from the running peak of a growth-indexed curve (base 100). This is the number that tells you what it would have actually felt like to hold this portfolio through its worst stretch.

Correlation matrix

Pairwise Pearson coefficient between assets, aligned by date. This is the metric most retail portfolios get wrong without knowing it — five stocks can feel diversified and still move together 90% of the time.

Concentration (HHI)

Herfindahl-Hirschman Index applied to position weights. One number that tells you how concentrated you actually are, beyond "I have 12 positions so I'm diversified."

From here, the same building blocks extend into:

automated risk alerts
portfolio rebalancing scripts
backtesting engines

What it looks like in practice

You add a position, EODHD's Search + EOD endpoints autocomplete the ticker and the closing price on your purchase date.

From there, Vault renders your returns curve against the S&P 500, your correlation heatmap, and your sector exposure pulled straight from fundamentals data.

No manual formula-building. No re-entering prices when a position updates.

Key takeaways

Portfolio risk metrics (Sharpe, beta, drawdown, correlation) aren't proprietary — they're standard formulas most tools just gatekeep behind a paywall
Running them client-side means your positions never leave your browser
EODHD's Search, EOD, and Fundamentals endpoints cover everything needed to build this without stitching together multiple data providers

Try it yourself

git clone https://github.com/Kevinelectronics/portafoliotracker.git
cd portafoliotracker
npm install

Add your EODHD key to .env, run npm run dev, and add your first position.

Get your free EODHD API key
Vault runs entirely on EODHD's Search, EOD, and Fundamentals endpoints — no backend, no paywall on the metrics.
→ Get your EODHD API key

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.

Need technical content like this for your product?
→ kevinmeneses.com

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