DEV Community: Kevin Meneses González

I Tested 5 Developer-Focused Video Editing Tools — Here's What I Learned

Kevin Meneses González — Wed, 03 Jun 2026 12:15:21 +0000

Most "best video editing software" lists are written by people who have never opened a terminal.

They rank tools by how nice the timeline looks and how many transitions ship in the free plan. Useful if you're editing a wedding montage. Useless if you're a developer who needs to generate 5,000 videos from a database while you sleep.

Because for developers, the question isn't which editor has the smoothest drag-and-drop.

It's a completely different question.

If you're:

building a SaaS that exports video,
automating social content from data,
or generating personalized clips at scale,

You don't need an editor. You need a render engine you can call from code.

The real question developers are asking in 2026

The shift happening right now is simple to state: video is becoming code.

Instead of dragging clips on a timeline, you describe a video the way you describe a web page — components, data, props — and a machine renders the frames. No human in the loop. No "export" button clicked by a person at 2 a.m.

That changes what "best" even means. Flexibility, scalability, and how cleanly the tool fits into an automated pipeline matter far more than the prettiness of the UI.

So I spent time with the five tools developers actually reach for, and graded each on three axes: flexibility (how much control you really get), ease (time-to-first-render), and scalability (what happens when you need thousands of videos, not three).

Here's what held up.

1. Remotion — the reference standard for video in React

Remotion lets you build real MP4 videos using React components. Created by Jonny Burger and open-sourced in 2021, it has quietly become the default answer when a developer asks "how do I make video with code."

Every frame is a React component. Every animation is a function of the current frame. Because the whole video is code, you version it in Git, review it in pull requests, and feed it dynamic props — which is exactly why it pairs so well with LLM-generated scripts and data.

Pros

Full React: hooks, props, components — no proprietary DSL to learn.
Total control over animation, down to the frame.
Scales hard via Lambda rendering — thousands of videos from one codebase.
Open-source core with a large, active community.

Cons

Steep curve if you don't already live in React.
Render pipelines (especially serverless) take real setup effort.
No HDR yet, a limitation inherited from headless Chrome rendering.

Best for: SaaS products, animated dashboards, fintech data videos, and any content automation where you want code-level control.

Pricing is fair for its target: free for individuals and small teams, a company license from around $100/month, and enterprise terms above that.

2. HyperFrames — video as HTML, built for AI agents

This is the tool I had to re-learn while researching, because the early write-ups got it wrong.

HyperFrames is HeyGen's open-source (Apache 2.0) framework that turns plain HTML, CSS and JavaScript into frame-accurate MP4. No React. No component system. No build step. You write something close to a normal web page — using data-start, data-duration and data-track-index attributes for the timeline — and a headless browser captures it frame by frame.

The bet is interesting. Remotion wagered on React as the future of programmatic video. HyperFrames is wagering on raw HTML, precisely because today's AI models write clean HTML far more reliably than they write complex React animation architectures.

It ships with skill packs for Claude Code and Codex, so an agent can scaffold, write and render a full video from a single prompt. It supports GSAP, Lottie, Three.js and D3, and renders locally with no API key required.

Pros

Lower barrier than Remotion — plain HTML, no framework lock-in.
Open source, runs locally, no account or cloud dependency.
Purpose-built for agentic workflows (Claude Code, Codex).
50+ pre-built blocks installable via npx hyperframes add.

Cons

Young: launched in 2026, so the ecosystem is still thin.
Best suited to simpler motion — text, diagrams, data overlays.
Fewer battle-tested production references than Remotion.

Best for: AI-agent pipelines, automated shorts, and data videos where an agent writes the code and renders the output end to end.

3. Creatomate — JSON in, video out

Creatomate (Create + Automate) is the tool of choice when you want templated video generation through a REST API without managing rendering infrastructure.

You design a template once — in a visual editor or as JSON — then fire data at it and get back a rendered video, GIF, or image. It's a favorite in the no-code automation crowd because it drops cleanly into n8n, Make and Zapier.

Pros

Genuinely robust, well-documented API.
Generate video straight from JSON — ideal for data-driven content.
First-class fit for n8n and Make automations.
Visual editor lets non-developers maintain templates.

Cons

Credit-based pricing climbs fast at volume.
Text-to-speech (ElevenLabs/Azure) is billed on top of render credits.
Less low-level control than a code-native tool like Remotion.

Best for: agencies, marketing automation, and personalized video at moderate volume.

Plans start around $41–54/month for roughly 150–200 minutes at 720p, scaling up from there.

4. Shotstack — the AWS of video

If Creatomate is the friendly templating layer, Shotstack is the industrial-grade rendering backend. Define a composition as JSON, send it to the API, and Shotstack renders it at scale — thousands of videos in minutes — and serves them from its own CDN.

It's been around since well before the current hype cycle, which shows: the API is mature, the behavior is predictable, and there's a free sandbox that doesn't ask for a credit card. It's a rendering engine, not a content-intelligence platform — you bring your own AI for voice or subtitles.

Pros

Extremely mature, well-documented API with SDKs for Node.js, PHP and more.
Predictable, deterministic rendering — what you send is what you get.
Built to scale; white-label editor SDK you can embed in your own product.
Free sandbox for testing before you commit.

Cons

More technical to set up than a visual-first tool.
Resolution-based pricing gets expensive at 1080p+.
No native AI features — you wire in voice and captions yourself.

Best for: SaaS platforms and any application that needs to render large volumes of video reliably.

Pricing runs pay-as-you-go at roughly $0.30/min, or plans from about $39/month at lower per-minute rates.

5. React Video Editor (RVE) — a timeline UI you don't have to build

Building a video editor from scratch is brutal: timelines, drag-and-drop, multi-track state, media handling. RVE exists so you don't have to.

It's a React/Next.js editor that uses Remotion underneath for rendering. There's a free, open-source baseline to learn the building blocks, plus commercial Pro and SDK options for teams that want a production-ready editor without burning a month of engineering on it.

Pros

Open source baseline — inspect and learn the architecture for free.
Pure React/Next.js; customizable to your product.
Saves weeks of work if you need an in-app editor.

Cons

Younger project with a smaller community.
Documentation is still catching up.
Built on Remotion, so a Remotion license may apply depending on use.

Best for: React teams shipping an embedded video editor, internal tools, or creative SaaS features.

What "video as code" actually looks like

Theory is cheap. Here's the same idea — a simple fintech price card — expressed in the three paradigms these tools represent.

Remotion (React):

import { AbsoluteFill, useCurrentFrame, interpolate } from "remotion";

export const PriceCard = ({ ticker, price }) => {
  const frame = useCurrentFrame();
  const opacity = interpolate(frame, [0, 20], [0, 1], {
    extrapolateRight: "clamp",
  });

  return (
    <AbsoluteFill style={{ backgroundColor: "#0A1628", opacity }}>
      <h1 style={{ color: "#FFFFFF" }}>{ticker}</h1>
      <h2 style={{ color: "#3B82F6" }}>{price}</h2>
    </AbsoluteFill>
  );
};

HyperFrames (HTML):

<div data-track-index="0" data-start="0" data-duration="3">
  <h1 style="color:#FFFFFF">AAPL</h1>
  <h2 style="color:#3B82F6">$214.30</h2>
</div>
<!-- render: npx hyperframes render scene.html -->

Creatomate / Shotstack (JSON via API, called from Python):

import requests

resp = requests.post(
    "https://api.creatomate.com/v1/renders",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "template_id": "your-template-id",
        "modifications": {"ticker": "AAPL", "price": "$214.30"},
    },
)

print(resp.json()[0]["url"])

Three philosophies. React owns the components. HTML optimizes for what AI writes well. JSON-over-API hides the rendering entirely.

From here you can build:

daily auto-generated market recap videos,
personalized onboarding clips per user,
thousands of localized product shorts from one template.

The ranking, at a glance

Tool	Flexibility	Ease	Scalability
Remotion	10/10	6/10	10/10
HyperFrames	8/10	8/10	8/10
Creatomate	7/10	9/10	9/10
Shotstack	8/10	7/10	10/10
RVE	8/10	6/10	8/10

Read the scores as trade-offs, not a leaderboard. Remotion wins on control and loses on ramp-up. Creatomate wins on speed-to-first-video and gives up low-level control. Nobody wins all three.

Honorable mentions — the AI generation layer

These don't compete with the tools above. They sit next to them, generating the raw footage you then assemble:

Runway — generative AI video.
Descript — edit video by editing the transcript.
CapCut — fast, creator-focused editing.
VEED — marketing and subtitle-heavy workflows.
Luma AI — text-to-video generation.

The pattern worth noticing: the code-first tools are the assembly layer, and these are the content layer. The strongest pipelines in 2026 chain both — Runway or Luma generates a clip, Remotion or HyperFrames composes it with data and renders the final cut.

How to actually choose

Forget the feature lists for a second and answer three questions.

Do you live in React? Then Remotion, and RVE if you need a ready-made editor UI on top of it.

Are AI agents writing your video code? HyperFrames was built for exactly that.

Do you just want a video back from an API and never think about rendering? Creatomate for templated content with a visual editor, Shotstack when you need it to scale like infrastructure.

There's no universal winner. There's only the tool that disappears into your pipeline.

Key takeaways

For developers, "best video tool" means best render engine, not best timeline.
Remotion (React) and HyperFrames (HTML) split the code-first world by what they optimize for: human control vs. AI ergonomics.
API-first tools (Creatomate, Shotstack) trade control for not having to run rendering infrastructure at all.

FAQs

Can I generate videos without a video editor?
Yes. Tools like Remotion, HyperFrames, Creatomate and Shotstack let you produce MP4 video entirely from code or an API — no timeline, no manual editing.

What's the difference between Remotion and HyperFrames?
Remotion renders video from React components and is the more mature choice for product teams. HyperFrames renders video from plain HTML and is optimized for AI agents writing the code. Both render through a headless browser.

Which tool is best for generating thousands of videos?
Shotstack and Remotion (on Lambda) are built for high-volume rendering. Creatomate also scales well but its credit pricing climbs at large volumes.

Do I need to know how to code to use these?
For Remotion, HyperFrames and RVE, yes. Creatomate and Shotstack can be driven through no-code tools like n8n and Make, though the API unlocks the most power.

If you're a software or API company looking to explain a developer product through high-quality educational content — real code, not marketing fluff — feel free to connect with me on LinkedIn.

Video stopped being something you edit and started being something you generate. The developers who internalize that won't be the ones with the best timeline skills.

They'll be the ones who treat video like every other build artifact: code, data, and a render step.

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

Top 5 Data Visualizations for Algorithmic Trading (With Python Code)

Kevin Meneses González — Sun, 31 May 2026 09:30:00 +0000

Most algo traders write signals. Almost none visualize them correctly.

You can have a backtest with 300 trades, a Sharpe ratio of 1.4, and still have no idea whether your system is working — or getting lucky. The numbers don't show you where the strategy breathes. Charts do.

If you're:

building a quantitative trading system,
running backtests and not knowing how to interpret the results,
or trying to communicate your edge to investors or teammates,

This matters.

The Real Problem Isn't the Data. It's What You Can't See.

A developer I know spent three months building a mean-reversion strategy. Solid execution, clean Python, well-documented. He ran the backtest. The results looked good.

What he couldn't see:

Three consecutive months of drawdown that would have ended any fund
80% of returns coming from a single volatile week in March
His volume filters triggering on micro-cap stocks with no real liquidity

The strategy wasn't broken. His visualization layer was.

Visualization is not decoration. It is part of the analysis.

Once I understood that, I stopped treating charts as outputs and started treating them as inputs to the research process.

Why EODHD Is the Right Data Layer for This

Before the code, a word on data quality.

Every chart in this article is powered by EODHD APIs. Not because it's the only option — but because it's the one I consistently use for production-grade algo trading research.

What you get:

End-of-day prices for 70,000+ tickers across 60+ exchanges
Intraday data down to 1-minute resolution
Fundamental data, economic indicators, and options chains — all through a clean REST API
Python-friendly JSON responses with predictable schema

The free tier covers most of what you need to start. Paid plans scale with your data volume.

👉Get started with EODHD here

Data Architecture: From API to Chart

Before we dive into charts, it's worth understanding how data flows from the EODHD API into your visualization layer.

The pipeline has four stages: fetch raw OHLCV data from the REST API, normalize it into a pandas DataFrame, compute derived metrics (signals, indicators, returns), and finally render the visualization.

The 5 Visualizations

1. Candlestick Chart with Moving Averages — Trend Structure at a Glance

What it shows: Price action as OHLC candles, layered with a fast (20-period) and slow (50-period) exponential moving average.

Why it matters for algo trading:
The candlestick + EMA combination is the foundation of every trend-following system. Before deploying any directional strategy, you need to see whether the asset is trending, consolidating, or reversing. Moving average crossovers are a common signal generation mechanism — and seeing them plotted against real price action reveals how late, noisy, or clean those signals actually are.

A crossover that looks clean in a table of dates looks completely different when you see it happening during a sideways chop period. The chart reveals what the numbers hide.

import requests
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots

API_KEY = "your_api_key"
TICKER = "AAPL.US"

def fetch_ohlcv(ticker, api_key, period="d", from_date="2024-01-01"):
    url = f"https://eodhd.com/api/eod/{ticker}"
    params = {
        "api_token": api_key,
        "fmt": "json",
        "period": period,
        "from": from_date
    }
    r = requests.get(url, params=params)
    df = pd.DataFrame(r.json())
    df["date"] = pd.to_datetime(df["date"])
    df.set_index("date", inplace=True)
    return df

df = fetch_ohlcv(TICKER, API_KEY)

# Compute EMAs
df["ema_20"] = df["close"].ewm(span=20).mean()
df["ema_50"] = df["close"].ewm(span=50).mean()

fig = go.Figure()

fig.add_trace(go.Candlestick(
    x=df.index,
    open=df["open"], high=df["high"],
    low=df["low"], close=df["close"],
    name="OHLC"
))

fig.add_trace(go.Scatter(x=df.index, y=df["ema_20"],
    line=dict(color="orange", width=1.5), name="EMA 20"))

fig.add_trace(go.Scatter(x=df.index, y=df["ema_50"],
    line=dict(color="blue", width=1.5), name="EMA 50"))

fig.update_layout(
    title=f"{TICKER} — Candlestick with EMA 20/50",
    xaxis_rangeslider_visible=False,
    template="plotly_dark",
    height=500
)
fig.show()

From here you can build:

EMA crossover signal detection with entry/exit markers on the chart
Multi-timeframe confluence overlays (daily trend + intraday entry)
Automated alerts when price closes above/below a moving average

2. Volume Profile — Where the Market Actually Traded

What it shows: A horizontal histogram of traded volume at each price level over a defined period.

Why it matters for algo trading:
Price tells you when moves happened. Volume profile tells you where the market spent its time. High-volume nodes are price magnets — levels where large participants built positions. Low-volume nodes are inefficiencies — levels the market crossed through quickly and is likely to revisit.

If your strategy is entering near a high-volume node, you have natural support or resistance. If it's entering in a low-volume area, you're in air. No other visualization shows this as clearly.

import numpy as np
import matplotlib.pyplot as plt

# Fetch data (reuse fetch_ohlcv from above)
df = fetch_ohlcv(TICKER, API_KEY)

# Build volume profile
price_range = np.linspace(df["low"].min(), df["high"].max(), 50)
vol_profile = np.zeros(len(price_range) - 1)

for _, row in df.iterrows():
    for i in range(len(price_range) - 1):
        if price_range[i] <= row["close"] < price_range[i+1]:
            vol_profile[i] += row["volume"]
            break

bin_centers = (price_range[:-1] + price_range[1:]) / 2

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 7),
    gridspec_kw={"width_ratios": [3, 1]}, facecolor="#0d1117")

# Left: price chart
ax1.plot(df.index, df["close"], color="#58a6ff", linewidth=1.2)
ax1.set_facecolor("#0d1117")
ax1.set_title(f"{TICKER} — Close Price", color="white")
ax1.tick_params(colors="gray")

# Right: volume profile (horizontal bars)
ax2.barh(bin_centers, vol_profile,
    height=(price_range[1] - price_range[0]) * 0.85,
    color="#388bfd", alpha=0.75)
ax2.set_facecolor("#0d1117")
ax2.set_title("Volume Profile", color="white")
ax2.tick_params(colors="gray")
ax2.yaxis.tick_right()

plt.tight_layout()
plt.show()

From here you can build:

Point of Control (POC) detection — the single price level with the highest volume
Value Area calculation (70% of volume) for mean-reversion entries
Multi-session profiles to compare volume distribution across market regimes

3. Equity Curve with Drawdown Panel — Backtest Health in One View

What it shows: The cumulative return of a strategy over time (top panel) + the drawdown at every point (bottom panel).

Why it matters for algo trading:
A positive total return tells you almost nothing. What matters is the path to that return. A strategy that returns +40% over 3 years with a -35% drawdown in the middle is not the same as one that returns +40% with a max drawdown of -8%. One you can trade. The other will cause you to abandon the system at exactly the wrong moment.

The drawdown panel is the psychological test. If you can't stomach what you see there, you can't run that strategy live.

import pandas as pd
import numpy as np
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# --- Simulate a simple MA crossover strategy ---
df = fetch_ohlcv(TICKER, API_KEY)
df["ema_10"] = df["close"].ewm(span=10).mean()
df["ema_30"] = df["close"].ewm(span=30).mean()

df["signal"] = np.where(df["ema_10"] > df["ema_30"], 1, -1)
df["daily_return"] = df["close"].pct_change()
df["strategy_return"] = df["signal"].shift(1) * df["daily_return"]

df["equity_curve"] = (1 + df["strategy_return"]).cumprod()
df["running_max"] = df["equity_curve"].cummax()
df["drawdown"] = (df["equity_curve"] / df["running_max"]) - 1

# --- Plot ---
fig = make_subplots(rows=2, cols=1,
    shared_xaxes=True,
    row_heights=[0.65, 0.35],
    vertical_spacing=0.05)

fig.add_trace(go.Scatter(
    x=df.index, y=df["equity_curve"],
    fill="tozeroy", line=dict(color="#58a6ff"),
    name="Equity Curve"), row=1, col=1)

fig.add_trace(go.Scatter(
    x=df.index, y=df["drawdown"] * 100,
    fill="tozeroy", line=dict(color="#f85149"),
    fillcolor="rgba(248,81,73,0.2)",
    name="Drawdown (%)"), row=2, col=1)

fig.update_layout(
    template="plotly_dark",
    title="MA Crossover Strategy — Equity Curve & Drawdown",
    height=550,
    showlegend=True
)
fig.show()

Key metrics to annotate on this chart:

Max Drawdown — the deepest valley from peak
Recovery Time — how long it took to reach a new equity high
Calmar Ratio — annualized return / max drawdown (one number that summarizes risk-adjusted performance)

4. Correlation Heatmap — Portfolio Risk Hidden in Plain Sight

What it shows: A matrix of pairwise return correlations between multiple assets or strategies.

Why it matters for algo trading:
Diversification only works if your assets are actually uncorrelated. Most traders think they're diversified because they hold different tickers. They're not — they're holding different tickers that all fall together in a risk-off event.

A correlation heatmap shows you the real structure of your portfolio. Dark red cells = concentrated risk. Near-zero cells = genuine diversification. This is the chart you show before adding a new strategy or asset to your book.

import seaborn as sns
import matplotlib.pyplot as plt

TICKERS = ["AAPL.US", "MSFT.US", "GOOGL.US", "AMZN.US", "JPM.US", "GLD.US"]

price_data = {}
for ticker in TICKERS:
    df_t = fetch_ohlcv(ticker, API_KEY)
    price_data[ticker.split(".")[0]] = df_t["close"]

prices = pd.DataFrame(price_data).dropna()
returns = prices.pct_change().dropna()
corr_matrix = returns.corr()

fig, ax = plt.subplots(figsize=(9, 7), facecolor="#0d1117")
sns.heatmap(
    corr_matrix,
    annot=True, fmt=".2f",
    cmap="RdYlGn",
    center=0, vmin=-1, vmax=1,
    square=True, linewidths=0.5,
    cbar_kws={"shrink": 0.8},
    ax=ax
)
ax.set_title("Asset Return Correlation Matrix", color="white", pad=15)
ax.tick_params(colors="white")
plt.tight_layout()
plt.show()

From here you can build:

Correlation monitoring over rolling windows to detect regime shifts
Portfolio optimizer that constrains position sizing based on pairwise correlation
Alert when two previously uncorrelated assets start moving together

5. RSI + Bollinger Bands Overlay — Momentum Meets Volatility

What it shows: RSI (Relative Strength Index) as a momentum oscillator below the price chart, with Bollinger Bands (20-period SMA ± 2σ) overlaid on price.

Why it matters for algo trading:
Neither RSI nor Bollinger Bands alone is particularly reliable. Together, they become a high-conviction signal framework:

Price touching the lower Bollinger Band while RSI is below 30 = potential oversold reversal entry
Price breaking above the upper band while RSI is above 70 = potential momentum continuation or overbought exit

This is the kind of multi-indicator confluence that most systematic strategies are built around. Seeing it visually — before you code the logic — prevents you from building signal combinations that never actually coincide in real market data.

import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots

df = fetch_ohlcv(TICKER, API_KEY)

# Bollinger Bands
df["bb_mid"] = df["close"].rolling(20).mean()
df["bb_std"] = df["close"].rolling(20).std()
df["bb_upper"] = df["bb_mid"] + 2 * df["bb_std"]
df["bb_lower"] = df["bb_mid"] - 2 * df["bb_std"]

# RSI
delta = df["close"].diff()
gain = delta.clip(lower=0).rolling(14).mean()
loss = (-delta.clip(upper=0)).rolling(14).mean()
rs = gain / loss
df["rsi"] = 100 - (100 / (1 + rs))

fig = make_subplots(rows=2, cols=1,
    shared_xaxes=True,
    row_heights=[0.65, 0.35],
    vertical_spacing=0.04)

# --- Price + Bollinger Bands ---
fig.add_trace(go.Scatter(x=df.index, y=df["close"],
    line=dict(color="#58a6ff", width=1.5), name="Close"), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df["bb_upper"],
    line=dict(color="rgba(255,165,0,0.5)", dash="dot"), name="BB Upper"), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df["bb_lower"],
    fill="tonexty", fillcolor="rgba(255,165,0,0.05)",
    line=dict(color="rgba(255,165,0,0.5)", dash="dot"), name="BB Lower"), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df["bb_mid"],
    line=dict(color="gray", width=0.8, dash="dash"), name="BB Mid"), row=1, col=1)

# --- RSI ---
fig.add_trace(go.Scatter(x=df.index, y=df["rsi"],
    line=dict(color="#c9d1d9"), name="RSI"), row=2, col=1)
fig.add_hline(y=70, line_dash="dot", line_color="red", opacity=0.5, row=2, col=1)
fig.add_hline(y=30, line_dash="dot", line_color="green", opacity=0.5, row=2, col=1)

fig.update_layout(
    template="plotly_dark",
    title=f"{TICKER} — Bollinger Bands + RSI",
    height=580
)
fig.show()

From here you can build:

Signal detection when both conditions are met simultaneously (dual-condition scanner)
Backtesting the mean-reversion rule: buy when price < BB lower AND RSI < 30
Squeeze detection using Bollinger Band width as a volatility compression indicator

FAQs

❓ Do I need a paid EODHD plan to run these examples?
✅ The free tier of EODHD includes end-of-day data for most major exchanges, which is enough to run all five visualizations in this article. You only need a paid plan if you require intraday data (1-minute or 5-minute candles), real-time feeds, or access to premium data categories like options chains.

❓ Which Python charting library is best for algo trading — Plotly or Matplotlib?
✅ Use Plotly for any visualization that benefits from interactivity: equity curves you want to zoom, heatmaps you want to hover over, multi-panel dashboards. Use Matplotlib for static outputs, publication-quality figures, or when you're exporting to PDF reports. Both are used in this article because each has a domain where it genuinely wins.

❓ Can I use these visualizations in a live trading dashboard, not just backtesting?
✅ Yes. The EODHD API supports intraday data with minute-level resolution on paid plans. Swap the period="d" parameter in fetch_ohlcv to period="m" for minute data. The chart code stays identical — only the data granularity changes. For a fully automated live dashboard, combine these functions with a scheduler like APScheduler or a workflow tool like n8n.

❓ What does the Volume Profile actually measure vs. standard volume bars?
✅ Standard volume bars (shown at the bottom of most charts) show volume over time — how much was traded in each candle. Volume Profile shows volume at price — how much was traded at each price level across a defined period. The second view is far more useful for identifying support/resistance zones and understanding where institutional positions were built.

❓ Is algorithmic trading data visualization useful if I'm not running fully automated strategies?
✅ Absolutely. Even manual or semi-systematic traders benefit from these charts. The equity curve and drawdown panel are essential for anyone journaling their performance. The correlation heatmap is useful for any multi-asset portfolio. Visualization is not about automation — it's about reducing blind spots.

Final Thoughts

Markets don't reward complexity. They reward clarity.

The five charts in this article won't give you an edge by themselves. But they will show you where your edge actually exists — and, more importantly, where it doesn't.

Start with the candlestick overlay to understand trend structure. Add the drawdown panel to understand psychological survivability. Use the correlation matrix before you add any new position to your book.

The rest follows.

Start Building With Better Data

Every chart in this article runs on EODHD APIs. If you're serious about algorithmic trading research, the data layer is not the place to cut corners.

👉 Get started with EODHD here

What you get access to:

End-of-day and intraday data for 70,000+ tickers across 60+ exchanges
Fundamentals, economic indicators, and options chains — all through one clean REST API
A free tier that covers everything in this article, no credit card required

Work With Me

I produce technical content for fintech and developer tools companies — tutorials, API walkthroughs, data-driven articles that actually get read.

If you're building something in the trading, data, or developer tools space and need content that explains your product without sounding like a press release:

👉 Connect on LinkedIn or reach out directly at kevinmenesesgonzalez@gmail.com

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

Interactive Brokers API vs EODHD: Which One Actually Saves You Time?

Kevin Meneses González — Fri, 29 May 2026 09:00:35 +0000

Most developers assume that using a broker's API gives you a direct advantage when building financial tools.

The assumption: if your broker has an API, you might as well use it for data.

The reality: trading APIs and data APIs solve fundamentally different problems — and confusing the two will cost you weeks of unnecessary setup, a running desktop app, and a live brokerage account before you write a single line of analysis code.

If you're:

building a stock screener or portfolio analyzer,
automating financial research with Python,
or integrating market data into an AI agent,

this comparison matters.

What Interactive Brokers API Actually Is (And What It Isn't)

Interactive Brokers is a serious brokerage. Their API — built around TWS (Trader Workstation) and the ib_insync Python library — is designed for one primary use case: executing trades programmatically from a live account.

It also exposes market data. Historical prices, fundamentals, options chains. The data is there.

But the access model is the problem.

To pull a single historical price series using the IBKR API, you need:

An active Interactive Brokers brokerage account (funded or paper)
TWS or IB Gateway running locally on your machine
A socket connection open on port 7497 or 4002
Pacing limits: IBKR throttles historical data requests to ~60 per 10 minutes

That's the setup before you write any analysis logic.

Here's the simplest working example using ib_insync:

from ib_insync import IB, Stock, util

# Requires TWS or IB Gateway running on localhost
ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1)

contract = Stock('AAPL', 'SMART', 'USD')
bars = ib.reqHistoricalData(
    contract,
    endDateTime='',
    durationStr='30 D',
    barSizeSetting='1 day',
    whatToShow='CLOSE',
    useRTH=True
)

df = util.df(bars)
print(df[['date', 'close']].tail(10))

ib.disconnect()

Output (example):

         date   close
20  2026-04-28  211.23
21  2026-04-29  213.45
...

This works. But notice what it requires: a running desktop application, an authenticated session, and a live connection. If TWS isn't open, your script fails silently. If you're running this on a server, you need IB Gateway configured and maintained.

Pros

Deep integration if you're already trading with IBKR
Access to live quotes, options data, and order execution in one place
Well-maintained Python library (ib_insync)

Cons

Requires a funded or paper brokerage account
TWS or IB Gateway must be running — not suitable for lightweight server deployments
Historical data pacing restrictions limit bulk research workloads
Not designed for broad market screening across thousands of symbols

Best for: algo traders who are already IBKR clients and need to combine execution with data in a single workflow.

What EODHD Is (And Why the Model Is Different)

EODHD — End of Day Historical Data — is a pure financial data API. No brokerage account. No desktop software. No socket connections.

One API key. REST calls. JSON responses. That's it.

The architecture is what makes it developer-friendly by design: you send an HTTP request to an endpoint, you get structured data back. The same way you'd call any modern API — from a Jupyter notebook, a FastAPI backend, a cron job on a cloud server, or an AI agent.

Here's the equivalent historical price request in EODHD:

import requests
import pandas as pd

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

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

response = requests.get(url, params=params)
df = pd.DataFrame(response.json())
print(df[['date', 'close']].tail(10))

Output:

         date    close
20  2026-04-28   211.23
21  2026-04-29   213.45
...

Same data. No running application. No account requirement. Deployable anywhere.

Pros

REST API — no local dependencies, works on any server or cloud environment
70+ exchanges covered globally, 30+ years of historical data
Fundamentals, macroeconomic indicators, options chains, news sentiment — all under one API key
No pacing restrictions for most endpoints (rate limits are generous on paid plans)
Free tier available for evaluation

Cons

No trade execution — data only (by design)
Real-time quotes have a 15–20 min delay on lower-tier plans

Best for: developers building research tools, AI agents, portfolio analytics, or any financial application where data access needs to be clean, fast, and deployment-independent.

💡 Try EODHD on your next project
API key in 30 seconds. No brokerage account required. Free tier included — EOD data for US exchanges out of the box.
👉 Get started with EODHD

The Most Useful EODHD Endpoints for Developers

EODHD's value isn't just in historical prices. The breadth of the API is where it differentiates.

End-of-Day Prices (/api/eod/)
Daily OHLCV for 70+ global exchanges. Adjusted for splits and dividends. 30+ years of history for major symbols.

Fundamentals (/api/fundamentals/)
Full company financials: income statements, balance sheets, cash flow, earnings history, analyst estimates. Structured JSON you can feed directly into a model or dashboard.

url = f"https://eodhd.com/api/fundamentals/{ticker}"
params = {
    "api_token": API_KEY,
    "filter": "Financials::Income_Statement::yearly"
}
data = requests.get(url, params=params).json()

Real-Time / Live Data (/api/real-time/)
Delayed quotes (~15–20 min) or real-time on higher plans. Bulk requests supported — fetch up to 50 tickers in one call.

Macroeconomic Indicators (/api/macro-indicator/)
GDP, CPI, unemployment, interest rates per country. Useful for macro-driven models and risk analysis.

News & Sentiment (/api/news/)
Financial news filtered by ticker. Useful for NLP pipelines and sentiment-aware trading signals.

Options Data (/api/options/)
Full options chain per symbol including Greeks, open interest, and volume.

Each endpoint follows the same REST pattern. You learn one, you know all.

Side-by-Side Comparison

Feature	Interactive Brokers API	EODHD
Setup required	TWS/IB Gateway + account	API key only
Account required	Yes (brokerage)	No
Deployment	Local / desktop-dependent	Any server, cloud, notebook
Historical data	Yes (paced, limited)	Yes (30+ years, bulk-friendly)
Fundamentals	Limited	Full financial statements
Global coverage	Major exchanges	70+ exchanges
Real-time data	Yes (with live account)	Delayed / real-time (plan-based)
Trade execution	Yes	No
Suitable for AI agents	Difficult	Yes — REST native
Free tier	Paper account only	Yes
Pricing	Free with brokerage account	From $19.99/month

The MCP Advantage: EODHD as an AI-Native Data Layer

This is where EODHD's architecture creates a significant gap that didn't exist two years ago.

With the rise of AI agents — tools built on Claude, GPT-4, LangChain, or custom LLM pipelines — financial data access needs to be agent-callable. That means structured, predictable, HTTP-based endpoints that an AI model can invoke without managing state, connections, or authentication flows mid-conversation.

EODHD has an official MCP (Model Context Protocol) server.

This means you can give Claude, Cursor, or any MCP-compatible agent direct access to EODHD endpoints — without writing a single line of integration code.

A practical example: instead of building an API wrapper, a prompt chain, and an output parser, you connect the EODHD MCP server and ask your agent:

"Fetch the last 6 months of Apple's revenue growth and compare it to its 5-year average."

The agent calls the fundamentals endpoint, receives structured JSON, and performs the analysis — all within a single reasoning loop.

Here's what that integration looks like in a Python agent setup using the EODHD MCP:

# Example: Claude SDK + EODHD MCP integration
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-4-5",
    max_tokens=1024,
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcpv2.eodhd.dev/v2/mcp",
            "name": "eodhd-mcp"
        }
    ],
    messages=[{
        "role": "user",
        "content": (
            "Using EODHD data, get Apple's (AAPL.US) end-of-day prices "
            "for the last 30 days and calculate the 10-day moving average."
        )
    }]
)

print(response.content[0].text)

Interactive Brokers has no equivalent. The IBKR API requires an open socket, a running GUI application, and explicit connection management — none of which fits the stateless, HTTP-native model that AI agents operate on.

If you're building anything AI-powered on top of financial data in 2026, the integration model matters as much as the data itself.

🤖 EODHD + MCP: financial data for AI agents
Connect your LLM pipeline to 70+ global exchanges in one step. No wrappers. No boilerplate. Just structured data your agent can actually use.
👉 Explore the EODHD MCP server

When to Use Each One

Use Interactive Brokers API when:

You're already an IBKR client and need to combine order execution with data in a single script
You're building an algo trading system that needs to execute, not just analyze
You're running a live trading strategy that requires real-time bid/ask data tied to your positions

Use EODHD when:

You're building a research tool, screener, or portfolio analyzer with no execution component
You want to deploy a financial data pipeline on a cloud server without managing desktop software
You're integrating market data into an AI agent, LLM pipeline, or MCP-based workflow
You need global coverage across 70+ exchanges with consistent data structure
You're prototyping — EODHD's free tier lets you validate the idea before committing to a plan

The choice isn't really about which API is "better." It's about what your project actually needs.

If your project needs to place orders: use IBKR.

If your project needs clean, accessible, scalable financial data: EODHD is the obvious answer.

FAQs

❓ Can I use the Interactive Brokers API without a funded account?
✅ Yes, IBKR offers a paper trading account that gives you access to their API without real capital. However, you still need to register, get approved, and run TWS or IB Gateway locally. It's functional for testing but not suited for lightweight or server-based deployments.

❓ Is EODHD free to use?
✅ EODHD has a free tier that includes end-of-day data for US exchanges with limited API calls. It's enough to prototype and evaluate the API structure. Paid plans start at $19.99/month and unlock fundamentals, global exchanges, bulk endpoints, and real-time data.

❓ Does EODHD provide real-time stock data?
✅ EODHD provides delayed quotes (~15–20 minutes) on standard plans. Real-time data is available on higher-tier plans. For most research, backtesting, and AI agent use cases, delayed data is sufficient and significantly cheaper.

❓ Can I use EODHD with an AI agent or LLM pipeline?
✅ Yes — this is one of EODHD's strongest advantages in 2026. EODHD has an official MCP server that makes it directly callable from Claude, Cursor, and any MCP-compatible agent. You don't need to build an API wrapper; you connect the server and your agent can query financial data natively within its reasoning loop.

❓ What's the best financial data API for Python developers in 2026?
✅ It depends on your use case. If you need trade execution, IBKR is the standard. If you need broad, clean, accessible financial data for analysis, AI, or research — EODHD covers more exchanges, requires less setup, and integrates natively with modern AI tooling via its MCP server.

Final Thoughts

The Interactive Brokers API is a serious tool. Well-maintained, deep, powerful.

But it's built for traders, not data engineers.

EODHD is built for the other use case: developers who need financial data as a clean input — in a notebook, on a server, inside an agent — without managing a brokerage session in the background.

The gap widens further when you introduce AI agents into the equation. REST-native APIs with MCP support fit how modern LLM pipelines are built. Socket-based desktop APIs don't.

Choose the tool that matches your architecture, not just your data needs.

📦 Ready to drop the overhead?
EODHD gives you 70+ exchanges, 30 years of history, fundamentals, macro data, and an MCP server — all under one API key. Start free, scale when you need to.
👉 Start with EODHD free tier

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

5 Powerful MCP Use Cases for Financial AI Agents in 2026

Kevin Meneses González — Sun, 24 May 2026 10:43:27 +0000

Most people still use AI like it's a smarter Google.

They open ChatGPT or Claude… ask a few questions… copy a few answers… and that's it.

But something massive is changing right now.

AI is evolving from "chatbots" into systems that can actually work with real-world tools and live data.

And one of the biggest reasons is MCP.

Model Context Protocol (MCP) is quietly becoming the bridge between LLMs and external systems.

Instead of asking an AI generic questions… you can now connect it directly to:

financial APIs
live market data
trading systems
research workflows
automated decision pipelines

The problem? Most developers still don't understand how powerful this becomes when combined with financial data.

Without real-time context:

AI hallucinate prices
invent earnings numbers
provide outdated market information
generate unreliable trading insights

Which makes them useless for serious financial workflows.

That's where MCP changes the game.

By connecting LLMs to live financial APIs like EODHD APIs, you can build AI agents that:

analyze markets
evaluate companies
summarize financial news
generate trading signals
automate research pipelines

In this article, we'll explore 5 practical MCP use cases for financial AI agents — including real-world ideas developers can build today.

What Is MCP (Model Context Protocol)?

MCP is essentially a standardized way for AI models to interact with external tools and systems.

Instead of working only with training data, the model can:

request live information
access APIs
interact with databases
execute workflows

Think about it like giving Claude or ChatGPT "real-time financial senses".

And this becomes incredibly powerful in finance because markets are dynamic. Yesterday's data is already old.

Why MCP Matters for Financial AI

Financial AI agents fail for one main reason: they don't have reliable context.

Without live data:

valuations become outdated
technical indicators become inaccurate
earnings analysis becomes irrelevant
trading decisions become dangerous

Connecting MCP with a live financial data provider like EODHD APIs solves this problem.

You can feed your AI agents:

real-time stock prices
fundamentals
earnings
insider transactions
news sentiment
technical indicators
macroeconomic data
historical OHLC data

Now the AI is no longer "guessing". It's analyzing reality.

👉 Explore EODHD APIs — Real-time market data, fundamentals, news, and technical indicators for financial AI agents.

1. AI-Powered Portfolio Research Agent

One of the best MCP use cases is building a portfolio research assistant.

Instead of manually opening Yahoo Finance, earnings reports, news websites, and spreadsheets… you can ask:

"Analyze my portfolio risk exposure and summarize the biggest concerns."

The AI agent can:

fetch live prices
analyze volatility
compare sector exposure
summarize news
detect concentration risk
explain drawdowns

For example:

NVIDIA overweight exposure
excessive tech correlation
weak diversification
unusual volatility spikes

This transforms AI into a true investment research companion.

And because the data comes through MCP using EODHD APIs, the analysis is grounded in real financial information instead of hallucinations.

2. AI Earnings Analysis Agent

Earnings season creates information overload.

Thousands of reports. Conference calls. Guidance updates. Revenue surprises.

Most traders simply cannot process all of it fast enough.

An MCP-powered AI agent can automatically:

retrieve earnings data
summarize reports
compare quarter-over-quarter growth
detect guidance changes
explain what matters

Imagine asking:

"What were the most important insights from Tesla's latest earnings report?"

The AI could instantly summarize:

revenue growth
margins
AI investments
automotive delivery numbers
management guidance

This is one of the most practical real-world use cases for financial AI — especially for investors, analysts, fintech startups, and trading communities.

3. AI Trading Signal Generator

This is where things get really interesting.

Using MCP + market data APIs, you can create AI agents that combine:

technical indicators
news sentiment
volume analysis
price action

For example:

RSI oversold
unusual trading volume
positive earnings sentiment
bullish momentum breakout

The AI agent can then explain why a signal exists instead of just showing numbers.

Example output:

"Apple shows bullish momentum after earnings, supported by increasing volume and positive AI-related news sentiment."

This is far more useful than traditional black-box indicators.

And with EODHD APIs, developers can access historical market data, technical indicators, real-time prices, and financial news APIs — perfect for algorithmic trading workflows.

4. Autonomous Market News Intelligence Agent

Most traders consume too much information and still miss what matters.

Financial news is overwhelming. A smarter approach is building an AI filtering layer.

With MCP, your AI agent can:

monitor market news
detect unusual events
summarize key developments
prioritize important stories

Instead of reading 100 headlines… you receive 5 critical events, summarized in plain English, with market implications attached.

For example:

"Semiconductor stocks are rising after new AI infrastructure spending announcements."

Or:

"Oil prices dropped after unexpected inventory data."

This becomes incredibly valuable for swing traders, macro investors, and busy professionals.

5. AI-Powered Quant Research Assistant

This is probably the most exciting long-term use case.

Imagine an AI assistant capable of:

testing trading ideas
analyzing correlations
explaining strategy performance
generating research insights

You could ask:

"Find momentum-based strategies that performed well during high-volatility periods."

Or:

"Compare mean reversion performance across tech stocks over the last 10 years."

The AI can use historical data, volatility metrics, technical indicators, and statistical analysis tools.

This dramatically reduces research time for quantitative traders.

And when combined with Python frameworks like pandas, vectorbt, backtesting.py, or Streamlit, you can build incredibly powerful systems.

Why EODHD APIs Fit Perfectly for MCP Workflows

One of the biggest challenges when building financial AI agents is finding reliable data infrastructure.

That's why EODHD APIs are especially interesting for MCP-based workflows.

They provide:

real-time market data
historical OHLC data
financial fundamentals
earnings
economic events
technical indicators
financial news APIs

Which means developers can build AI agents, trading dashboards, automated research systems, and quant workflows — without stitching together multiple fragmented providers.

If you want to experiment with AI-powered finance projects, it's honestly one of the best places to start.

👉 Explore EODHD APIs — Real-time market data, fundamentals, news, and technical indicators for financial AI agents.

Final Thoughts

Most people still think AI is about generating text.

But the real shift is happening somewhere else.

AI is becoming operational. Connected. Context-aware. Integrated with real systems.

And finance is one of the industries where this transformation will happen fastest.

Because whoever can process information faster, filter noise better, and automate financial research… will have a massive advantage.

MCP is one of the most important pieces enabling that future.

And we're still extremely early.

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

The 5 Best OCR APIs for Developers in 2026 (Compared)

Kevin Meneses González — Fri, 22 May 2026 08:54:32 +0000

Most developers underestimate how painful document processing still is.

Invoices. PDFs. Receipts. Contracts. Financial reports.

A huge amount of business data is still trapped inside documents.

And most teams still solve this problem the same way they did 10 years ago:

manual copy-paste,
fragile OCR tools,
messy spreadsheets,
broken automations,
and workflows that collapse the moment a PDF layout changes.

Now combine that with the rise of:

AI agents,
RAG systems,
automation pipelines,
and LLM workflows.

Suddenly, extracting clean structured data from documents becomes one of the most important layers in the entire AI stack.

That's why OCR APIs and document parsing platforms are exploding right now.

But not all tools are built the same.

Some are optimized for:

developer workflows,
AI-native parsing,
invoice automation,
enterprise document ingestion,
or RAG pipelines.

So after researching the current market, here are 5 OCR/document extraction APIs that stand out the most in 2026.

1. LlamaParse (LlamaIndex)

LlamaParse is probably the most interesting OCR/document parsing platform right now for AI engineers.

Why?

Because it's not just "OCR".

It's built specifically for:

LLMs,
AI agents,
and RAG systems.

The difference matters.

Traditional OCR extracts text. LlamaParse tries to preserve semantic structure and context.

Best For

RAG systems
AI agents
Financial reports
Complex PDFs
LLM ingestion pipelines

Key Features

AI-native parsing
Markdown and JSON outputs
Advanced table extraction
Multi-modal parsing
Agentic parsing modes
Complex layout understanding

Pricing

Free tier available
Credit-based pricing
Around 10,000 free credits/pages monthly depending on parsing mode

Pros

Excellent for complex PDFs
Built for AI workflows
Strong parsing quality
Great ecosystem for developers

Cons

More expensive at scale
Overkill for simple OCR use cases
Requires understanding of RAG/LLM workflows

2. Mindee

Mindee is one of the most developer-friendly OCR APIs available today.

Fast setup. Excellent documentation. Very practical APIs.

This is the kind of tool developers love because you can go from "PDF chaos" to "working automation" in a few hours.

Best For

Python developers
OCR automation
Invoice extraction
Receipt OCR
API integrations

Key Features

Invoice OCR
Receipt OCR
Passport/document parsing
Python SDK
API-first architecture
Batch processing

Pricing

Starter plan: ~€44/month
500 pages included
Usage-based scaling available

Pros

Extremely developer-friendly
Great documentation
Strong API ecosystem
Fast implementation

Cons

Less focused on advanced RAG
Enterprise AI features more limited than some competitors

3. Nanonets

Nanonets sits somewhere between OCR platform, AI workflow engine, and automation suite.

Instead of focusing only on extraction, they focus heavily on business automation.

This makes it attractive for companies that want OCR, approvals, integrations, AI extraction, and workflows together.

Best For

Business automation
Finance operations
Invoice processing
AI document workflows

Key Features

AI OCR
Workflow automation
Table extraction
ERP integrations
Email ingestion
Approval systems

Pricing

Free credits available
Pay-as-you-go model
Enterprise plans available

Pros

Strong automation capabilities
Enterprise-friendly
Powerful extraction workflows
Good UI

Cons

Less developer-focused
Can become expensive with volume
More business-oriented than technical

4. Veryfi

Veryfi is heavily specialized in receipts, invoices, bookkeeping, and financial OCR.

And honestly, that focus is a strength.

Instead of trying to solve every OCR problem, they dominate a very specific niche extremely well.

Best For

Fintech
Expense management
Accounting automation
Receipt scanning

Key Features

Receipt OCR
Invoice extraction
Expense categorization
Fraud detection
Mobile OCR
Financial automation

Pricing

API-based pricing
Enterprise-focused plans
Free trial available

Pros

Very accurate for receipts/invoices
Strong financial workflows
Good mobile support

Cons

Narrower use cases
Less useful for general-purpose document parsing

5. Docparser

Docparser is one of those tools you understand in 30 seconds.

Upload a PDF. Extract structured data automatically. Connect it to Zapier, Make, or n8n. And remove hours of manual work.

It doesn't try to be an "AI operating system." And honestly, that's part of the appeal.

It's extremely focused on solving one problem well: extracting structured data from documents reliably.

Best For

Business automation
Invoice extraction
PDF workflows
No-code automation
Operations teams

Key Features

OCR + PDF parsing
Table extraction
Template-based parsing
Zapier integrations
Email parsing
API access
Export to Excel/CSV/JSON

Pricing

Starter plan around $39/month
Professional plans available
Free trial included

Pros

Very easy to use
Great for automations
Fast setup
Strong integrations

Cons

Less AI-native than LlamaParse
Complex documents may require setup
More template-driven

Final Comparison

Tool	Best For	AI-Native	Pricing Model	Developer-Friendly
LlamaParse	RAG / LLM pipelines	✅ Yes	Credits	✅ High
Mindee	Invoice / receipt OCR	Partial	Per page	✅ Very High
Nanonets	Business automation	Partial	Pay-as-you-go	Medium
Veryfi	Fintech / expenses	Partial	API-based	Medium
Docparser	No-code automation	❌ No	Monthly plan	✅ High

Final Thoughts

The OCR market is no longer just about extracting text.

The real opportunity now is building systems that understand documents.

And the companies that solve this layer well will become critical infrastructure for AI agents, automation, RAG systems, fintech, and enterprise AI workflows.

FAQs

What is the best OCR API for developers?
Mindee is probably the best balance between ease of use, pricing, documentation, and developer experience.

Which OCR tool is best for RAG systems?
LlamaParse and Unstructured are currently among the strongest options for AI-native document pipelines.

Which OCR API is best for invoices and receipts?
Veryfi, Mindee, and Nanonets are excellent for financial documents and expense automation.

Are OCR APIs expensive?
Most platforms now offer free tiers, pay-as-you-go pricing, or credit systems. Costs mainly depend on document volume and complexity.

Can OCR APIs work with Python?
Yes. All the platforms mentioned here provide APIs and Python integrations.

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

You're Probably Calculating Your Returns Wrong: The Math Behind True Portfolio Performance

Kevin Meneses González — Thu, 21 May 2026 12:27:44 +0000

My broker told me I was up 12% last year.

The real number, once I accounted for currency conversion losses and the timing of my capital additions, was closer to 7%.

That's not a rounding error. That's a 5-point gap that changes how you evaluate every decision you made that year.

If you invest across multiple brokers, hold assets in different currencies, or move capital in and out of positions throughout the year, the return number your broker shows you is almost certainly wrong. Not maliciously. Just structurally. Broker dashboards are not built to calculate true portfolio performance. They're built to show you activity on their platform.

There's a difference.

Why Broker Return Numbers Are Misleading

Every broker calculates returns differently. And most of them use the simplest possible method: they compare your current value to your starting value and call it a return.

That works fine if you invested a lump sum on January 1st and never touched it.

It breaks immediately the moment you:

Add capital mid-year
Withdraw funds at any point
Hold positions in a different currency than your base
Pay transaction fees, custody fees, or conversion spreads
Split your portfolio across multiple platforms

Which is to say: it breaks for almost every real investor.

TWR vs MWR: The Two Numbers You Need to Understand

There are two ways to measure portfolio return properly. Most investors have never heard of either.

Time-Weighted Return (TWR)

TWR eliminates the effect of external cash flows — deposits and withdrawals — so you can evaluate the performance of your investment strategy independently of when you added or removed money.

It answers the question: how well did my portfolio perform, regardless of my timing decisions?

TWR is the standard used by professional fund managers. It's the number that lets you compare your strategy against a benchmark fairly.

Calculating it manually requires breaking your portfolio into sub-periods every time cash flows in or out, computing the return for each sub-period, and chain-linking them multiplicatively. For a portfolio with monthly contributions across four brokers, that's dozens of calculations per year.

Money-Weighted Return (MWR)

MWR — also called IRR at the portfolio level — accounts for the size and timing of your cash flows. It answers a different question: how well did my money actually perform, given when I deployed it?

If you added a large amount right before a market drop, your MWR will be lower than your TWR. If you happened to invest heavily before a rally, it'll be higher. MWR reflects the reality of your specific decisions.

Neither metric is "better." They answer different questions. The problem is that most brokers show you neither — they show you a simplified gain/loss percentage that conflates both and accounts for neither properly.

The Currency Problem Nobody Talks About

If you hold USD-denominated assets and your base currency is EUR, your broker's return figure is almost certainly calculated in USD.

That matters more than most investors realize.

A position up 15% in USD terms might be up only 7% in EUR terms if the dollar weakened during your holding period. Or it might show 20% if the dollar strengthened. The currency movement is not a minor adjustment — in volatile years it can be larger than the underlying asset's return.

My own experience: a 5–10% gap between what the broker showed and what I actually had after converting back to euros. Not because the broker was wrong in their own terms. Because their terms weren't my terms.

A true return calculation has to be done in your base currency. Every position, every dividend, every fee — converted at the rate applicable on the date of the transaction.

No broker does this automatically across multiple platforms. No spreadsheet maintains this accurately over time without constant manual intervention.

The Hidden Costs That Erode Real Returns

Currency conversion fees and spreads are the most underestimated drag on retail investor returns.

On Degiro, currency conversion carries a fee that applies every time you buy or sell a non-EUR asset. It's small per transaction. Across a year of activity, it compounds.

Neither of these shows up in the return figure your broker displays. They're already baked into your prices, invisible unless you calculate them explicitly.

Add custody fees, inactivity fees, and any platform-specific charges, and the gap between headline return and true return widens further.

The math isn't complicated. But doing it manually, across four platforms, in multiple currencies, for every transaction in a year — that's the problem.

What True Return Calculation Looks Like by Hand

Let's make the complexity concrete. Suppose you want to calculate your MWR for the year across your portfolio.

You need:

The starting value of your portfolio on January 1st
Every cash inflow (deposits, dividends received) with exact dates
Every cash outflow (withdrawals, fees paid) with exact dates
The ending value on December 31st
All of the above converted to your base currency at the exchange rate on each transaction date

Then you solve for the rate r in this equation:

Ending Value = Starting Value × (1+r)^t 
               + CF₁ × (1+r)^(t-t₁) 
               + CF₂ × (1+r)^(t-t₂) 
               + ... CFₙ × (1+r)^(t-tₙ)

Where each CF is a cash flow and each t is the fraction of the year remaining at the time of that cash flow.

This requires numerical iteration to solve — there's no closed-form algebraic answer. In Excel it's the XIRR function. By hand it's trial and error.

Now multiply that by four brokers, twelve months of dividends, currency conversions at different rates on different dates, and exchange-specific fees.

This is not a calculation problem you solve with a better spreadsheet. It's an integration problem — you need software that connects to your accounts, ingests transaction data automatically, applies the correct exchange rates, and computes the result continuously.

What Snowball Shows You Instead

Snowball Analytics does this automatically.

Every position across your connected brokers is tracked in your base currency. Returns are calculated using proper methodology — accounting for cash flow timing, currency movements, and fees. The number you see is your actual return, not your broker's simplified approximation.

The difference isn't cosmetic. For an investor with a multi-currency, multi-broker portfolio, the gap between a broker's headline number and a properly calculated return can be 5–10 percentage points. That's the difference between thinking your strategy is working and knowing whether it actually is.

👉 See your true portfolio return with Snowball Analytics — Multi-broker, multi-currency portfolio tracking with proper TWR/MWR methodology.

Why This Matters for Every Decision You Make

Return calculation isn't academic. It drives every allocation decision you make.

If you think a strategy is returning 12% when it's actually returning 7%, you'll keep deploying capital into it. You'll benchmark it against alternatives incorrectly. You'll attribute performance to skill that was actually currency tailwind — or miss underperformance that was hidden by currency movement.

Conversely, a strategy that looks like 6% in your broker app might actually be 11% once you account for dividend reinvestment timing and a favorable exchange rate. That position deserves more capital, not a review.

The numbers your broker shows you are not wrong. They're just incomplete. And in investing, incomplete information and wrong information produce the same outcome.

The Benchmark Question

Once you have a true return number, the next question is: compared to what?

A 9% return sounds good. Against the S&P 500 returning 15% in the same period, it's underperformance. Against a bond portfolio returning 4%, it's strong outperformance. Against a passive ETF with lower risk and zero time cost, it might not justify the complexity.

You can't answer this question with a broker's simplified return figure. You need TWR — the methodology that strips out your cash flow timing and gives you a clean strategy-level number comparable to any benchmark.

That's the number that tells you whether your active decisions are adding value, or whether you'd be better off in a simple index fund and spending those 10 hours a month on something else.

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

I Built an AI Hedge Fund Analyst Using Claude + EODHD APIs

Kevin Meneses González — Tue, 19 May 2026 08:01:51 +0000

Most people use AI for finance the wrong way.

They open ChatGPT.

They ask: "Should I buy Nvidia?"

And then they expect a useful answer.

But there is one big problem:

AI does not magically know what is happening in the market right now.

It can sound confident. It can write a beautiful explanation. It can even give you a clean bullish or bearish thesis.

But without real financial data, it is mostly guessing.

And guessing is not analysis.

That is why I wanted to build something different.

Not another chatbot. Not another "AI stock picker." Not a toy project.

I wanted to build a small version of what a hedge fund analyst might use every morning: an AI system that can read financial data, analyze news, review fundamentals, detect risks, and generate a useful market summary.

So I built an AI hedge fund analyst using Claude and EODHD APIs.

Here is the step-by-step process.

Step 1: Understand the Real Problem

The problem is not that AI is bad at finance.

The problem is that most AI tools are disconnected from real financial data.

A normal chatbot does not automatically know:

the latest price
recent volume changes
current market news
earnings surprises
insider transactions
valuation metrics
revenue growth
dividend history

And in finance, outdated data is dangerous. A stock can look attractive based on old numbers. A company can look safe before earnings collapse. A bullish thesis can break after one bad guidance call.

This is the key idea: AI is only as good as the data you give it.

That became the foundation of the project. The goal was simple: connect Claude to real financial data.

Step 2: Define What the AI Analyst Should Do

Before writing code, I defined the role of the system.

I did not want a generic assistant. I wanted something closer to a junior hedge fund analyst.

Its job would be to analyze a stock from multiple angles:

Price action
Fundamentals
Recent news
Earnings
Risk factors
Market sentiment
Final summary

The output should not be: "This stock looks good." That is useless.

The output should be structured:

Bullish signals
Bearish signals
Key risks
Data-backed observations
Final analyst-style summary

A good AI financial analyst should not only give answers. It should show its reasoning based on data.

Step 3: Choose the Data Source

This is where EODHD APIs became useful.

For this type of project, I needed access to different types of financial data from one place.

EODHD gives access to data like:

historical prices
real-time and end-of-day market data
fundamentals
news
earnings
dividends
splits
insider transactions

That matters because an AI finance system becomes much more powerful when it can combine multiple signals.

Price data alone is not enough. News alone is not enough. Fundamentals alone are not enough.

The value comes from connecting everything. That is when the AI starts to behave less like a chatbot and more like an analyst.

📊 Try EODHD APIs free — One API for historical prices, fundamentals, news, earnings, insider transactions, and more. Everything in this project runs on it.

Step 4: Build the Basic Architecture

The architecture was simple. I did not want to overcomplicate it.

The system had four main parts:

User enters a ticker
Python fetches financial data from EODHD APIs
Claude analyzes the structured data
The result is displayed in a dashboard

You can make this more advanced later with:

Streamlit dashboard
Telegram alerts
Scheduled reports
Database storage
MCP server
Email summaries
Portfolio tracking

But the first version should be simple. Simple systems get finished. Overcomplicated systems die in Notion.

Step 5: Fetch Market Data

The first signal is price action.

For each ticker, I wanted to know:

current price
recent performance
volatility
trend
volume changes
important price movements

This gives Claude context. Instead of asking: "Analyze Apple stock." — you are giving it something more useful: "Analyze Apple stock using this recent market data."

That small difference changes everything. The AI stops hallucinating and starts interpreting.

Step 6: Add Fundamentals

Price tells you what the market is doing. Fundamentals tell you what the business is doing.

So the next step was to collect company fundamentals:

revenue
earnings
profit margins
debt
valuation ratios
cash flow
dividend data

This is where the analysis becomes more serious. For example, Claude can compare:

revenue growth vs valuation
margins vs debt
dividend yield vs payout ratio
earnings growth vs stock performance

That is much better than a generic AI opinion. Now the model has actual business data to work with.

Step 7: Add News Sentiment

Markets move because of stories.

Earnings matter. Interest rates matter. Regulation matters. Product launches matter. Management changes matter.

So I added recent news data. This allows the AI analyst to answer questions like:

What is the current market narrative?
Are recent headlines positive or negative?
Is the stock moving because of news or technical momentum?
Are there hidden risks in recent articles?

This is one of the most useful parts of the system. Because investors often look at the chart — but forget to ask: "Why is this moving?"

News gives the AI the missing context.

Step 8: Add Earnings Data

Earnings are where reality punches narratives in the face.

A company can have a beautiful story. But if earnings disappoint, the market reacts.

So I added earnings-related data. The AI analyst can now review:

EPS trends
earnings surprises
revenue expectations
past earnings reactions
future earnings dates

This creates much better summaries. For example:

"The stock has strong momentum, but the next earnings report is a major risk because recent EPS growth has slowed."

That is the type of insight you want. Not perfect. Not financial advice. But useful.

Step 9: Add Insider Transactions

This is one of the most interesting signals.

Most retail investors ignore insider activity. But it can be valuable context.

If executives are buying shares, that may signal confidence. If insiders are selling heavily, it does not always mean something bad — but it is worth noticing.

The AI can summarize:

recent insider buys
recent insider sells
transaction size
patterns over time

This makes the analysis feel much more professional. Because now the system is not only looking at charts. It is looking at behavior. And behavior often says more than words.

Step 10: Create the Claude Prompt

This is where everything comes together. The prompt is the brain of the system.

Here is a simple version:

prompt = f"""
You are an AI hedge fund analyst. Analyze the following stock using the data provided.

Ticker:
{ticker}

Market Data:
{market_data}

Fundamentals:
{fundamentals}

Recent News:
{news}

Earnings:
{earnings}

Insider Transactions:
{insider_transactions}

Return the analysis in this structure:
1. Executive Summary
2. Bullish Signals
3. Bearish Signals
4. Key Risks
5. News Sentiment
6. Fundamental Analysis
7. Final Analyst View

Important:
- Do not make up data.
- Only use the information provided.
- Be clear and concise.
- Mention uncertainty when data is incomplete.
"""

This is important: you must tell the model not to invent data. Finance is not the place for creative writing. Unless you enjoy losing money with poetry.

📊 Try EODHD APIs free — One API for historical prices, fundamentals, news, earnings, insider transactions, and more. Everything in this project runs on it.

Step 11: Generate the Analyst Report

Once Claude receives the structured data, it can generate a report like:

Executive Summary:
Apple shows stable fundamentals, but recent revenue growth appears limited
compared to its valuation.

Bullish Signals:
- Strong margins
- Consistent cash flow
- Positive recent news sentiment
- Stable long-term trend

Bearish Signals:
- High valuation
- Slower growth
- Potential earnings risk
- Insider selling activity

Final View:
The stock remains high quality, but the current valuation requires strong
future execution.

This is much more useful than: "Apple is a strong company." Everyone knows that.

The goal is not to state the obvious. The goal is to connect signals.

Step 12: Build a Simple Dashboard

The next step is visual. A good dashboard makes the project feel real.

You can build it with:

Streamlit
Plotly
Python
EODHD APIs
Claude API

Basic dashboard sections:

Ticker input
Price chart
Key metrics
News summary
AI analyst report
Risk score
Final summary

This makes the article much stronger visually. Readers love seeing the actual system — not just theory. Screenshots are your best friend here.

Step 13: Automate the Workflow

Once the system works manually, you can automate it.

For example, every morning the system can:

Check your watchlist
Fetch fresh market data
Analyze news
Detect unusual movements
Generate an AI summary
Send the report by email or Telegram

This turns the project from "cool demo" into "real productivity tool."

And that is where the article becomes more powerful. Because the reader thinks: "I could actually use this."

That is the sweet spot.

Step 14: The Big Lesson

The most important lesson was not about Claude. It was not about Python. It was not even about finance.

The real lesson was this: AI becomes useful when you connect it to the right data.

Without data, AI gives opinions. With data, AI can generate analysis. That is the difference.

Most people are still using AI like a smarter Google search. But the real opportunity is building systems:

Systems that collect data
Systems that analyze information
Systems that summarize complexity
Systems that help you make better decisions

Final Thoughts

This project changed how I think about AI in finance.

The future is not just asking a chatbot: "What stock should I buy?" That is too simple.

The future is building AI systems that monitor markets, analyze data, detect signals, and help humans think better. Not replace thinking — improve it.

And for that, you need two things:

A strong AI model
Reliable financial data

Claude gives you the reasoning layer. EODHD APIs give you the financial data layer.

Together, they allow you to build something much more interesting than another stock dashboard. You can build your own AI financial analyst.

Not perfect. Not magic. But useful.

And in a world full of noisy financial content, useful is already a massive advantage.

📊 Try EODHD APIs free — One API for historical prices, fundamentals, news, earnings, insider transactions, and more. Everything in this project runs on it.

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

The Exact Framework I Use to Forecast My Dividends (And Why My Broker Can't Do This)

Kevin Meneses González — Mon, 18 May 2026 14:06:40 +0000

My goal with dividends is simple: build an income stream that runs without me.

No checking prices every morning. No deciding whether to add more capital this month. Just positions that pay, compound, and grow — while I focus on other things.

Between €500 and €1,000 a month in dividend income is the kind of number that changes how you think about money. It doesn't replace a salary. But it changes the math on every decision you make.

The problem: getting to that number — and staying there — requires forecasting. And forecasting dividends across multiple brokers, in multiple currencies, with positions paying on different schedules, is exactly the kind of thing a spreadsheet cannot do reliably.

If you're:

building a dividend income strategy across multiple accounts,
trying to project future cash flow, not just track past payments,
or tired of visiting 20 different websites to piece together what you'll earn next quarter,

This matters.

Why Broker Dashboards Fail Dividend Investors

Every broker shows you a yield. That's the easy part.

What they don't show you: whether that yield is growing, shrinking, or about to be cut. Whether your income is concentrated in one sector. Whether your portfolio will generate more or less next year than it does today.

Degiro shows me what JEPI paid last month. Interactive Brokers shows me Chevron's yield.

None of them shows me a consolidated view of what my entire portfolio will generate over the next 12 months. None of them tells me the dividend streak of each holding — how many consecutive years a company has kept paying without interruption. None of them gives me a quality rating to compare positions across sectors at a glance.

That's not a minor gap. That's the entire point of a dividend strategy.

The 20-Tab Problem

Before I had a proper system, forecasting dividends looked like this:

Open each broker app separately
Note down the payments received manually
Search each ticker on a financial data site for ex-dividend dates
Cross-reference with a dividend calendar on another website
Copy everything into a Google Sheet
Pray the formulas didn't break when I added a new position

That process took hours. And it was always out of date by the time I finished.

The worst part: I was spending all that time on data collection, not on analysis. I knew roughly what I'd earned. I had no real visibility on what I'd earn.

There's a difference between tracking dividends and forecasting them.

The Metrics That Actually Matter

Most investors focus on dividend yield. It's the number brokers show you. It's also the least useful metric for building a sustainable income strategy.

Here's the framework I use now — and the metrics Snowball surfaces automatically:

1. Dividend Yield

The baseline. What percentage of your invested capital comes back as income annually. Useful for comparison, but incomplete on its own. A high yield can signal a struggling company as easily as a generous one.

2. Dividend Growth (5-Year)

This is the metric that changes everything. A stock yielding 3.52% today but growing its dividend at 6.16% annually — like Chevron — compounds your effective income without adding a single euro of new capital. Target, at just 2.64% yield, is growing at 11.38% annually. In 7 years, that position pays more than most high-yield plays do today.

3. Dividend Streak

How many consecutive years a company has paid dividends without cutting. Johnson & Johnson: 38 years. Coca-Cola: 38 years. Aflac: 35 years. This number tells you more about dividend reliability than yield ever will.

4. Dividend Growth Streak

Not just paying — but increasing the payment every single year. A company that has raised its dividend for 35+ consecutive years has done so through recessions, rate cycles, and market crashes. That's the kind of compounding you can plan around.

5. IRR (Internal Rate of Return)

The metric brokers almost never show you. IRR accounts for when you invested and when you received income — giving you the true annualized return on each position, not just the price gain. A position that's flat on paper might have an IRR of 20%+ once dividends are factored in. That's a completely different picture.

What This Looks Like in Practice: The Stock Screener

Snowball's dividend screener puts all of this in one table. Not per broker — for any stock you want to evaluate.

Look at what that table tells you in seconds:

Chevron (CVX): 3.52% yield, 6.16% 5Y growth, 38-year streak. A dividend aristocrat with momentum.
Exxon (XOM): 3.08% yield, but only 20-year growth streak vs. 37-year payment streak — growing, but more recently.
Target (TGT): the lowest yield in the table at 2.64%, but 11.38% annual growth and a 38-year growth streak. The compounder hiding behind a modest number.

Your broker shows you none of this side-by-side. You'd need five separate tabs to assemble it.

👉 Screen dividend stocks with Snowball Analytics

The Dividend Calendar: Forecasting Made Visual

Knowing your positions is one thing. Knowing when they pay — and projecting forward — is where most investors lose visibility.

This is where Snowball's dividend calendar changes the game.

What you see immediately:

Annual income: $5,419.67 — not a rough estimate, a projection based on declared and estimated payments
Monthly average: $451.64 — your baseline income number
Daily: $14.85 — the number that makes the strategy feel real
Yet to receive: $291.77 — what's already declared and arriving this month

Below that, every payment is broken down by position: JEPI pays monthly on April 6, Merck quarterly on April 10, Realty Income monthly on April 14, and Cisco quarterly on April 26. Each entry shows the exact amount per share, the ex-dividend date, and whether the payment is declared or estimated.

That's a 12-month income roadmap. No spreadsheet builds this automatically. No broker shows you this across all your accounts at once.

The income smoothing tip becomes actionable here too: you can see at a glance which months are heavy ($624 in June, $631 in September) and which are light ($323 in February, $327 in May) — and decide whether to add a position that pays in the gap months before you deploy the next round of capital.

Forecasting vs. Tracking: The Actual Difference

Tracking tells you what happened. Forecasting tells you what to do next.

Most tools — including spreadsheets — are built for tracking. You log a payment, update a cell, move on. The data is historical.

Forecasting requires knowing ex-dividend dates, payment schedules, growth rates, and how changes to one position affect your total income projection. That's the kind of calculation that breaks spreadsheets and sends you back to 20 different tabs.

Having that data consolidated and updated automatically isn't a convenience feature. For a dividend investor, it's the difference between building a strategy and just hoping the payments keep coming.

5 Tips for Investors Already Building Dividend Income

If you already have positions paying dividends and you're trying to optimize — not just collect — here's what actually moves the needle.

1. Stop optimizing for yield. Start optimizing for yield growth.

A 9% yield that stays flat is worth less over time than a 3% yield growing at 10% annually. In 8 years, that 3% position is yielding more on your cost basis than the static 9% — and the underlying company is almost certainly healthier. Look at the 5-year dividend growth column before you look at current yield.

2. Track income concentration, not just portfolio allocation.

You might have a well-diversified portfolio by sector — but 60% of your dividend income coming from one or two positions is a completely different kind of risk. Map your income sources separately from your capital allocation. A single dividend cut can destroy a month's projections if you haven't done this.

3. Use IRR to compare positions fairly.

Two positions with similar yields can have very different IRRs depending on when you bought, how much you've received in dividends, and how the price has moved. IRR is the only metric that accounts for all of this. It's the number that tells you whether a position is actually working for you — or just looking good on paper.

4. Reinvest selectively, not automatically.

DRIP (Dividend Reinvestment Plan) is convenient, but it reinvests into whatever you already own — regardless of whether that's still your best opportunity. A better approach: collect dividends as cash, review your allocation quarterly, and deploy capital into whichever position is most underweight relative to your targets. More work, better results.

5. Build for income smoothing across months.

Most dividend portfolios are lumpy — heavy payments in certain months, nothing in others. Before adding a new position, check when it pays. A portfolio that generates consistent monthly income is easier to plan around than one that pays €2,000 in March and €80 in August. The dividend calendar makes this immediately obvious.

The Goal Isn't Yield. It's Predictability.

€500–€1,000 a month in dividend income is not a number you hit by chasing the highest yields.

It's a number you build toward by selecting positions with growing payouts, understanding your income concentration, and reinvesting deliberately.

You can't do that with a broker dashboard. You can't do it reliably with a spreadsheet.

You need a single view that shows you not just what your portfolio is worth — but what it will pay you, when it will pay you, and whether that number is growing.

👉 Start forecasting your dividend income with Snowball Analytics

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

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

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

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

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

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

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

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

The Red/Green Trap

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

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

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

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

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

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

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

I sold. Not everything. But enough.

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

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

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

The Shift: From Capital Value to Cash Flow

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

Price is volatile. Income is sticky.

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

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

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

What a Portfolio Visualizer Actually Shows You

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

A broker dashboard shows you:

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

A portfolio visualizer shows you:

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

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

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

The Dividend Calendar During a Correction

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

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

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

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

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

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

A Sense of Control vs. Reacting to Noise

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

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

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

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

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

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

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

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

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

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

👉 Get a full view of your portfolio with Snowball Analytics

One Last Thing

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

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

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

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

👉 Start visualizing your portfolio the right way

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

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

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

Most investors think their broker's app is enough.

It's not.

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

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

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

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

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

If you're:

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

This matters.

The Broker Blind Spot Nobody Talks About

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

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

What none of them show me is the full picture.

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

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

The Spreadsheet Trap

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

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

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

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

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

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

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

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

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

The Hidden Cost Nobody Calculates

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

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

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

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

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

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

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

What you end up with is:

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

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

What Changed When I Tried Snowball Analytics

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

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

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

No more spreadsheets. No more Sunday night rituals.

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

👉 Try Snowball Analytics here

What a Proper Portfolio Tracker Actually Shows You

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

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

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

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

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

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

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

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

Your Broker's App Is Not a Wealth Tracker

Broker apps are trading interfaces with dashboards bolted on.

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

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

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

👉 Start tracking your full portfolio with Snowball Analytics

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

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

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

Your script ran fine yesterday. Today it throws:

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

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

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

If you're:

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

This matters more than you think.

The Problem Isn't Your Code

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

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

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

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

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

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

What I Switched To — and Why EODHD

After testing several alternatives, I migrated to EODHD APIs.

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

What you get access to:

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

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

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

The Migration in Python

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

1. Historical Price Data

Before — yfinance:

import yfinance as yf

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

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

After — EODHD:

import requests
import pandas as pd

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

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

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

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

Output:

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

Clean, predictable, JSON-native.

2. Fundamental Data (Balance Sheet / Income Statement)

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

After — EODHD:

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

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

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

Output:

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

Structured, typed, consistent across updates.

3. Dividend History

Before — yfinance:

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

After — EODHD:

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

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

Output:

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

From here you can build:

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

What Actually Changed After the Migration

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

Data Coverage

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

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

Historical Depth

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

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

Reliability vs. Scraping

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

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

Endpoint Depth

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

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

Full Comparison

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

The Cost Question

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

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

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

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

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

That's worth more than free.

Key Takeaways

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

FAQs

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

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

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

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

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

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

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

How I Automated My Investing Workflow with EODHD and Claude Cowork

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

I had trade history files from three different brokers.

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

If you're:

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

this matters.

The Problem With Manual Portfolio Tracking

Every month, the process looked the same.

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

Then start cleaning.

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

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

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

The data was never the problem.

The system connecting it was.

The Stack: Two Tools, One Workflow

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

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

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

Here's how each one fits in.

Claude Cowork: From Chaos to Clean Data

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

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

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

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

EODHD API: Enriching Every Position

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

For each ticker in the portfolio, the script pulls:

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

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

👉 Start with EODHD here

The Implementation: Step by Step

Step 1 — Drop Files Into Cowork

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

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

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

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

Step 2 — Enrich With EODHD

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

import requests
import pandas as pd

API_KEY = "your_eodhd_api_key"

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

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

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

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

From here you can extend the script to pull:

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

Step 3 — Update the Dashboard

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

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

What the Dashboard Shows

Monday morning. One tab open.

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

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

Now it runs in minutes.

Key Takeaways

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

Most investors don't need better instincts.

They need a better system.

Get Started With EODHD

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

👉 Start with EODHD here

You'll get access to:

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

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

FAQs

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

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

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

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

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