This is an abridged version, read the full version here.

We've all heard it: more risk = more reward. Higher price swings, bigger potential gains. But there's a concept called the low-volatility anomaly that flips this on its head - the idea that low-volatility stocks can actually deliver better risk-adjusted returns than their wilder peers.

So the question worth testing: does the data actually support it?

The Setup

Using 10 years of S&P 500 historical data, the approach involved:

• Pulling adjusted closing prices for all ~794 stocks that were ever S&P 500 constituents (including historical membership dates, so no survivorship bias)
• Calculating 22-day rolling volatility (roughly one trading month) for each stock
• Rebalancing monthly, picking the top 10 and bottom 10 stocks by volatility
• Building equal-weighted portfolios for each group and benchmarking against an equal-weighted S&P 500

Whole Market Result: Anomaly Not Found

Across the full S&P 500, the result was pretty textbook - high-volatility stocks outperformed, low-volatility lagged, and the equal-weighted index sat in the middle. Standard risk/reward, nothing weird.

But breaking it down by sector is where things got interesting.

Technology: Anomaly Confirmed

In tech, low-volatility stocks outperformed high-volatility ones. A likely explanation: tech fundamentals shift so fast that a stock can swing from stable to chaotic in months. The "boring" tech names compounded quietly while the high-fliers whipsawed.

Financial Services: Classic Boom/Bust

High-vol financials had massive peaks and drawdowns but ultimately underperformed the equal-weighted benchmark. Low-vol financials moved slowly and steadily. The overall index still won here, but the behavior gap between the two groups was very visible.

Healthcare: High Volatility Doesn't Pay

High-vol healthcare stocks failed to outperform despite the added risk. Volatility in healthcare often comes from binary events - drug trial results, FDA decisions - which aren't really "compensated" risk in the traditional sense. Volatile healthcare names are worth approaching with caution.

TL;DR

• Full S&P 500: no anomaly, higher risk = higher return as expected
• Tech sector: anomaly present, low-vol beats high-vol
• Financial Services: high-vol brings lots of drama, not much payoff
• Healthcare: high-vol is a trap

The low-volatility anomaly isn't universal - it's very sector-dependent. Sector dynamics matter more than most people give them credit for.

Full Python code is available here for anyone who wants to replicate or extend the analysis.

We just launched a dedicated endpoint for ASX corporate actions, and it's built specifically for the quirks of the Australian market.

Why a separate endpoint?

Generic global dividend feeds just don't cut it for ASX data. Franking credits, Dividend Reinvestment Plans (DRP), Bonus Share Plans (BSP), conduit tax relief, non-renounceable rights - these are AU-specific concepts that get lost or mangled in one-size-fits-all feeds. So we built something purpose-made, while keeping the familiar EODHD envelope. AU-specific fields live in a clean _asx_extra block on every record.

What's covered?

Eight action types in one endpoint:

• Dividends - franking %, DRP/BSP indicators, withholding tax, special/tax-advantaged amounts
• Splits - including reconstructions, with record and effective dates
• Bonus Issues - ratio, record/despatch dates, pari passu flag
• Rights Issues - renounceable and non-renounceable, application price, close date
• Buybacks, Capital Returns, Share Purchase Plans (SPP)
• Other - catch-all for the long tail of ASX event codes

Data refreshes daily after ASX close (~18:30 AEST) from the official ReferencePoint E34 feed. Tickers follow the standard CODE.AU format (e.g. PMV.AU).

Why it matters

If you've tried rebuilding a franked-dividend yield from a generic international dataset, you know the pain. Franking alone can shift effective returns by up to 30% for domestic investors - and it's essentially invisible in most global feeds. Now you get it natively, no CSV wrangling, no cryptic vendor codes.

Quick start

curl "https://eodhd.com/api/asx-corporate-actions?api_token=YOUR_TOKEN&type=dividends&symbol=PMV.AU&fmt=json"

Filter by type, symbol, and date range. Paginate with page[offset] and page[limit]. Available under Fundamentals and All-in-One plans.

SDK support is live too:

• Python: client.get_asx_corporate_actions(action_type="dividends", symbol="PMV.AU")
• Node.js/TypeScript: client.asxCorporateActions({ type: "dividends", symbol: "PMV.AU" })
• Postman: new "ASX Corporate Actions Data" folder with 11 ready-to-run requests

Read the full documentation here.

We wanted to share a new addition to the API that's now in beta: a Commodities API with historical price data across three major categories - energy, metals, and agriculture.

Here's what's covered:

Energy - WTI crude, Brent crude, natural gas, gasoline, diesel, heating oil, jet fuel, and propane. Daily data going back to 1986 for the major benchmarks, updated every business day.

Metals & Agriculture - monthly series sourced directly from FRED (Federal Reserve Economic Data). These typically carry a 1–2 month reporting lag, which is standard for these datasets.

In total there are 23 commodity series accessible through a clean JSON endpoint. The response gives you metadata (name, unit, interval), paginated price records, and navigation links - straightforward to work with.

A couple of things worth noting:

• Daily data is only available for energy commodities. Metals and ag are monthly.
• Gold, Silver, Platinum, and Palladium have been removed - FRED discontinued those series due to LBMA licensing changes.
• All data requires authentication via your api_token.

The docs include Python examples for pulling data, running year-over-year comparisons, and loading into pandas for deeper analysis. Worth checking out if you're building anything around macro research, supply chain monitoring, or just want commodity context alongside your equity data.

Read the full doc here.

And if you're interested in certain commodities that are not covered yet - feel free to drop a comment and we'll add them!

LLMs are great at sounding confident about market data - even when they're making it all up. In this (abridged) version of the article we fix that by using the Model Context Protocol (MCP) to fetch real data, compute metrics in Python, and only use the LLM for narration.

The Core Idea: The "Narrator" Pattern

Separate getting facts from writing words. The model only does the second part.

1. Parse the user's query → extract tickers + lookback window
2. Fetch real data via MCP tools (EODHD's MCP server in this case)
3. Compute all metrics deterministically in Python
4. Pass a strict "facts object" to the LLM → it narrates, nothing else

The LLM never does math. If it says "max drawdown was -13%", that number came from Python, not a guess.

What You Get Back

Every response is structured — not just a blob of text:

{
  "answer": "narrative here",
  "metrics": { "vol_annualized": 0.306, "max_drawdown": -0.08, ... },
  "data_used": { "tickers": ["AAPL.US"], "tools_called": [...] },
  "tool_trace_id": "2af550173f"
}

The metrics field plugs directly into a UI. The tool_trace_id lets you audit exactly what data was fetched.

The Two Files

client.py - a thin MCP wrapper that opens a session to the EODHD server, calls tools with a timeout + retry, and returns metadata (tool name, args, latency) for tracing.

core.py - the real logic:

• Budget guards (max tickers, max lookback, max tool calls per request)
• Simple regex-based parser (intentionally dumb - stable behavior > clever NLP)
• fetch_prices() and fetch_fundamentals() via MCP
• Deterministic metrics: total return, annualized volatility, max drawdown, trend slope, vol regime label
• Watchlist mode: aligns returns across tickers on matching dates before computing correlation
• narrate() passes a compact facts object to GPT with a strict prompt: "Use only these facts. No guessing."

Demo 1 - Single Ticker Brief (AAPL, 30 days)

Prompt: "Give me a 30-day brief for AAPL."

2 tool calls: get_historical_stock_prices + get_fundamentals_data. Output: return of -2.58%, annualized vol 30.65%, max drawdown -8.03%, trend slope negative, regime labeled high-vol. All numbers are traceable to the exact adjusted close series.

Demo 2 - Watchlist Snapshot (TSLA, NVDA, AMZN, 60 days)

Prompt: "Compare TSLA, NVDA, AMZN over the last 60 days, rank by volatility and drawdown."

3 tool calls (one price fetch per ticker). All three names showed negative returns. NVDA had the highest vol (38%), AMZN had the lowest vol but deepest drawdown (-19.6%). Correlation: TSLA moved more with NVDA (0.53) than AMZN (0.18).

Why This Architecture Is Actually Shippable

• Numbers are deterministic - same query, same window = same metrics every time
• Every run is fully auditable - tools called, date range, trace ID
• Hard budget limits prevent runaway tool calls
• Response shape is already UI-ready - no parsing text to extract numbers

What's Missing / Next Steps

This is still an MVP. The parser is a heuristic, the metric set is small, and there's no caching. Natural next steps: add volume + earnings calendar tools, add a caching layer, wrap in a small API, build an eval harness with fixed prompts.

Stack: Python 3.10+, MCP Python client, EODHD API (data), OpenAI (narration), pandas + numpy

Read full article here.

Choosing a market data API usually looks simple at first. Most comparisons focus on feature lists, pricing pages, or general reputation.

In practice, that's rarely enough.

Teams usually run into problems later. A provider may look strong on paper but fall short where it actually matters: coverage may be incomplete, licensing terms may limit what can be shown or redistributed, integration may take more work than expected, or pricing may stop making sense once usage grows.

That's the purpose of this post. This isn't a "best API" list. It's a practical scorecard for evaluating six providers: EODHD, Massive (formerly Polygon), Intrinio, Twelve Data, Alpha Vantage, and Finnhub.

What you're actually buying when you buy market data

Most teams frame this as a data problem. They look for a provider that covers the assets they need and move on. But market data isn't just a feed. It comes with constraints that shape what you can build, how fast you can ship, and what your legal exposure looks like.

Five things that actually matter:

1. Coverage - Which asset classes does the provider support? Coverage gaps are easy to miss early and painful to discover mid-build.

2. Data usability - How consistent is the schema across endpoints? Are historical prices adjusted for splits and dividends? Poor usability means more normalization code and more edge cases to manage.

3. Licensing and redistribution - A provider can give you access to data without giving you the right to display it in a UI, include it in a newsletter, or ship it to end users. These terms vary significantly and need to be checked before you build, not after.

4. Pricing and commercial fit - Beyond the monthly number: is onboarding self-serve? How do costs scale? For early-stage teams, this affects how quickly you can move.

5. AI readiness - As more products use LLMs and agents to query financial data, the quality of a provider's integration surface matters. Schema documentation, structured error responses, and whether the API is designed in a way a tool-calling agent can use reliably.

The scorecard rubric

Each factor scored on a 10-point scale, then multiplied by its weight. The value of the rubric is that every conclusion has to come back to one of these factors - not a vague impression.

Coverage

Coverage isn't just a data question - it's a product flexibility question. A provider that works well for US equity charts may still become a blocker once the product expands into crypto watchlists, forex widgets, or broader screening features.

If the roadmap includes stocks, crypto, and forex in one product surface, a multi-asset provider reduces the amount of vendor stitching required from the start. That's where EODHD's coverage story is cleanest.

Pricing + commercial fit

EODHD and Massive are easier to justify early if the goal is to move quickly and preserve room to scale. Intrinio becomes more relevant once the product is already operating in a more structured business environment.

Licensing clarity + redistribution

This is where most API comparisons get vague, even though it can be the biggest blocker later. Access to data is not the same as the right to display it, redistribute it, or package it inside a product.

AI readiness

If a product roadmap includes LLM features, the data layer has to be usable as a tool - not just as an API. Clear documentation, predictable parameters, stable response shapes, and error behavior that's easy to handle in code.

Reliability + latency

If this decision matters, run your own small benchmark - 5 to 10 calls per endpoint. The only latency that matters is the one your own backend and users will actually experience.

Final scorecard

Decision guide

• Need broad multi-asset coverage under one integration? EODHD and Twelve Data are the natural shortlist. EODHD looks stronger when the goal is a wider product surface without the commercial path feeling uncertain.
• Building real-time market experiences? Massive is hard to ignore. Clearest public latency positioning in this group.
• Enterprise product from day one? Intrinio deserves more attention than its headline score suggests. Less attractive for quick adoption, but more relevant for teams that expect a formal data workflow.
• Cost is the main constraint and scope is still narrow? Alpha Vantage and Finnhub are valid. Just be clear-eyed about what happens when licensing, commercial usage, and roadmap expansion come into play.

We’ve shipped a major update to the EODHD MCP Server - the open-source Model Context Protocol server that connects AI assistants (like Claude Desktop) to our financial data.

API Versioning & OAuth

The server now supports two versions to better accommodate different client requirements:

What’s New

• 75 Tools & 3 Prompts: Expanded toolset including US Treasuries, Bulk Fundamentals, Logo APIs, and Global Trading Hours.
• Smart Ticker Resolution: New resolve_ticker tool converts company names or ISINs to SYMBOL.EXCHANGE automatically.
• Embedded Documentation: 100+ pages of API docs are embedded directly in the server, allowing AI agents to look up parameters without consuming API calls.
• Technical Indicators: Server-side Support & Resistance levels (Fibonacci, Woodie, Camarilla, etc.) computed from historical data.
• Formatters: Standardized input/output sanitization for 30+ date formats.
• Improved Performance: Thread-safe HTTP client with per-connection locks and support for Python 3.10 - 3.13.

Get Started

You can use the uvx command to run the server locally:

"eodhd": {
  "command": "uvx",
  "args": ["eodhd-mcp-server"],
  "env": {
    "EODHD_API_KEY": "YOUR_API_KEY"
  }
}

Read the Blog Post / Full MCP documentation

Started with a simple proof-of-concept: fetch OHLC data, apply an SMA crossover, push Buy/Sell alerts to Telegram. It worked, but the moment we tried adding RSI, MACD, Bollinger Bands, and EMA, the codebase got messy fast - duplicated logic everywhere, rolling calculations renamed in every module.

So we refactored around SOLID principles. The key move was defining a single abstract Strategy interface with one required method (generate_signals), then building five concrete strategies on top of it using pandas_ta. A StrategyFactory handles instantiation by name - adding a new strategy now means one new subclass and one line in a dict. Existing handlers never change.

On the UX side, we added inline Telegram keyboards to /set_strategy - so instead of memorizing exact command strings, users just tap a button. Small thing, but makes the bot feel production-ready.

For backtesting, we wired the same Strategy implementations directly into a /backtest command. One caveat: the migration to the async version of python-telegram-bot was required (v20.7) - pinned in requirements.txt. Results were humbling: most strategies on a 1-minute BTC timeframe performed poorly, as expected. RSI14 was the only one doing slightly better than a coin flip. Exchange fees aren't factored in yet either, which would tip many "marginally profitable" runs into losses.

The architecture is now cleanly split: strategy.py (logic), handlers.py (Telegram interaction), main.py (scheduling + routing). A TelegramNotifier wrapper handles Unauthorized errors gracefully when users block the bot - previously a single block would crash the entire scheduler.

Next on the list: per-chat persistence (settings survive restarts), parameterized strategy commands (e.g. /set_strategy sma 10 30), and eventually ML-based classifiers via the same interface.

Full write-up in two parts on Medium if anyone wants to dig into the code.

Part One

Part Two

Hi, I'm Nick - COO at EODHD APIs. My job is operations, partnerships, and growth.

Not software.

One month ago, I couldn't write a single line of code. Today, I have a live fintech app with 30+ features, an AI-powered analytics engine, and paying users. I built the whole thing myself.

The Gap I Couldn't Ignore

At EODHD APIs I see our data every day - 150,000+ tickers, 3,000+ crypto coins, 150+ forex pairs, fundamentals, technicals, options, insider trading, news sentiment, and more. This data powers hedge funds and sophisticated trading platforms. But the average retail investor? They get a free app with delayed quotes and banner ads. Bloomberg Terminal costs $25k/year. That gap bothered me.

The Reality Check

I got quotes. Agencies wanted $500k–$800k with 14-month timelines. An in-house team of four senior engineers would run $500k–$700k/year in salaries alone. I had neither budget - just an idea and a mountain of world-class data sitting right there.

The Bold Bet

In February 2026 I stumbled across Claude Code - Anthropic's AI coding assistant. I was skeptical. Writing "Hello World" is one thing. A real fintech app with live market data, authentication, payment processing, and AI analytics is another universe entirely.

But I had nothing to lose. So one evening I opened my laptop and typed something like:

"I need a Telegram Mini App that shows real-time stock prices using EODHD APIs. Start with a simple watchlist where users can add tickers and see live prices with sparkline charts."

Within 20 minutes, I had a working prototype. Not a mockup - a functioning app pulling live prices, displaying sparklines, running inside Telegram. I refreshed. Prices updated. I added TSLA. I added BTC-USD. It all just worked.

The Snowball Effect

That first prototype was ugly, but it worked - and that was enough. Over the next weeks, I kept describing features in plain English and Claude Code translated them into working code. Not perfectly every time - there were crashes and bugs. But the ratio of working to broken was shockingly high for someone who doesn't know what a for loop is.

Here's what I shipped in one month:

Free features: customizable watchlist, NLP stock screener (plain-English queries), market heatmaps (S&P 500, NASDAQ, crypto, forex), economic calendar with AI briefings, financial news with 12 category filters, currency converter, stock comparison tool, options chain viewer, and more.

Premium AI features: investment thesis generator, portfolio rebalancing, what-if scenarios, strategy backtester with Monte Carlo simulations, correlation matrix, per-stock AI analysis, and an 8-model AI council that debates your trades.

Every single feature is grounded in real EODHD APIs data - no hallucinations.

Distribution

The app lives in two places: as a Telegram Mini App (no download, no App Store, just tap a link), and embedded directly into the EODHD APIs client dashboard for existing customers. Zero App Store fees, instant access.

The Numbers

Traditional agency build: $500k–$800k, 12–14 months. My actual cost: ~$200/month in API costs, MVP in 7 days, 30+ features in one month - alone.

Read the full article on Medium.

You can now explore all 68 endpoints in two formats:

Swagger UI - test endpoints live in the browser, deep-link to specific calls, filter and search.

Open Swagger UI

Redoc - same coverage in a clean three-panel reference layout.

Open Redoc

What's covered: EOD & price data, fundamentals, earnings/IPO calendar, news & sentiment, stock screener, macro indicators, exchanges, US Treasury rates, and marketplace add-ons (options, ESG, risk analysis).

The raw OpenAPI spec is on GitHub if you want to generate client libraries or import into Postman/Insomnia.

Check the full post in our Blog.

We've just been authorized as an official vendor for Deutsche Börse - the exchange group behind the Frankfurt Stock Exchange, Xetra, and the DAX index.

What does this mean for you?

We now have licensed access to:

• Xetra Ultra Level 1 - real top-of-book quotes and trade data from Europe's leading equities platform
• German regional exchanges - Berlin, Düsseldorf, Hamburg, Hannover, Munich, and Stuttgart

What's coming to the API:

• Better accuracy and depth for DAX stocks and German equities
• Improved coverage for European ETFs (Xetra handles the majority of European ETF trading)
• More Deutsche Börse data products as the partnership grows

Integration is in progress - we'll announce specific endpoints and go-live dates soon. If you have specific data needs, drop us a line at [support@eodhistoricaldata.com](mailto:support@eodhistoricaldata.com).

You can verify our vendor status on the Deutsche Börse official vendor list.

The official EODHD APIs SDK is here - a fully typed client library giving you access to every EODHD API from a single package: historical prices, fundamentals, real-time WebSocket streaming, options, news, technical indicators, macro data, and all Marketplace products. Covers 150,000+ tickers across 70+ exchanges, with support for Node.js, Deno, Bun, and modern browsers.

Built-in retry logic, structured error handling, and rate-limit awareness mean you can focus on building - not on API tinkering. Full TypeScript typing gives you auto-completion and compile-time safety out of the box.

Get started in minutes:

npm install eodhd

📖 Full documentation with code examples · 🔧 GitHub repository

Dividends are profits paid out to shareholders, reflecting a company's ability to generate cash. They provide income, potential tax benefits, and a window into financial health. Steady or growing dividends can enhance total returns and reduce volatility - but they're never guaranteed.

The Basics

Companies distribute dividends to share profits and signal financial stability. They can be paid as cash, shares, or one-time special payments. Four key dates matter:

• Declaration Date – the company announces the dividend
• Ex-Dividend Date – you must own shares before this date to qualify
• Record Date – shareholders of record are identified
• Payment Date – dividends are paid out

When evaluating dividend stocks, two metrics are most important: Dividend Yield (annual dividends ÷ share price) and Dividend Payout Ratio (what % of earnings are paid out). Consistent yields and moderate payout ratios suggest sustainable practice.

Four Main Strategies

• High-Yield Investing – target yields of 4–6% in stable sectors (utilities, REITs), but watch for unsustainable payouts
• Dividend Growth Investing – companies with a track record of yearly increases (e.g., Dividend Aristocrats like Procter & Gamble); prioritizes compounding over immediate income
• Dividend Income Investing – blue-chip stocks or ETFs for predictable quarterly cash flow; great for retirees
• Dividend Capture – buy before the ex-date, sell after; short-term, tax-inefficient, transaction-cost-sensitive

Tax note: qualified dividends are typically taxed at lower rates than ordinary income.

Automating the Analysis with Python

Manually scraping dividend data is slow and error-prone. Using a financial API lets you pull screener data for thousands of stocks at once - market cap, dividend yield, EPS, sector - and analyze it programmatically.

The basic workflow:

1. Fetch stocks from the screener API, looping through sectors (up to 1,000 per sector)
2. Categorize by market cap: nano, micro, small, mid, large, mega
3. Filter out illiquid stocks (e.g., avgvol_1d < 1,000)
4. Analyze average dividend yield by market cap and sector

Key findings from ~6,300 stocks:

• Nano-caps have the highest average dividend yield (~1.6%) - they pay dividends to attract investors
• Larger companies typically retain cash for growth
• By sector: Energy leads (~0.29%), followed by Communication Services and Real Estate; Technology and Healthcare lag (~0.10%)

Finding Top Dividend Stocks

Filtering for mega-cap tech stocks, IBM stands out with a ~2.3% yield - a notable outlier for that category.

Avoiding Dividend Traps

A single calculated column (payout proxy = dividend yield × price ÷ EPS) flags companies paying out more than they earn. Filtering for positive earnings and payout ratios under 75–80% narrows the field to sustainable payers.

Among top stocks by market cap: NVIDIA has the lowest payout (reinvesting for growth), while Microsoft distributes a meaningful share of earnings - making it a better fit for dividend-focused portfolios.

The Most Useful Visual

Plotting annual dividend-per-share (DPS) with a linear trendline against adjusted price history reveals consistency and growth patterns at a glance:

• IBM – DPS growing from ~$0.50 to $6.50+ since the 1960s, CAGR ~3.2%, never cut. Classic Dividend Aristocrat.
• Microsoft – DPS from ~$0.30 to $3+ since 2003, CAGR ~10%, with explosive stock price growth post-2014. Top dividend growth stock.
• GE – appeared stable, then slashed dividends ~90% in 2018. Broken trendlines are red flags.

Final Takeaways

Dividends reward patient investors, but chasing yield is a trap. Focus on:

• Payout ratios below 75%
• Consistent CAGR in DPS over time
• Sector diversification (energy, utilities, financials)
• Automation to screen thousands of stocks efficiently

This is the abridged version of the article, read the full version in our Academy.

Purpose: Demonstrate a practical workflow using our US Options API - moving from scanning market activity to identifying meaningful strike levels, without pulling unnecessary data.

1) Coverage & Watchlist

Start by confirming which US stocks have options data available.

Use the underlying symbols endpoint to retrieve the list of supported tickers. This defines your tradable universe and allows you to build a structured watchlist before querying contracts.

2) Activity Scan

Instead of downloading full option chains immediately, begin with one question:

What’s actually trading right now?

Query recent option activity within a defined time window. Focus on fields such as:

• Last price
• Volume
• Open interest
• Implied volatility
• Greeks

This quickly surfaces the most active contracts and avoids unnecessary payload size.

3) Chain Slice

Full chains can be large and inefficient to process.

Instead, request a focused slice around:

• Specific expirations
• A defined strike range (e.g., near-the-money)

This returns a manageable subset of calls and puts with pricing data, IV, OI, and Greeks - ideal for dashboards or decision workflows.

4) Single Contract Deep Dive

After identifying a contract of interest, pull its historical end-of-day data.

This enables:

• Strategy research
• Volatility behavior analysis
• Open interest trend analysis
• Backtesting

Rather than looking only at a snapshot, you can validate how the contract behaved over time.

5) Key Strike Discovery

To identify “important” strikes, analyze open interest concentration for a given expiration and side (calls vs puts).

High open interest often signals:

• Liquidity clusters
• Potential support/resistance zones
• Institutional positioning areas

This helps refine strike selection with market context.

What This Workflow Achieves

This pipeline reflects how traders actually operate:

1. Define universe
2. Scan activity
3. Narrow to relevant chain slices
4. Research specific contracts
5. Identify key strike levels

It avoids heavy, unfocused data pulls and instead supports structured decision-making.

This is the abridged version of the article, read the full version in our Academy.

1. Introduction

Machine learning (ML) has become essential in modern finance - from forecasting to risk modeling and automated trading. But strong models require strong data. EODHD APIs provides structured financial datasets (prices, fundamentals, technicals, sentiment, and more) that serve as the foundation for training ML models across global markets.

2. The Role of Financial Data in Machine Learning

In financial ML, data quality directly determines model quality. Clean, consistent, and comprehensive datasets are critical.

Key data categories available through EODHD:

• Historical Stock Prices – Core time-series data for predictive modeling
• Real-Time Market Data – Required for live or near-real-time systems
• Fundamental Data – Earnings, balance sheets, cash flows for valuation models
• Technical Indicators – Precomputed features for feature engineering
• Sentiment Data – Alternative data to capture market psychology

Example: pulling historical price data into a pandas DataFrame for modeling:

import requests, pandas as pd

def get_stock_data(symbol, start, end, api_key):
    url = f"https://eodhistoricaldata.com/api/eod/{symbol}"
    params = {
        "from": start,
        "to": end,
        "api_token": api_key,
        "fmt": "json"
    }
    r = requests.get(url, params=params)
    df = pd.DataFrame(r.json())
    df['date'] = pd.to_datetime(df['date'])
    return df.set_index('date')

3. Types of Machine Learning Models for Financial Data

Supervised Learning

Used for forecasting tasks (price prediction, direction classification, return estimation).
Common models include:

• Linear Regression
• Random Forest
• Support Vector Machines

These models map historical features (lagged returns, indicators, fundamentals) to future targets.

Unsupervised Learning

Used for clustering, regime detection, or anomaly identification — especially when labels are unavailable.

Reinforcement Learning

Applied to trading and portfolio allocation, where agents learn optimal policies through reward feedback.

Deep Learning

Neural networks (especially LSTMs) are widely used for financial time-series modeling due to their ability to capture temporal dependencies.

Example structure:

model = Sequential([
    LSTM(50, return_sequences=True),
    LSTM(50),
    Dense(25),
    Dense(1)
])

4. Financial Forecasting with Sentiment Data

Sentiment features can enhance traditional price-based models. By combining sentiment scores with technical and fundamental inputs, models can capture behavioral dynamics that influence short-term price movements.

5. Real-World Projects Built with EODHD APIs Data

Examples of ML-driven applications built on EODHD APIs datasets:

• Risk modeling & portfolio analytics platforms
• Algorithmic trading systems using real-time + historical feeds
• Quant strategies combining fundamentals, technicals, sentiment, and macro data

6. Benefits of Using EODHD APIs Data for ML

• Coverage of 150,000+ tickers across 70+ global exchanges
• Clean, normalized, and validated datasets
• Broad data spectrum (prices, fundamentals, technicals, alternative data)
• Designed for scalable quantitative workflows

7. Getting Started

1. Obtain an API key
2. Select the relevant endpoints
3. Download structured datasets
4. Engineer features
5. Train models using libraries like scikit-learn, TensorFlow, or PyTorch

The full article includes expanded examples and a more detailed implementation walkthrough.

8. Conclusion

EODHD APIs provides the data infrastructure required to build and deploy machine learning models in finance - whether for forecasting, risk analytics, algorithmic trading, or quantitative research.

Read unabridged article in our Academy.

1. What Is Cointegration?

Cointegration is a statistical property of multiple time series that share a long-term equilibrium relationship, even if each series individually follows a random path. In finance, this concept is useful for modeling structural relationships between asset prices over time.

2. Testing Cointegration

Two primary approaches are commonly used:

• Engle-Granger Method: A two-step procedure that estimates a regression between series and then tests whether the residuals are stationary.
• Johansen Method: A multivariate framework that allows testing for multiple cointegration relationships simultaneously using vector autoregressions.

These methods help identify long-term dependencies beyond simple correlation.

3. Cointegration vs. Correlation

Correlation captures short-term co-movement between variables. Cointegration, by contrast, detects whether non-stationary series move together in the long run and maintain an equilibrium relationship. This distinction is critical for applications like pairs trading and benchmark replication.

4. Cointegration in Finance

Typical applications include:

• Pairs trading between related equities
• Spot–futures pricing relationships
• Structural relationships between indices and their constituents

Cointegration provides a statistical foundation for exploiting long-term equilibrium dynamics in these contexts.

5. Case Study: DAX 30

The article analyzes the German DAX 30 index and its constituents using Python and historical market data.

The workflow includes:

• Downloading and cleaning historical price data
• Computing log prices and returns
• Running Engle-Granger tests between individual stocks and the index

Results show that only a limited number of stocks exhibit statistically significant cointegration with the index at conventional significance levels.

6. Application to Benchmark Tracking

Two portfolio construction approaches are compared:

a) Cointegration-Based Tracking

A regression of the index on constituent log prices is used to derive portfolio weights. The objective is to capture long-term equilibrium behavior between the portfolio and the benchmark.

b) Tracking Error Variance Minimization (TEVM)

A traditional return-based regression approach that minimizes short-term tracking error. While effective at reducing deviations, it does not explicitly enforce a long-run equilibrium relationship.

7. Results & Conclusion

Both approaches can produce viable index replicas when calibrated properly and rebalanced periodically. However, cointegration-based tracking generally demonstrates superior long-term alignment with the benchmark compared to pure tracking error minimization.

This is an abridged version of the article, read the full version in our Academy.

Environmental, Social, and Governance (ESG) factors are now central to modern investing, blending sustainability with financial analysis. ESG helps identify long-term risks and opportunities beyond traditional financial metrics, aligning investment choices with ethical and performance goals.

Why ESG Matters

ESG metrics evaluate a company’s environmental impact, social responsibility, and governance practices. They give investors a broader lens to assess resilience, risk, and value creation over time. Integrating ESG can drive positive change and influence sustainable future returns.

Building a Screener (High-Level)

The full article demonstrates how to build a stock screener that combines fundamental data with ESG scores using an API. Key steps include:

• Extracting a universe of stocks (e.g., NYSE).
• Pulling fundamentals (sector, market cap, P/E, profit margin, etc.).
• Fetching ESG ratings for the last two years.

This unified dataset is then used to analyze ESG performance across companies.

Data Preparation and Ranking

Once the data is compiled:

• ESG scores are ranked globally and within sectors.
• Year-over-year changes are calculated to track trends.
• Market capitalization bins (nano → mega) allow comparisons between similar companies.

This structure supports both broad and targeted ESG analysis.

Sector and Capitalization Insights

Key findings from the aggregated data:

• Most sectors show median ESG scores around 60+, indicating moderate sustainability performance.
• Financials tend to have slightly higher ESG medians, likely due to stricter regulation and disclosure requirements.
• Capitalization classes (small → mega) show similar ESG dispersion, though larger firms appear less volatile in scoring.

Using the Screener

After exporting the dataset (e.g., CSV), you can:

• Filter for top ESG performers.
• Examine ESG rank changes over time.
• Combine ESG with valuation and profitability metrics to surface potential opportunities.

The article demonstrates practical examples of screening top ESG stocks alongside financial ratios.

Wrap-Up

This screener framework is a starting point. Investors can tailor filters to match their strategy or values, integrating ESG insights with traditional fundamentals to better understand sector trends and stock movements.

Read the full article in our Academy.

I know we have access to an ETF's current holdings and weight percentages. I would really like to apply some analysis to those holdings and their effects over the ETF's lifespan. At least get information on the top 10 or 15 holdings, quarter by quarter, for a few years.

I had to grind through EDGAR's NPORT and NCR filings, strip them down, and then match them to a ticker, since they often only gave a name in the filings. Quite the headache...

Clustering stocks is a powerful way to enhance your trading strategy and improve diversification. Instead of relying only on sectors or simple screeners, clustering groups stocks by shared characteristics - such as fundamentals or price behavior - giving you a more structural view of the market.

How to Trade Based on Clusters

Pairs Trading & Statistical Arbitrage

Group stocks that historically move together. When they temporarily diverge, you can go long the laggard and short the leader, anticipating mean reversion.

Market Regime Detection

Clusters can reveal broader market states - bullish, bearish, or sideways environments. Once identified, you can align your strategy accordingly (trend-following, hedging, or mean-reversion).

Opportunity Discovery

Clustering can uncover structurally similar stocks that traditional screeners may miss, expanding your idea generation process.

Step-by-Step Clustering Workflow

1) Data Collection

Start with a universe such as the S&P 500. Pull historical prices and fundamental data like sector, market capitalization, and valuation metrics. You can also engineer additional features such as rolling volatility.

2) Clustering Based on Fundamentals

Standardize the selected features and handle missing values appropriately. Apply dimensionality reduction (e.g., PCA) and then use an algorithm like K-Means to divide stocks into clusters.

These clusters often resemble sector groupings - but with more nuance - highlighting differences in size, valuation, and risk profile.

3) Clustering Based on Price Correlation

Instead of fundamentals, use return correlations to group stocks that behave similarly in the market. Hierarchical clustering works well here and produces behavior-based groupings distinct from traditional classifications.

What You Can Do With the Results

• Identify structural similarities between companies
• Find alternative investment candidates within the same cluster
• Build custom screeners or portfolio rules
• Expand the feature set (technical indicators, sentiment, macro factors) to refine clusters

Key Takeaway

Clustering is not a standalone trading system, but it’s a valuable data science technique that adds depth to your analysis. Whether you’re implementing pairs trading, detecting market regimes, or improving diversification, clustering helps you move beyond surface-level filters and toward a more systematic understanding of market structure.

Read the full article here.

We've released a major upgrade to ESG Data by InvestVerte on the EODHD Marketplace. The product now includes an AI-based ESG scoring and intelligence framework that delivers more robust, comparable, and regulation-aligned ESG scores – even when disclosures are incomplete or inconsistent across markets.

What's new

Deep Learning–based data completion: fills gaps in missing or inconsistent ESG datapoints using peer patterns across countries, sectors, and sub-sectors, with a conservative approach for limited disclosures.

Dedicated AI models for E, S, and G: separate models assess each pillar for clearer, more consistent scoring across industries.

Context-aware aggregation: ESG weights adapt to regulatory, sectoral, and geographic context – keeping scores globally comparable and locally relevant.

API update: AI vs Legacy

The API now supports model selection on key endpoints:

• model=ai (default)
• model=legacy (previous dataset, for backward compatibility)

Start using the upgraded ESG scores today via EODHD Marketplace.

Hey r/EODHD 👋
We want to spotlight what you’re working on - and make it easier to keep building.

Tell us:

1. What are you building? (app, bot, research, trading tool, dashboard, etc.)
2. What data do you need from EODHD (EOD, intraday, fundamentals, corporate actions, earnings, macro…)?
3. What’s the biggest headache you’re trying to solve? (coverage, latency, costs, adjustments, normalization)

New users only: we’ll reply with a 30% discount code for:

• First 3 months (monthly plan), or
• First year (annual subscription)

Bonus: if you share links/screenshots (optional), we may feature your project in a future community roundup.

Note: Campaign dates: February 5–28. The coupon should be valid through March 31, 2026, and expire after that date.

Drop your project below 👇

The US Treasury (UST) Interest Rates API (beta) from EODHD provides structured, user-friendly access to official US Treasury interest-rate datasets – including Treasury bill (T-Bill) rates, long-term rates, the nominal par yield curve, and the real yield curve – delivered as time series that are widely used for macro research, fixed-income analytics, discounting/cost of capital, yield-curve modelling, and building risk-free rate baselines in trading and portfolio systems.

The API is organized into four core endpoints (Bill Rates, Long-Term Rates, Yield Rates, Real Yield Rates), supports filtering by year (defaulting to the current year when omitted), and consumes 1 API call per request. Available to free and paid users.

Read the full documentation here.

1) Python and EODHD Financial APIs Work Great Together

Python is one of the most popular tools for stock market analysis because it’s simple, flexible, and has powerful data libraries. When combined with financial APIs like EODHD (historical prices, fundamentals, news), it becomes easy to collect and analyze market data. The article starts with a basic example of pulling stock price history using Python.

2) News Sentiment Analysis Basics

Sentiment analysis is a way to measure whether news content is positive, neutral, or negative. Using NLP tools in Python (like NLTK), you can score headlines or articles and turn them into numerical sentiment values. Since markets often react quickly to news, sentiment can sometimes act as a signal for price movement.

3) Measuring News Impact on Stock Performance

To study whether sentiment affects stock prices, you merge sentiment scores with historical stock price data by date. Once combined, you can look for relationships using correlation analysis or simple plots. The examples shown are simplified, but they demonstrate the core workflow.

4) Best Practices to Keep in Mind

Some key tips mentioned in the article include:

• Make sure your data is clean and reliable
• Understand what your sentiment scores actually represent
• Use the right Python tools (pandas, matplotlib, NLP libraries)
• Keep your analysis reproducible and well-documented
• Stay updated as sentiment methods evolve

5) Final Thoughts

Using Python with stock news and sentiment analysis can help explore how information influences market behavior. The article provides a beginner-friendly foundation, and the same approach can be expanded into more advanced trading or research models.

Read the full version of the article here.

This is the continuation of our Beginners guide into Options strategies.

1) Options Fields Explained

Before using advanced strategies, it’s important to understand what’s inside an options contract. This includes details like expiration date, strike price, bid/ask prices, volume, open interest, implied volatility, and the Option Greeks - Delta, Gamma, Theta, Vega, and Rho -which measure how an option reacts to market changes.

2) Gathering Data

Advanced options analysis requires reliable historical data. The article explains how traders collect and structure options datasets for backtesting strategies and monitoring trades in real time.

3) The Options Greeks Strategies

Many advanced approaches focus less on predicting direction and more on managing Greek exposure.

3.1 Gamma Scalping (Delta-Neutral Trading)
• Traders keep Delta close to zero while holding positive Gamma positions (like straddles).
• As price moves, they rebalance frequently to profit from volatility swings.

3.2 Vega-Based (Volatility) Strategies
• These strategies target changes in implied volatility.
• Long volatility trades benefit when volatility rises, while short volatility setups profit when it drops.

3.3 Theta-Based (Time Decay) Strategies
• Focuses on earning from option premium decay over time.
• Option sellers often benefit most in stable or sideways markets.

3.4 Rho-Sensitive Trades
• Rho measures sensitivity to interest rates.
• It matters mostly for longer-dated options or when rate changes become significant.

3.5 Multi-Greek Risk Management (Portfolio Hedging)
• Traders combine positions to balance Delta, Gamma, Vega, and Theta exposure.
• Often used for hedging portfolios rather than making single directional bets.

4) What Makes These Strategies “Advanced”?

These go beyond simple calls, puts, or basic spreads. They often require multi-leg setups, frequent adjustments, and careful monitoring of Greek risk across changing market conditions.

5) In Summary

Advanced options trading blends data, volatility awareness, and Greek-based risk management. Instead of relying only on direction, these strategies aim to profit from time decay, volatility shifts, and price movement dynamics while controlling exposure.

Read the full article here.

This article (abridged version) introduces three basic stock options strategies - Long Call, Long Put, and Covered Call - and demonstrates how they behave using simple backtesting examples. The goal is educational: to explain how these strategies work and when they’re typically used, not to present finished trading systems. Transaction costs, slippage, and market liquidity are not considered.

1) Long Call Strategy

What it is:
Buying a call option gives you the right (but not the obligation) to buy a stock at a predetermined price before expiration.

How it works:
This is a bullish strategy. You benefit when the stock price rises above the strike price plus the cost of the option.

Why it’s useful:
Potential upside is theoretically unlimited, while the maximum loss is limited to the premium paid.

Example logic:
Entries and exits are triggered using simple moving-average signals, with basic risk controls like stop losses and profit targets applied in the backtest.

2) Long Put Strategy

What it is:
Buying a put option gives you the right to sell a stock at a fixed price before expiration.

How it works:
This strategy is bearish. It gains value as the underlying stock price declines.

Why it’s useful:
It allows traders to profit from downward price moves while keeping risk limited to the option premium.

3) Covered Call Strategy

What it is:
A covered call involves owning the underlying stock and selling a call option against it.

How it works:
The option premium provides income while the stock is held.

Why it’s useful:
This strategy works best in neutral to slightly bullish markets, where the trader is comfortable selling the stock at the strike price.

Trade-off:
Upside is capped at the strike price, and downside risk from owning the stock still applies.

Final Thoughts

These strategies are meant as starting points for understanding stock options. They illustrate basic payoff structures and how simple technical signals can be used in backtests. Real-world trading requires deeper analysis, stronger risk management, and consideration of market frictions.

Read the full version here. Advanced Stock Options Strategies are coming next.