Forem: Kevin Meneses González

How I Automated My Investment Research With 50 Lines of Python

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

The Problem: Too Much Noise, Not Enough Signal

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

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

Every day, the same process.

And the problem wasn't time alone.

It was inconsistency.

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

Because I was relying on manual effort.

The Shift: From Checking Stocks to Filtering Them

At some point, I realized something simple:

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

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

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

That's when I built a simple Python watchlist.

What This System Actually Does

The idea is straightforward:

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

Instead of asking:

"What should I check today?"

You get:

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

Step 1: Define Your Watchlist

This is your universe of interest.

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

This list can include:

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

The watchlist gives structure to your process.

Step 2: Define Your Conditions

Now comes the key part.

You define what "interesting" means.

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

This means:

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

You are encoding your thinking into rules.

Step 3: Fetch Real-Time Data

To make this work, we need reliable data.

This is where EODHD comes in.

import requests

API_KEY = "YOUR_API_KEY"

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

This gives us:

Current price
Volume
Daily change

Everything needed to evaluate our conditions.

Step 4: Apply the Logic

Now we combine everything.

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

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

Step 5: Filter the Market

results = []

for symbol in WATCHLIST:
    data = get_stock_data(symbol)

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

Step 6: Get a Clean Output

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

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

What Changed for Me

Before this system:

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

After:

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

The script doesn't make decisions for me.

It removes the noise before I make them.

The Hidden Cost of API Calls

This is something most people ignore.

When you build systems like this, API usage matters.

Let's say you track:

30 stocks
Every hour

That quickly becomes thousands of API calls per month.

And here's the problem:

Not all APIs handle this well.

Some have:

Strict limits
Unstable responses
Delayed data

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

Time
Errors
Missed opportunities

Why Data Quality Matters

In a system like this, everything depends on data.

If your data is wrong:

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

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

Because it gives you:

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

This is what allows the system to actually work.

FAQs

Do I need advanced Python skills?

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

Can I change the conditions?

Yes. That's the core idea.

You can adapt the script to:

Momentum strategies
Long-term filters
Volatility setups

Is this a trading bot?

No.

This is a filtering system.

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

Are free APIs enough?

For testing, yes.

For real systems, usually not.

Because reliability becomes critical.

Why use EODHD?

Because it allows you to:

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

Final Thought

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

But the real advantage comes from filtering better.

Because:

You don't need more data
You need less noise

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

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

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

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

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

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

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

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

You hit the wall before the first component renders.

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

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

Why the Usual Options Don't Work

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

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

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

What I Built

A single-page React app with four vertical sections:

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

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

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

What the API Actually Returns

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

`GET /coins?limit=50`

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

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

`GET /markets`

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

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

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

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

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

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

`GET /news?limit=6`

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

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

Project Setup

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

Tailwind v4 configuration in vite.config.js:

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

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

In src/index.css:

@import "tailwindcss";

Create .env in the root:

VITE_COINSTATS_KEY=your_api_key_here

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

The Data Hooks

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

`useCoinList` — The main table data

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

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

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

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

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

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

  return { coins, loading, error };
}

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

`useMarketStats` — Global market cards

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

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

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

  return { stats, loading };
}

`useChartData` — Price history per coin

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

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

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

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

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

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

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

  return { chartData, loading };
}

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

`useNews` — News feed

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

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

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

  return { news, loading };
}

Section 1: Global Market Stats

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

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

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

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

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

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

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

Section 2: Coin Table with Sort and Search

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

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

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

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

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

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

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

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

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

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

Section 3: The Inline Price Chart

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

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

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

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

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

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

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

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

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

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

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

Section 4: News Feed

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

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

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

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

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

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

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

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

Composing the App

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

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

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

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

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

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

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

      </div>
    </div>
  );
}

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

How Many API Calls Does the Dashboard Make?

At cold load, before any user interaction:

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

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

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

API Key Security

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

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

For a public production deployment:

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

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

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

FAQ

Do I need a backend to use CoinStats API?

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

How do I protect the API key in production?

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

Why Recharts instead of Chart.js or D3?

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

Why no TypeScript?

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

Does this work with React 19?

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

Can I add portfolio tracking without a backend?

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

Wrapping Up

Four data sections. Four hooks. One API.

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

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

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

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

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

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

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

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

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

If you're:

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

this matters.

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

Why Unofficial APIs Break (and What to Use Instead)

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

Here's what developers typically run into:

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

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

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

That's exactly what EODHD gives you.

What Is EODHD and What's Free

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

The free plan gives you:

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

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

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

Getting Historical Stock Data in Python: Step by Step

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

1. The base request

import requests
import pandas as pd

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

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

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

Output:

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

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

2. Build a multi-ticker price matrix

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

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

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

Output:

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

3. Compute returns and volatility

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

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

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

Output:

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

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

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

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

Here's something most tutorials skip entirely.

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

Bad stock data comes in predictable forms.

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

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

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

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

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

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

Advanced Use Cases

Use Case 1: Correlation matrix for portfolio analysis

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

import matplotlib.pyplot as plt

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

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

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

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

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

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

Use Case 2: RSI indicator from scratch

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

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

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

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

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

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

Output:

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

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

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

Use Case 3: Backtesting a moving average crossover

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

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

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

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

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

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

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

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

Use Case 4: Multi-asset momentum ranking

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

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

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

prices = pd.DataFrame(frames)

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

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

Output:

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

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

Free vs Paid: What Changes When You Upgrade

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

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

FAQs

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

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

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

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

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

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

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

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

Closing

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

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

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

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

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

Top 6 Cryptocurrency Data APIs: Comprehensive Comparison (2026)

Kevin Meneses González — Fri, 24 Apr 2026 17:01:33 +0000

Most developers building crypto tools make the same mistake.

They grab the first API with a free tier, get it working, then six months later realize they're juggling three providers, paying for overlapping data, and still missing what they actually need.

The right API depends on what you're building:

A trading bot that reacts to live market moves
A portfolio tracker spanning DeFi, wallets, and CEX balances
A quantitative model that needs 10 years of clean OHLCV history
An on-chain research dashboard tracking blockchain fundamentals

In this comparison, we cover six of the most capable crypto data API providers — CoinStats, Mobula, EODHD, CoinMarketCap, CoinGecko, and CryptoCompare — focusing on data types, real-time capabilities, rate limits, documentation, and pricing.

Let's start with the one that covers the most ground.

1. CoinStats — The All-in-One Crypto Data & Wallet Layer

Platform: coinstats.app/api-docs
Standout feature: Single integration covering market prices, wallet balances, DeFi positions, and transaction history across 120+ blockchains — plus a native MCP server for AI agents.

Most crypto APIs answer one question well. CoinStats answers all of them.

CoinStats API consolidates market data, wallet balances, DeFi positions, transaction histories, and portfolio analytics into a single endpoint. That matters because most projects end up stitching together a chain-specific RPC node, a market data provider, a DeFi aggregator, and a transaction parser. CoinStats replaces that entire stack.

The platform powers the CoinStats app with over 1M monthly users, and the same infrastructure is available to any developer via API key.

What you get:

Real-time prices, market caps, volumes, and OHLCV charts for 100,000+ coins
Wallet balances and transaction histories for any address across 120+ blockchains
Staking, lending, and LP positions across 10,000+ DeFi protocols — auto-detected per wallet
Tickers and trading pairs from 200+ exchanges with consistent response formatting
Aggregated crypto news, trending topics, and sentiment data

MCP Server for AI agents:

The CoinStats MCP Server exposes the same data through the Model Context Protocol, allowing LLMs and AI agents to query crypto data directly. This works with Claude, Cursor, Claude Code, VS Code, and N8N, among other MCP clients.

That's a significant differentiator for teams building AI-powered tools in 2025.

What you can build:

Portfolio trackers, trading bots and signal engines, tax and accounting tools, multi-chain wallet explorers, and AI crypto assistants.

Pros:

Widest integration surface: one API key, one schema across 120+ chains
DeFi positions auto-detected — no manual protocol setup
MCP server ready for AI agent workflows
Free tier with credit-based pricing (not flat limits)

Cons:

Newer API compared to established players — ecosystem still maturing
Credit-based model requires more upfront planning for high-volume use
Not the right choice if you only need clean multi-asset historical data (stocks + crypto)

Pricing: Free tier available. Credit-based pricing scaled to endpoint complexity rather than flat monthly limits. Get your API key at openapi.coinstats.app.

Best for: Developers building portfolio trackers, multi-chain explorers, AI agents, or any product that needs wallet + market + DeFi data in a single call.

2. Mobula — Developer-First Onchain Data & Execution Layer

Platform: Mobula Official Site
Standout feature: Stream-based, real-time onchain API with sub-second latency, multi-chain coverage, and a built-in execution layer.

Most trading bot platforms give you a pre-packaged interface and call it a day. Mobula gives you the raw infrastructure to build exactly the bot you want.

Mobula is a real-time onchain data and execution platform for developers building automated trading tools, crypto dashboards, AI agents, and DeFi products. At its core is the Octopus engine — a multi-chain pricing system that tracks assets from major tokens down to newly listed DEX pairs, aggregating prices using volume weighting and liquidity ponderation. Prices update every 5 seconds with no caching, even on free plans.

Data covered:

Token prices, wallet balances, historical PnL, pair trades, pool states, OHLCV data
Wallet labels, token security checks
Execution layer: route swaps and execute onchain trades programmatically

Mobula supports Ethereum, Solana, BNB Chain, Base, and many more, with a TypeScript SDK and GraphQL alongside the REST API.

Pros:

Blazing fast, no-cache data — prices refresh every 5 seconds on any tier
Data + execution in one platform — skip stitching together multiple providers
Broadest onchain coverage including long-tail tokens and newly listed DEX pairs
Developer-first: REST, WebSocket, TypeScript SDK, GraphQL, real-world cookbooks

Cons:

Requires coding — no no-code interface
No visual strategy builder
Execution layer features are relatively recent

Pricing: Free tier with a free API key. Paid plans available via the Mobula dashboard, usage-based — more cost-efficient than flat-subscription competitors for lean bots or early-stage projects.

Best for: Technically proficient developers building custom bots, dashboards, or AI agents who need institutional-grade onchain data including DeFi tokens and cross-chain wallet tracking.

3. EODHD — All-in-One Multi-Asset Data

Platform: eodhd.com
Standout feature: Up to 30 years of historical data across stocks, forex, and 2,600+ crypto pairs under one API.

EODHD is a versatile financial data provider that goes beyond crypto. It covers stocks, forex, ETFs, and crypto under one consistent JSON/CSV API — which makes it the pragmatic choice when you're building cross-asset tools.

For crypto specifically:

Historical OHLCV with records for major coins going back to 2009
Live crypto price quotes via REST and WebSocket
Fundamental metrics: market cap, diluted valuation, circulating/total/max supply, all-time highs/lows
Bulk API endpoints for efficient data ingestion
No-code add-ons for Excel and Google Sheets

Pros:

All-in-one: crypto + equities + FX under a single, consistent API
Best-in-class historical depth — 30 years for equities, full crypto history since Bitcoin genesis
Excellent price-to-performance ratio
24/7 live customer support and thorough documentation

Cons:

No native on-chain/DeFi metrics
Not focused exclusively on crypto — specialists may find other APIs deeper on chain data

Pricing:

Free: 20 calls/day (no credit card required)
From $19.99/mo: 100,000 calls/day, end-of-day + live crypto data
$29.99/mo: adds real-time WebSocket streaming
$99.99/mo: All-in-One (historical, intraday, real-time, fundamentals, news)
Enterprise and student (50% discount) plans available

Best for: Developers and analysts building cross-asset tools, backtesting pipelines, or dashboards that need both crypto and traditional finance data from one provider.

4. CoinMarketCap — Industry-Standard Market Data

Platform: coinmarketcap.com/api
Standout feature: Data on 10,000+ assets aggregated from hundreds of exchanges — the reference standard for market cap rankings.

CoinMarketCap is the most recognized name in crypto market data. Its API is the go-to for current prices, rankings, and exchange statistics.

Key data:

Real-time price quotes, market cap, trading volume, and rankings for thousands of assets
Global market metrics: total market cap, Bitcoin dominance, total volume
Exchange-level data: listings, trading pair metadata, liquidity scores
Derivatives market data (futures, options) on higher plans

Historical data is locked behind paid tiers. The free plan covers only current market data.

Pros:

Industry-recognized data, used by Yahoo Finance and major financial platforms
Robust documentation with straightforward RESTful endpoints
Covers derivatives and exchange analytics

Cons:

No on-chain metrics
Historical data requires paid upgrade
Can become expensive at scale — enterprise tiers are priced for enterprise budgets

Pricing:

Free: 10,000 credits/month (~333 calls/day), 11 core endpoints
Hobbyist: ~$29/mo — ~50,000 calls/month, more endpoints
Startup: ~$79/mo | Standard: ~$199/mo
Professional/Enterprise: from $699/mo and up

Best for: Apps that need authoritative market cap rankings and real-time prices for a broad asset universe, especially when credibility of the data source matters to end users.

5. CoinGecko — Broad Coverage & Community Focus

Platform: coingecko.com/en/api
Standout feature: 13,000+ cryptocurrencies tracked including DeFi, NFTs, and community metrics — with one of the best free tiers in the industry.

CoinGecko is often the first choice for developers who want to get something working quickly without a credit card. Its free tier covers most endpoints and has been powering projects and tutorials for years.

Key data:

Real-time prices, market caps, and volumes for 13,000+ assets
Historical market charts (daily/hourly granularity)
Exchange data, trading pairs, categories, and asset contract addresses
Developer and social metrics: GitHub stats, Twitter followers, Reddit subscribers
DeFi protocol data and NFT collections

No WebSocket support — REST only, with polling intervals from 1–5 min (free) to ~30 sec (Pro).

Pros:

One of the best free tiers in the space
Exceptionally wide asset coverage including small-cap and emerging tokens
Community/developer metrics are unique to CoinGecko
Very easy to integrate — clean documentation, simple GET requests

Cons:

REST only — no WebSocket streaming
Not suited for high-frequency or ultra-low-latency use cases
Paid plans can get expensive for heavy usage

Pricing:

Free (Demo): ~10–30 calls/min, most endpoints included
Analyst: ~$129/mo — 500,000 calls/mo at 500 req/min
Pro: ~$499/mo — 2,000,000 calls/mo
Enterprise: ~$999/mo+

Best for: Developers who need broad asset coverage on a budget, or analysts who want community and developer activity metrics alongside price data.

6. CryptoCompare — Full Market Data + Sentiment + On-Chain

Platform: cryptocompare.com/api
Standout feature: Price data from 260,000+ trading pairs across 170+ exchanges, combined with news feeds, social sentiment, and basic on-chain metrics in one API.

CryptoCompare is the choice when you want more than just prices. It blends market data with alternative data — news, social sentiment, and some blockchain metrics — making it useful for researchers who want to correlate on-chain activity with price movements.

Key data:

5,700+ coins and 260,000+ trading pairs across 170+ exchanges (CEX and DEX)
Real-time quotes, order book snapshots, trade history, OHLCV candlesticks
Historical daily and intraday (minute) data — up to 1 year of minute-level history on enterprise
Blockchain metrics: transaction counts, wallet address data for major chains
News feeds and social sentiment endpoints

Infrastructure supports up to 40,000 API calls per second in bursts — suitable for demanding real-time dashboards.

Pros:

Enormous trading pair coverage across a wide exchange universe
Mix of price + news + sentiment + basic on-chain in one integration
High-performance infrastructure for real-time applications
Well-documented with Python client libraries

Cons:

Not as deep on on-chain metrics as dedicated platforms like Glassnode
Historical minute data beyond 7 days is enterprise-only
Free tier limits are not explicitly published — less transparent than competitors

Pricing:

Free: non-commercial, API key required (a few thousand calls/day reported)
Paid: from ~$80/mo basic to ~$200/mo advanced
Enterprise: custom pricing for unlimited usage, custom feeds, white-label

Best for: Quantitative researchers and analysts who want a mid-range provider combining market depth, news/sentiment signals, and basic on-chain context without committing to enterprise pricing.

Side-by-Side Summary

Provider	Real-Time	Historical	On-Chain/DeFi	Multi-Chain Wallets	MCP/AI Ready	Free Tier	Starting Price
CoinStats	✅	✅	✅ Deep	✅ 120+ chains	✅ Native	✅ Credits	Free
Mobula	✅ Sub-second	✅	✅ DEX/DeFi	✅ Multi-chain	Partial	✅	Usage-based
EODHD	✅ WebSocket	✅ 30yrs	❌	❌	❌	✅ 20 calls/day	$19.99/mo
CoinMarketCap	✅ (~1-2 min)	Paid only	❌	❌	❌	✅ Limited	$29/mo
CoinGecko	✅ REST	✅	Partial	❌	❌	✅ Generous	$129/mo
CryptoCompare	✅ WebSocket	✅ Minute	Basic	❌	❌	✅ Limited	~$80/mo

Which One Should You Use?

There's no single winner — it depends entirely on what you're building.

Pick CoinStats if you need a single integration covering wallet data, DeFi positions, and market prices across 120+ chains. Especially relevant if you're building AI-powered tools — the MCP server is production-ready.

Pick Mobula if you're building automated trading systems that need real-time, no-cache DEX/DeFi data and want the execution layer included.

Pick EODHD if your product spans crypto and traditional finance, and you need decades of clean historical data across asset classes.

Pick CoinMarketCap if your use case requires the industry-recognized market cap reference and exchange-level data with a reliable SLA.

Pick CoinGecko if you're prototyping fast, working on a budget, or need community/developer metrics alongside prices.

Pick CryptoCompare if you're a researcher who wants price, sentiment, and basic on-chain data blended in one API at a mid-range price.

The worst outcome is picking one and discovering three months in that it doesn't cover your actual use case. Start with a clear list of what your product needs to query — then pick accordingly.

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

How to Connect Claude to Real Financial Data with FMP MCP

Kevin Meneses González — Wed, 22 Apr 2026 06:09:28 +0000

Most investors using AI are still stuck analyzing screenshots.

They copy numbers from a brokerage. Paste charts into ChatGPT. Ask questions about data that's already 3 hours old.

If you're:

building a portfolio monitoring system,
automating weekly research reports,
or trying to cut 4 hours of manual work down to 20 minutes,

This matters.

The real problem isn't the AI. It's the pipeline. And MCP fixes that.

Why Financial AI Tools Break at the Data Layer

The pattern repeats constantly.

A developer sets up a solid Claude workflow. The prompts are good. The logic is there. Then they hit the wall: getting real, structured financial data into the model without building and maintaining a custom API layer.

The options until recently were ugly:

Scrape Yahoo Finance and pray it doesn't break
Pay for a premium API and write integration code from scratch
Use CSV exports and process everything manually

None of these scale. All of them break.

The issue is infrastructure, not intelligence.

What FMP MCP Actually Does

Financial Modeling Prep launched an official MCP server that exposes its entire financial data catalog directly to Claude.

No middleware. No custom connectors. No parsing logic.

Claude reads the available tools, calls them when needed, and returns structured answers — the same way a senior analyst would query a Bloomberg terminal, except you don't need to pay $24,000/year for the hardware.

FMP's MCP server gives you access to:

Real-time and historical stock prices
Income statements, balance sheets, and cash flow data
Financial ratios and valuation metrics
Earnings calendars and analyst estimates
Sector performance and market movers
Crypto, forex, and commodities data

One server. One configuration. Everything your research workflow needs.

Setup in Under 10 Minutes

1. Get your FMP API key

👉 Get access to FMP's data plans here

The free tier covers a solid range of endpoints — enough to test and build the core of your workflow.

2. Install the MCP server

npm install -g @financialmodelingprep/mcp-server

3. Configure Claude Desktop

Open your claude_desktop_config.json file and add:

{
  "mcpServers": {
    "fmp": {
      "command": "npx",
      "args": ["-y", "@financialmodelingprep/mcp-server"],
      "env": {
        "FMP_API_KEY": "your_api_key_here"
      }
    }
  }
}

Restart Claude Desktop. The FMP tools will appear automatically in the interface.

4. Test the connection

Ask Claude directly:

"What is Apple's current P/E ratio and how does it compare to the sector average?"

Claude will call the FMP tools, retrieve live data, and return a structured response. No copy-paste. No manual lookup.

3 Systems You Can Build This Week

This is where the time savings become concrete.

System 1 — Morning Portfolio Brief (15 minutes saved daily)

Instead of checking 6 different tabs every morning, set up a prompt that pulls everything in one shot:

Retrieve the current price, daily change, and P/E ratio for AAPL, MSFT, NVDA, and AMZN. 
Then summarize which position has moved most relative to its 52-week range 
and flag any that have dropped more than 2% today.

Claude queries FMP, compares positions, and gives you a ranked brief.

What used to take 20 minutes of tab-hopping takes 90 seconds.

System 2 — Earnings Prep Autopilot (2 hours saved per company)

Before an earnings call, most investors pull the same data every time: revenue trend, margin evolution, analyst consensus, year-over-year comparisons.

Claude can do it all in one call:

For $TSLA: retrieve the last 4 quarters of revenue, gross margin, and EPS. 
Compare against analyst consensus estimates. 
Highlight the biggest deviation between reported and estimated figures.

You get a structured earnings preview in under a minute.

From here you can build:

Pre-earnings briefing templates for your full watchlist
Automated flags when a company is expected to miss consensus by >10%
Comparative analysis across sectors before reporting season

System 3 — Fundamental Screening on Demand

Screening tools are useful. But they're fixed. They show you what the tool was designed to show.

With FMP MCP + Claude, you ask in natural language:

Find companies in the S&P 500 with a P/E below 15, 
debt-to-equity under 0.5, and revenue growth above 10% YoY. 
Sort by free cash flow yield descending.

Claude translates that into FMP queries, aggregates the results, and returns a clean list.

Your own screener. No SQL. No filters to configure.

What This Looks Like in a Python Workflow

If you're building automated pipelines rather than interactive sessions, FMP's REST API integrates cleanly alongside the MCP layer.

import requests

API_KEY = "your_api_key_here"
BASE_URL = "https://financialmodelingprep.com/api/v3"

def get_income_statement(ticker: str, limit: int = 4) -> list:
    url = f"{BASE_URL}/income-statement/{ticker}"
    params = {"apikey": API_KEY, "limit": limit}
    response = requests.get(url, params=params)
    return response.json()

def get_ratios(ticker: str) -> dict:
    url = f"{BASE_URL}/ratios-ttm/{ticker}"
    params = {"apikey": API_KEY}
    response = requests.get(url, params=params)
    return response.json()

# Pull last 4 quarters of financials + current ratios
ticker = "AAPL"
income = get_income_statement(ticker)
ratios = get_ratios(ticker)

print(f"Revenue (last quarter): ${income[0]['revenue']:,}")
print(f"Net income margin: {ratios[0]['netProfitMarginTTM']:.2%}")
print(f"P/E ratio (TTM): {ratios[0]['peRatioTTM']:.2f}")

Sample output:

Revenue (last quarter): $124,300,000,000
Net income margin: 23.97%
P/E ratio (TTM): 28.43

From here you can build:

Automated weekly reports delivered to Slack or email
Portfolio dashboards that refresh with real data on a schedule
Watchlist monitors that alert you when a ratio crosses a threshold

Practical Tips for Investors Using This Stack

Before building anything, a few lessons that save time.

Start with one workflow, not three. The most common mistake is trying to automate everything on day one. Pick your highest-friction task — for most investors it's the morning check — and make that seamless first. Once it runs reliably, extend it.

Use specific tickers, not vague questions. Claude performs better when you anchor queries to concrete symbols. "How is Apple doing?" produces a generic summary. "Retrieve AAPL's current P/E, 52-week range, and analyst consensus for Q2" produces structured, actionable data.

Chain queries, don't stack them. Instead of asking Claude to do everything in one giant prompt, build multi-step conversations:

Step 1: Pull the raw data
Step 2: Ask for the analysis
Step 3: Ask for the formatted output

This keeps the model focused and makes errors easier to debug.

Set a daily schedule for automated queries. If you're using the Python pipeline, run it at a fixed time — 7:30 AM before markets open works well. Use a simple cron job or a task scheduler like schedule:

import schedule
import time

def run_morning_brief():
    # Your FMP data pull + report generation here
    print("Morning brief generated.")

schedule.every().day.at("07:30").do(run_morning_brief)

while True:
    schedule.run_pending()
    time.sleep(60)

Store your API key as an environment variable, never in code. A small discipline that matters:

export FMP_API_KEY="your_key_here"

import os
API_KEY = os.getenv("FMP_API_KEY")

Use FMP's free tier to prototype, then upgrade only when you hit a wall. The free plan covers quotes, financial statements, and ratios for most common tickers. You'll only need a paid plan when you require real-time data at high frequency, access to smaller/international stocks, or advanced endpoints like institutional holdings.

How to Build a Portfolio Dashboard with FMP + Python

This is where the stack becomes a genuine time-saving system.

The goal: a single HTML file that opens in any browser and shows your portfolio's key metrics, refreshed every morning without manual effort.

Architecture Overview

Claude Desktop + MCP handles interactive queries and one-off analysis
Python Pipeline handles scheduled, automated data pulls via REST API
FMP is the single source of truth for all financial data
Outputs are either Claude responses, Python-generated files, or Slack/email alerts

Step 1 — Define your dashboard metrics

Pick 5–8 metrics that actually drive your decisions. A solid starting set:

PORTFOLIO = {
    "AAPL": 15,   # shares
    "MSFT": 10,
    "NVDA": 8,
    "AMZN": 12,
}

METRICS = [
    "price",
    "changesPercentage",
    "pe",        # P/E ratio
    "eps",
    "52WeekHigh",
    "52WeekLow",
]

Step 2 — Pull data for all positions

import requests
import os

API_KEY = os.getenv("FMP_API_KEY")
BASE_URL = "https://financialmodelingprep.com/api/v3"

def get_quotes(tickers: list) -> list:
    symbols = ",".join(tickers)
    url = f"{BASE_URL}/quote/{symbols}"
    response = requests.get(url, params={"apikey": API_KEY})
    return response.json()

portfolio_tickers = list(PORTFOLIO.keys())
quotes = get_quotes(portfolio_tickers)

Step 3 — Calculate portfolio value and build the report

from datetime import datetime

def build_report(quotes: list, portfolio: dict) -> dict:
    report = {
        "date": datetime.now().strftime("%Y-%m-%d %H:%M"),
        "positions": [],
        "total_value": 0,
        "total_daily_change": 0,
    }

    for q in quotes:
        ticker = q["symbol"]
        shares = portfolio.get(ticker, 0)
        value = q["price"] * shares
        daily_pnl = q["change"] * shares

        report["positions"].append({
            "ticker": ticker,
            "price": q["price"],
            "change_pct": q["changesPercentage"],
            "pe": q.get("pe", "N/A"),
            "shares": shares,
            "value": round(value, 2),
            "daily_pnl": round(daily_pnl, 2),
        })

        report["total_value"] += value
        report["total_daily_change"] += daily_pnl

    report["total_value"] = round(report["total_value"], 2)
    report["total_daily_change"] = round(report["total_daily_change"], 2)
    return report

report = build_report(quotes, PORTFOLIO)

Step 4 — Export to HTML dashboard

def export_html(report: dict, filename: str = "dashboard.html"):
    rows = ""
    for p in report["positions"]:
        color = "#22c55e" if p["daily_pnl"] >= 0 else "#ef4444"
        sign = "+" if p["daily_pnl"] >= 0 else ""
        rows += f"""
        <tr>
            <td><strong>{p['ticker']}</strong></td>
            <td>${p['price']:,.2f}</td>
            <td style="color:{color}">{p['change_pct']:.2f}%</td>
            <td>{p['pe']}</td>
            <td>{p['shares']}</td>
            <td>${p['value']:,.2f}</td>
            <td style="color:{color}">{sign}${p['daily_pnl']:,.2f}</td>
        </tr>"""

    html = f"""<!DOCTYPE html>
<html>
<head>
  <title>Portfolio Dashboard</title>
  <style>
    body {{ font-family: Arial, sans-serif; padding: 20px; background: #0f172a; color: #e2e8f0; }}
    h1 {{ color: #94a3b8; font-size: 18px; }}
    table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
    th {{ background: #1e293b; padding: 10px; text-align: left; color: #94a3b8; }}
    td {{ padding: 10px; border-bottom: 1px solid #1e293b; }}
    .total {{ margin-top: 20px; font-size: 22px; }}
  </style>
</head>
<body>
  <h1>Portfolio Dashboard — {report['date']}</h1>
  <table>
    <tr><th>Ticker</th><th>Price</th><th>Change</th><th>P/E</th><th>Shares</th><th>Value</th><th>P&L Today</th></tr>
    {rows}
  </table>
  <div class="total">
    Total: <strong>${report['total_value']:,.2f}</strong> &nbsp;|&nbsp;
    Today: <strong style="color:{'#22c55e' if report['total_daily_change'] >= 0 else '#ef4444'}">${report['total_daily_change']:,.2f}</strong>
  </div>
</body>
</html>"""

    with open(filename, "w") as f:
        f.write(html)
    print(f"Dashboard saved: {filename}")

export_html(report)

Open dashboard.html in any browser. Schedule the full script at 7:30 AM and your portfolio brief is ready before you pour your coffee.

From here you can extend it with:

A Slack webhook to push the summary to a channel automatically
A second tab comparing current P/E ratios against 5-year historical averages
An alert row that highlights any position down more than 3% in red

Key Takeaways

MCP removes the integration layer — Claude connects to FMP directly, without custom code or API wrappers
The time savings are real — systems like these compress hours of manual research into minutes of structured output
The free tier is enough to start — you don't need a premium plan to build and test the core workflows

Start Building

FMP's MCP server is one of the cleanest financial data integrations available for Claude today.

If you're building research workflows, portfolio tools, or automated briefings — this is the infrastructure layer that makes it practical.

👉 Explore FMP's data plans and get started

FAQs

Do I need to know how to code to use FMP MCP with Claude?

No. The Claude Desktop setup requires only editing a JSON config file — no coding involved. You can query financial data in plain English from day one. The Python examples are optional, for those who want to build automated pipelines.

Is FMP MCP available for free?

FMP offers a free tier that includes access to a solid range of endpoints — enough to test and build core workflows. Paid plans unlock higher rate limits, more historical data, and premium endpoints like institutional ownership or advanced DCF models.

What's the difference between using FMP's REST API directly vs using MCP?

The REST API requires you to write integration code: authentication, request formatting, response parsing. MCP exposes those same endpoints as tools Claude can call autonomously. For interactive workflows and natural language queries, MCP is significantly faster to set up and easier to extend.

Can I use FMP MCP with Claude Code, not just Claude Desktop?

Yes. The same MCP server configuration works with Claude Code. You can reference FMP data inside your development environment and build AI-assisted financial tooling without switching contexts.

How current is the data?

FMP provides real-time quotes with minimal delay on paid plans. Historical data, financial statements, and ratios are updated following each earnings release. For intraday trading decisions, always verify against your broker's live feed.

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

How to Get Real-Time Crypto Prices with the Mobula API in Python

Kevin Meneses González — Sun, 19 Apr 2026 10:59:42 +0000

Most crypto APIs are either too expensive, too slow, or designed for traders — not developers.

If you're:

building a portfolio tracker,
automating a DeFi monitoring bot,
or just need live onchain data without paying for an enterprise plan,

This is for you.

The Problem with Getting Crypto Data in 2026

Developers hit the same wall every time.

CoinGecko throttles free-tier requests. CoinMarketCap requires manual API key approval. Binance only covers exchange-listed tokens. And most "real-time" endpoints return data that's 60 seconds stale.

You need price. You need 24h change. You need volume. You need market cap.

What you don't need is a rate limit after 30 requests.

The real issue isn't access. It's that most crypto data APIs weren't built with developers in mind.

What Is the Mobula API?

Mobula is an onchain data API that provides structured market data — including real-time prices, volume, market cap, and liquidity — for thousands of tokens across multiple chains.

It works through a standard REST API with JSON responses.

Developers get access to:

Real-time price data (sub-second updates)
24h price change percentage
24h trading volume
Fully diluted market cap
Multi-chain token support (Ethereum, BSC, Polygon, Solana, and more)

No WebSocket setup required for basic use cases. A single HTTP GET request is enough.

Quick note: if you're a developer tool or fintech company looking for this kind of technical content — tutorials, integration guides, API comparisons — feel free to reach out on LinkedIn.

Setup: Install the Dependencies

No official SDK is needed. Mobula's API is REST-based, so requests is all you need.

pip install requests python-dotenv

Create a .env file to store your API key:

MOBULA_API_KEY=your_api_key_here

Get your free API key at mobula.io.

Example 1 — Fetch Real-Time Price for a Single Token

This is the core use case. One token, one request, live data.

import requests
import os
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("MOBULA_API_KEY")
BASE_URL = "https://api.mobula.io/api/1"

def get_token_price(symbol: str) -> dict:
    url = f"{BASE_URL}/market/data"
    params = {"symbol": symbol}
    headers = {"Authorization": API_KEY}

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

    data = response.json().get("data", {})
    return {
        "symbol": symbol.upper(),
        "price": data.get("price"),
        "price_change_24h": data.get("price_change_24h"),
        "volume_24h": data.get("volume"),
        "market_cap": data.get("market_cap"),
    }

result = get_token_price("BTC")
print(result)

Sample output:

{
  "symbol": "BTC",
  "price": 64312.47,
  "price_change_24h": 2.34,
  "volume_24h": 28450000000.0,
  "market_cap": 1264000000000.0
}

Clean. Structured. No parsing gymnastics.

Example 2 — Fetch Multiple Tokens at Once

When you're building a dashboard or tracker, you need batch data — not 10 separate requests.

def get_multiple_tokens(symbols: list[str]) -> list[dict]:
    results = []
    for symbol in symbols:
        try:
            data = get_token_price(symbol)
            results.append(data)
        except requests.HTTPError as e:
            results.append({"symbol": symbol, "error": str(e)})
    return results

tokens = ["BTC", "ETH", "SOL", "MATIC", "LINK"]
portfolio = get_multiple_tokens(tokens)

for token in portfolio:
    if "error" not in token:
        print(
            f"{token['symbol']:6} | "
            f"${token['price']:,.2f} | "
            f"{token['price_change_24h']:+.2f}% | "
            f"Vol: ${token['volume_24h']:,.0f}"
        )

Sample output:

BTC    | $64,312.47 | +2.34% | Vol: $28,450,000,000
ETH    | $3,121.88  | +1.12% | Vol: $14,200,000,000
SOL    | $148.50    | -0.78% | Vol: $3,800,000,000
MATIC  | $0.87      | +0.45% | Vol: $420,000,000
LINK   | $14.23     | +3.10% | Vol: $510,000,000

Five tokens. Five lines. Ready to pipe into a Telegram alert, a Google Sheet, or a Notion dashboard.

Example 3 — Search by Contract Address (Onchain Tokens)

Not every token has a clean ticker symbol. For newer or less-listed tokens, use the contract address instead.

def get_token_by_address(address: str, blockchain: str = "ethereum") -> dict:
    url = f"{BASE_URL}/market/data"
    params = {
        "asset": address,
        "blockchain": blockchain
    }
    headers = {"Authorization": API_KEY}

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

    data = response.json().get("data", {})
    return {
        "name": data.get("name"),
        "symbol": data.get("symbol"),
        "price": data.get("price"),
        "price_change_24h": data.get("price_change_24h"),
        "market_cap": data.get("market_cap"),
        "liquidity": data.get("liquidity"),
    }

# Example: PEPE token on Ethereum
pepe_address = "0x6982508145454Ce325dDbE47a25d4ec3d2311933"
result = get_token_by_address(pepe_address, blockchain="ethereum")
print(result)

This is where Mobula stands out from traditional exchange APIs.

Most CEX-based APIs don't index long-tail or newly launched tokens. Mobula does — because it reads directly from onchain liquidity pools.

Example 4 — Build a Simple Price Alert

Combine the fetcher with a basic threshold check. Useful for bots and automations.

import time

def price_alert_loop(symbol: str, threshold_pct: float = 5.0, interval: int = 60):
    """
    Polls the API every `interval` seconds.
    Triggers an alert if 24h change exceeds `threshold_pct`.
    """
    print(f"Monitoring {symbol} every {interval}s | Alert threshold: ±{threshold_pct}%\n")

    while True:
        try:
            data = get_token_price(symbol)
            change = data["price_change_24h"]
            price = data["price"]

            print(f"[{symbol}] ${price:,.2f} | 24h: {change:+.2f}%")

            if abs(change) >= threshold_pct:
                print(f"🚨 ALERT: {symbol} moved {change:+.2f}% in 24h — price is ${price:,.2f}")

        except Exception as e:
            print(f"Error fetching {symbol}: {e}")

        time.sleep(interval)

# Run the alert loop for ETH
price_alert_loop("ETH", threshold_pct=5.0, interval=60)

From here you can extend this into:

Telegram notifications via python-telegram-bot
Slack alerts via webhooks
n8n automations with an HTTP trigger node
Discord bots for trading communities

Mobula API — Quick Reference

Endpoint	Method	Description
`/market/data`	GET	Price, volume, market cap, 24h change
`/market/history`	GET	Historical OHLCV data
`/market/multi-data`	GET	Batch price data by symbols
`/metadata`	GET	Token metadata (logo, description, socials)

Authentication: Authorization: YOUR_API_KEY header on all requests.

Free tier includes several thousand requests/day — enough for personal projects and prototypes.

What You've Built

A working Python module that:

Fetches live price, 24h change, volume, and market cap
Handles both ticker symbols and contract addresses
Supports batch queries across any token list
Runs as a polling alert system

No SDKs. No bloated dependencies. Just requests and clean JSON.

Frequently Asked Questions

Is the Mobula API free?
Yes. Mobula offers a free tier with several thousand requests per day — enough for personal projects, prototypes, and low-frequency automations. Paid plans unlock higher rate limits, priority support, and access to premium endpoints like institutional-grade OHLCV history.

Does Mobula support tokens not listed on major exchanges?
Yes, and this is one of its key advantages. Because Mobula indexes onchain liquidity pools directly, it covers long-tail tokens and newly launched assets that CoinGecko and CoinMarketCap often lag behind on. You can query any token by contract address across supported chains.

Which blockchains does Mobula support?
As of 2026, Mobula covers Ethereum, BNB Chain, Polygon, Solana, Avalanche, Arbitrum, Base, and several other EVM-compatible chains. The /market/data endpoint accepts a blockchain parameter to scope results.

How fast is the price data?
Price updates are sub-second for major assets. For long-tail tokens with lower liquidity, refresh rates depend on onchain activity. For most use cases — dashboards, bots, alerts — the latency is negligible compared to alternatives.

Can I use Mobula in production?
Yes. The REST API is stable and versioned. For high-throughput production systems, use the /market/multi-data endpoint to batch requests and stay within rate limits. If you're building something at scale, check the paid plans for SLA guarantees.

Do I need a special library or SDK?
No. Mobula's API is standard REST — just requests in Python is enough. There's no proprietary SDK required.

Start Building with Mobula

Crypto data doesn't need to be complicated.

One endpoint, one request, one structured response — and you have everything you need to build monitoring tools, portfolio trackers, and trading automations without paying for an enterprise contract.

👉 Get your free Mobula API key here

You'll get access to:

Real-time prices across thousands of tokens
Onchain data including contract address lookup
Multi-chain support out of the box
A free tier that covers most personal and side-project use cases

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

I Asked Claude to Analyze My Portfolio. Here’s What Happened.

Kevin Meneses González — Fri, 17 Apr 2026 11:02:31 +0000

A Bloomberg Terminal costs $24,000 a year.

For that price, you get real-time market data, financial statements, earnings history, analyst estimates, and a research interface that institutional traders have used for decades.

Most developers, indie investors, and fintech builders can't justify that.

But here's what changed in 2026: you don't need Bloomberg anymore.

I connected Claude to real-time financial data using FMP's MCP server, asked it to analyze a portfolio of five stocks, and documented the entire session. No Python. No API calls. No JSON parsing.

Just questions. And real answers backed by live data.

If you're:

building AI-powered finance tools,
managing your own portfolio and tired of switching between tabs,
or just curious about what AI agents can actually do with real market data,

This is worth reading.

The Problem Nobody Talks About

Let me tell you about a conversation I had with a buy-side analyst last year.

She covers 15 companies. Every Monday morning, her routine looks like this:

Open Bloomberg, pull the weekly movers
Export to Excel, reformat the columns
Cross-reference with last quarter's earnings in a separate tab
Check FactSet for analyst revisions
Manually note any insider filings flagged in SEC EDGAR
Build a summary for the 9am team call

The whole process takes about two hours. Every week. For fifteen companies.

I asked her: "How much of that time is actual thinking versus data gathering?"

She didn't hesitate. "Maybe 20 minutes of thinking. The rest is plumbing."

That's the problem. Financial analysts aren't being paid to copy numbers between systems. They're being paid for the judgment that comes after. But most of their time gets consumed before they ever get there.

The bottleneck isn't intelligence.

It's infrastructure.

Why Data Quality Is the Foundation of Everything

Before getting into the setup, this point is worth making explicitly — because it's the one that gets glossed over in most AI + finance content.

An AI agent is only as good as the data it reasons on.

Claude can structure an argument brilliantly. It can synthesize across multiple data points, flag inconsistencies, and produce analysis that reads like a well-prepared research note. But if the underlying data is stale, incomplete, or sourced from unofficial endpoints that break under load — the output is worthless. Worse than worthless, because it looks credible.

This is why the choice of data provider matters more when you introduce AI into the equation, not less.

With a traditional workflow, an analyst can visually spot when a number looks wrong. They have the context to flag it. An AI agent acting on bad data doesn't have that safety net — it reasons confidently on whatever it's given.

FMP solves this by providing institutional-grade financial data through a clean, reliable API: 70,000+ data points, direct sourcing from exchanges and SEC filings, consistent update cycles, and full coverage across income statements, balance sheets, cash flow, earnings estimates, insider transactions, and macro indicators.

When you connect Claude to FMP via MCP, you're not connecting it to a scraper or a free feed. You're connecting it to the same underlying data infrastructure that powers serious financial tools.

That distinction changes what the AI can actually do.

The Setup: FMP + MCP + Claude in 3 Steps

FMP (Financial Modeling Prep) is a financial data API with 70,000+ data points covering everything from real-time quotes to earnings transcripts. MCP (Model Context Protocol) is the open standard introduced by Anthropic that lets AI agents connect directly to external data sources — no custom integration code, no glue scripts.

FMP now has an official MCP server. Connect it once, and Claude has direct access to FMP's entire dataset in natural language.

Here's how:

Step 1 — Get your FMP API key

Create a free account at financialmodelingprep.com. The free tier gives you 250 requests/day — enough to run all the experiments in this article.

Step 2 — Build your connection URL

https://financialmodelingprep.com/mcp?apikey=YOUR_FMP_API_KEY

Step 3 — Add it to Claude

In Claude.ai: Settings → Connectors → Add custom connector → paste the URL → name it "FMP" → Add.

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

The diagram below shows exactly how the pieces connect — from your question to the structured insight that comes back.

The Session: Real Questions, Real Data

I built a portfolio of five stocks representing different sectors and risk profiles: Apple (AAPL), NVIDIA (NVDA), JPMorgan (JPM), Pfizer (PFE), and Tesla (TSLA).

Then I started asking questions as if I were talking to an analyst.

Question 1: "Give me a quick overview of each company in my portfolio"

Claude pulled live company profiles for all five tickers simultaneously — sector, market cap, P/E ratio, 52-week range, and a one-line business description for each.

What would normally take 10 minutes of tab-switching took about 8 seconds.

The output was structured, comparable, and current. Not a cached summary from training data — actual live data from FMP's API, called in real time.

Time saved for a typical analyst: ~25 minutes per week just on the Monday morning overview pull.

Question 2: "Which of these companies has the strongest balance sheet right now?"

Claude pulled the latest balance sheets for all five companies, compared cash positions, total debt, and debt-to-equity ratios, and ranked them with a clear explanation of its reasoning.

The answer: Apple, with a net cash position that dwarfs the others. But the analysis also flagged that NVIDIA's balance sheet has strengthened considerably over the past two years, while Pfizer's debt load increased significantly post-pandemic acquisitions.

Not just numbers — interpretation.

Think about what this replaces. Pulling five balance sheets, normalizing the figures, building a comparison table, writing the summary. That's 40 minutes of work for a single analyst. Claude does it in one query.

Question 3: "Show me how earnings have trended for NVDA over the last 8 quarters"

Claude fetched NVIDIA's quarterly earnings history from FMP, organized it chronologically, and presented a clear progression of EPS and revenue growth.

It also noted the quarters where results beat analyst estimates versus where they came in below — data it pulled from FMP's analyst estimates endpoint without me asking for it.

It went further than the question asked. Because it had the tools to do so.

This is the compounding effect of quality data infrastructure. When the underlying data is complete and reliable, the AI makes connections you didn't think to ask for. When it's not, you get confident-sounding summaries built on gaps.

Question 4: "Which of these stocks has the most insider selling activity recently?"

Claude queried FMP's insider trades endpoint for all five tickers and returned a ranked summary.

The result surfaced something I hadn't thought to check: a notable cluster of executive sell transactions at one of the portfolio companies in the prior 90 days. Not necessarily a red flag — executives sell for many reasons — but exactly the kind of signal that gets buried when you're managing a portfolio manually.

For analysts covering a broader universe, systematic signal monitoring like this is the difference between catching something early and reading about it in a post-mortem.

Question 5: "If I had to cut this portfolio to 3 stocks based purely on fundamentals, which would you keep?"

Claude synthesized everything it had already pulled — balance sheets, earnings trends, analyst ratings, insider activity — and made a structured argument for three positions, with explicit reasoning for each exclusion.

It wasn't financial advice. It was structured analytical reasoning applied to real data.

This is what analysts spend hours producing for their morning call notes. With FMP + Claude, the raw material for that synthesis is assembled in seconds. The analyst's job shifts from data gathering to judgment — which is where their expertise actually lives.

Practical Use Cases for Financial Analysts

The portfolio session above is a starting point. Here's how this setup maps to real analyst workflows:

Earnings season preparation
Before a company reports, pull the last 8 quarters of EPS and revenue vs. estimates in one query. Ask Claude to identify the trend, flag any pattern of beats or misses, and summarize the setup going into the print. What used to take 30 minutes of spreadsheet work becomes a 2-minute prompt.

Peer group comparison
"Compare the operating margins of the five largest US semiconductor companies over the last 3 years." Claude queries FMP for each income statement, normalizes the figures, and returns a structured comparison. No export to Excel, no manual table building.

Macro sensitivity analysis
"How has JPM's net interest income correlated with Fed rate changes over the last 10 quarters?" FMP has both financial statements and macro indicators. Claude connects them. This kind of cross-dataset analysis typically requires a quant setup — here it's a natural language question.

Pre-meeting research brief
Heading into an earnings call or management meeting? Ask Claude to pull the company profile, recent earnings history, analyst consensus, and notable insider activity, structured as a one-page brief. Five minutes instead of forty-five.

Watchlist monitoring
Set up a weekly prompt that pulls the latest price, P/E, and analyst rating changes for your entire coverage list. Claude flags what moved, what changed in estimates, and what warrants a closer look. The cognitive overhead of monitoring 20 names drops dramatically.

What This Actually Means

Most AI tools work with static knowledge. They know what they learned during training — with a cutoff date and no access to real-time data.

FMP's MCP server changes that equation.

Claude connected to FMP doesn't hallucinate earnings numbers. It fetches them. It doesn't estimate balance sheet ratios. It calculates them from live statements. It doesn't guess at analyst consensus. It reads it directly from FMP's database.

The result is an AI that reasons about markets the way a well-prepared analyst would — with access to the same raw data, applied in real time, in natural language.

For developers, this removes weeks of integration work. For investors, it removes the cognitive overhead of data aggregation. For fintech teams, it collapses the distance between idea and working demo.

And for analysts — it gives back the two hours every Monday that were going to plumbing.

Getting Started with FMP

FMP's free tier covers 250 API requests per day — enough to replicate everything in this article. Paid plans unlock higher limits, real-time data, and premium endpoints like earnings transcripts and institutional holdings.

👉 Start free on FMP here

Connection URL once you have your key:

https://financialmodelingprep.com/mcp?apikey=YOUR_FMP_API_KEY

Settings → Connectors → Add custom connector. Two minutes. No code.

What You Can Build From Here

From here you can build:

automated weekly portfolio reviews that pull fresh data every Monday
earnings surprise trackers that flag when actual EPS deviates significantly from estimates
sector rotation monitors comparing relative performance across holdings
custom screening sessions where you describe criteria and Claude queries FMP for matches
pre-earnings research briefs assembled in minutes, not hours

The infrastructure is already there. The data is live. The interface is natural language.

Most analysts don't need a better instinct for markets.

They need to stop spending 80% of their time on plumbing — and start spending it on the 20% that actually matters.

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

Top 5 Crowdlending Platforms in Europe (2026): Where to Invest Your Money

Kevin Meneses González — Thu, 16 Apr 2026 08:29:27 +0000

Most people still believe generating passive income requires either a lot of capital or accepting a lot of risk.

Crowdlending breaks that assumption.

If you're:

tired of savings accounts paying 1–2% while inflation erodes your balance,
looking for fixed-income alternatives outside volatile stock markets,
or building a diversified portfolio that generates monthly cash flow,

This matters.

The European P2P lending sector has matured significantly. Regulation is catching up. Platforms are getting stricter about borrower selection. And the gap in quality between good platforms and bad ones is now very clear.

Here's a curated comparison of the five platforms worth your attention in 2026 — with a breakdown of what each one does well and where it falls short.

The Criteria

Before getting into the list, the comparison uses five dimensions:

Expected returns (annual yield, realistic range)
Risk protection (buyback guarantee, collateral, provision fund)
Regulation (licensing, jurisdiction, compliance framework)
Usability (minimum investment, auto-invest, secondary market)
Track record (default history, transparency, audits)

No platform is perfect. The goal is to understand the trade-offs.

1. Maclear — The Structured SME Platform from Switzerland

Maclear isn't the biggest name in European crowdlending. It's the most serious one.

Founded in Switzerland and operating as a P2B (peer-to-business) marketplace, Maclear connects investors with EU-based SMEs seeking capital for real industrial and commercial projects — manufacturing, logistics, retail, renewable energy. Not consumer loans. Not payday debt.

That distinction matters.

Returns: 13.5% to 16.5% annually, with monthly interest payments and no cash drag reported by investors.

Risk protection:

Provision Fund financed by 2% of every funded project
Collateral on every loan (equipment, assets, property)
Maclear acts as Collateral Agent, meaning it can legally enforce recovery on behalf of investors — not just hand you paperwork
More than 60% of loan applications are rejected before reaching the platform
One default recorded to date, resolved with full principal recovery

Regulation: Member of PolyReg SRO (Switzerland), with European crowdfunding license application filed. The platform is registered in the official Swiss company registry and has published a 2023 financial audit.

Usability: €50 minimum investment. AutoInvest launched in July 2025. Secondary market available. No deposit fees. KYC in approximately 5 minutes.

Track record: Growing at 6M€ per month invested as of early 2026. Surpassed platforms like Swaper in total registered users. No missed investor payments on record.

Pros

Real collateral behind every loan — not just a buyback promise from the same originator issuing the loan
Swiss regulatory framework adds structural credibility
Transparent project pages with financial scoring, business plans, and collateral details
Loyalty program with bonus rates on top of standard returns

Cons

Smaller loan supply than volume-driven marketplaces like Mintos
2024 financial audit delayed (expected Q1 2026)
Fewer projects available simultaneously compared to larger platforms

Best for: Investors who want structured protection, not just high numbers on a screen.

Disclosure: this article contains an affiliate link for Maclear. If you sign up through this link, you receive a 2% cashback bonus on investments in your first 90 days — at no extra cost.

2. Mintos — The European Giant

Mintos is the largest P2P lending marketplace in Europe. That's both its main argument and its main risk.

With over €10 billion in funded loans, 340,000+ investors, and access to 50+ loan originators across multiple countries, Mintos delivers diversification at a scale no other platform matches. The auto-invest tool is robust. The secondary market is active. The reporting is detailed.

The problem: you're not lending directly to borrowers. You're buying Notes issued by loan originators. If an originator fails, the Notes can go into recovery — which has happened before.

Returns: 10–12.25% average annually.

Risk protection: Buyback guarantee on most loans, but dependent on originator solvency. Regulated investment firm license in Latvia. Mintos Ratings system for originator assessment.

Pros

Unmatched diversification — dozens of originators, multiple countries, multiple loan types
Regulated platform with structured Notes product
Active secondary market for liquidity
Includes ETFs and bonds alongside loans

Cons

Originator defaults have happened — the buyback is only as solid as the originator
Complexity can overwhelm new investors
Auto-invest setup requires careful configuration to avoid concentration risk

Best for: Experienced investors building a large, diversified P2P portfolio.

3. PeerBerry — Reliability Over Everything

PeerBerry doesn't chase headlines. It has maintained a zero historical capital loss record since launching in 2017, and that consistency is its entire pitch.

Average return sits around 11.14%. Buyback guarantee on all loans, backed by a group guarantee from the Aventus Group — which paid back over €50 million in war-affected loans during the Russia-Ukraine conflict. That single data point explains why PeerBerry retains its investor base.

Returns: 10–12% annually.

Risk protection: 60-day buyback guarantee + group guarantee from Aventus Group. No capital losses recorded.

Pros

Zero historical capital loss
Group guarantee from a financially solid originator group
Clean, simple interface — low learning curve
No fees on deposits, withdrawals, or investing
Loyalty bonus program for larger portfolios

Cons

Loan supply occasionally insufficient for investor demand (cash drag possible)
No secondary market for early exits
Platform is unregulated
High concentration in Aventus Group loans

Best for: Conservative investors who prioritize reliability and a proven track record.

4. Esketit — Consumer Loans, High Efficiency

Esketit is the clean-room option for consumer loan investors. Backed by the AvaFin Group (formerly known as Creamfinance), the platform offers 12% average returns with 60-day buyback guarantees and a group guarantee layer on top.

The secondary market has no fees. Minimum investment is €10. Auto-invest is functional and easy to configure.

The trade-off is concentration: most loans come from a single originator group. That's efficient until it isn't.

Returns: 10–14% annually.

Risk protection: 60-day buyback guarantee + AvaFin Group guarantee. Low historical default rates.

Pros

Consistently high Trustpilot rating
Group guarantee adds a second protection layer
Secondary market with zero fees
€10 minimum — accessible for very small portfolios
Backed by an originator with 10+ years of experience

Cons

No regulatory license (unregulated platform)
Strong originator concentration — almost all loans are AvaFin-originated
Exposure to consumer loan risk, which behaves differently from SME/collateralized loans

Best for: Investors focused on short-term consumer loans who want simplicity and solid buyback protection.

5. Bondora Go & Grow — Passive Income with Daily Liquidity

Bondora belongs in this list for a different reason than the others. It's not the highest yield. It's the simplest entry point.

Go & Grow offers 6% annually with daily liquidity. You deposit money, it earns 6%, you withdraw whenever you want. No loan selection. No configuration. No complexity.

For someone who wants to park savings at returns above a bank account without thinking about originators, collateral, or buyback mechanics — Bondora is the answer.

Returns: 6% fixed annually.

Risk protection: Regulated in Estonia. No buyback guarantee — Bondora manages the portfolio internally. Investors do not see underlying loans.

Pros

Daily liquidity (rare in crowdlending)
Fully automated — zero management required
Regulated, experienced platform (founded 2008)
Minimum €1 investment

Cons

6% is significantly below what structured platforms like Maclear or Mintos offer
No visibility into underlying loans
Not suitable for investors seeking higher yields or active control

Best for: Beginners or investors who want passive savings above bank rates with instant access to funds.

Side-by-Side Comparison

Platform	Annual Return	Protection Type	Min. Investment	Regulation	Secondary Market
Maclear	13.5–16.5%	Collateral + Provision Fund	€50	Swiss (PolyReg SRO)	✅ Yes
Mintos	10–12.25%	Buyback (originator-dependent)	€50	Latvia (FCMC)	✅ Yes
PeerBerry	10–12%	Buyback + Group Guarantee	€10	Unregulated	❌ No
Esketit	10–14%	Buyback + Group Guarantee	€10	Unregulated	✅ Yes
Bondora G&G	6% fixed	Internal management	€1	Estonia (FSA)	❌ N/A

Why Maclear Ranks First

Most crowdlending platforms offer the same structure: a buyback guarantee backed by the same originator that issued the loan.

That structure has a well-known weakness. If the originator runs into financial trouble, the buyback promise becomes difficult to honor. It's not necessarily fraud — it's counterparty risk that investors often don't fully price in until a problem surfaces.

Maclear is structured differently.

Every loan is backed by real collateral — physical assets that exist regardless of whether the originator is solvent. And because Maclear acts as Collateral Agent, it can enforce recovery on behalf of investors independently, without waiting for borrower cooperation.

The Provision Fund, the 60%+ rejection rate on applications, the Swiss regulatory environment, and zero missed investor payments to date all point in the same direction: a platform designed with downside scenarios in mind, not just upside marketing.

That's not a guarantee of future performance. No platform is. But it's a meaningfully different risk architecture than what most alternatives offer.

If you want to explore it, you can open an account here — new investors get a 2% cashback bonus for the first 90 days.

Frequently Asked Questions

Is crowdlending safe?
No investment is risk-free, and crowdlending is no exception. The key variables are platform structure, borrower vetting, and what happens when a loan defaults. Platforms backed by real collateral (like Maclear) offer a different risk profile than those relying solely on buyback guarantees from loan originators — where the guarantee is only as solid as the originator's solvency.

What returns can I realistically expect from crowdlending?
Conservative platforms like Bondora's Go & Grow offer 6% with high liquidity. Mid-range platforms like PeerBerry and Mintos average 10–12%. Structured SME platforms like Maclear offer 13.5–16.5%, reflecting a more selective borrower pool and collateral-backed structure. Always distinguish between the stated rate and the risk-adjusted return.

What is the difference between P2P lending and P2B lending?
P2P (peer-to-peer) typically refers to lending to individual consumers. P2B (peer-to-business) refers to lending to companies — usually SMEs. P2B platforms like Maclear focus on business projects with defined collateral, which tends to offer more structured risk management than consumer loans.

What happens if a borrower defaults on Maclear?
Maclear acts as Collateral Agent for all loans. In the event of a default, the platform initiates recovery independently on behalf of investors — enforcing collateral rights and managing the legal process. The one default recorded on the platform to date resulted in full principal recovery for investors.

Can I withdraw my money early?
On Maclear, investors can sell loan positions on the secondary market before maturity. Liquidity depends on buyer availability, but the option exists. Platforms like Bondora Go & Grow offer daily liquidity. PeerBerry does not have a secondary market.

What is a Provision Fund?
A Provision Fund is a reserve of capital set aside to cover investor losses in the event of a default. On Maclear, it is funded by transferring 2% of every funded project directly to the fund. It acts as a buffer that operates independently from the borrower — providing an additional protection layer on top of collateral.

Is Maclear regulated?
Maclear is registered in Switzerland and is a member of PolyReg SRO, which requires compliance with Swiss AML regulations. The platform has applied for the European Crowdfunding Service Provider (ECSP) license. It is not yet licensed as an ECSP but operates under Swiss financial oversight — a stronger regulatory environment than many competing platforms registered in less scrutinized jurisdictions.

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

Top 5 Claude Code Skills for Algorithmic Trading

Kevin Meneses González — Wed, 15 Apr 2026 11:04:20 +0000

Most traders think the bottleneck is strategy.

It's not.

The bottleneck is the time between "I have an idea" and "this is running in production." Writing boilerplate, wiring APIs, debugging vectorbt errors at 2am. That's where most strategies die.

If you're:

building systematic trading systems in Python,
testing technical indicators before deploying real capital,
or trying to compress weeks of quant work into days,

This matters.

Claude Code isn't the chatbot. It's an agentic environment that runs in your terminal, reads your files, and executes code on your machine. For algorithmic trading, that changes what's possible.

The real power comes from skills — SKILL.md files that function as instruction sets, telling Claude exactly how to approach a specific task. Think of them as recipes: step-by-step workflows Claude follows automatically when the task matches. Install one, and Claude transforms into a specialist for that domain.

Here are 5 skills from public repositories that make Claude Code genuinely useful for trading — with the install commands, the recipes inside, and working Python code using EODHD for market data.

1. Backtesting Expert — Systematic Strategy Testing

Source: tradermonty/claude-trading-skills · ⭐ 16

git clone https://github.com/tradermonty/claude-trading-skills.git
cp -r claude-trading-skills/skills/backtest-expert ~/.claude/skills/

This skill turns Claude Code into a dedicated backtesting analyst. The SKILL.md recipe instructs Claude to follow a structured workflow every time you describe a strategy:

SKILL RECIPE (backtest-expert):
1. Confirm strategy rules and parameters
2. Fetch historical OHLCV data for the specified symbol and period
3. Compute indicator(s) from scratch — no library black boxes
4. Generate entry/exit signals with explicit conditions
5. Run a vectorized backtest: returns, Sharpe, max drawdown, win rate
6. Output equity curve + summary table
7. Flag overfitting risks if in-sample window < 2 years

In practice, you describe your idea in plain English. Claude follows the recipe.

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"

# Fetch EOD historical prices via EODHD REST API
url = f"https://eodhd.com/api/eod/AAPL.US"
params = {
    "api_token": API_KEY,
    "from": "2022-01-01",
    "to": "2024-12-31",
    "period": "d",
    "fmt": "json"
}
data = requests.get(url, params=params).json()
df = pd.DataFrame(data)[["date", "adjusted_close", "volume"]]
df["date"] = pd.to_datetime(df["date"])
df.set_index("date", inplace=True)
df.columns = ["close", "volume"]

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

# Signals
df["signal"] = 0
df.loc[df["rsi"] < 30, "signal"] =  1  # buy
df.loc[df["rsi"] > 70, "signal"] = -1  # sell

# Vectorized strategy returns
df["returns"]  = df["close"].pct_change()
df["strategy"] = df["signal"].shift(1) * df["returns"]

sharpe = df["strategy"].mean() / df["strategy"].std() * np.sqrt(252)
total  = (1 + df["strategy"]).prod() - 1
print(f"Sharpe: {sharpe:.2f} | Total return: {total:.2%}")

From here you can build: walk-forward validation loops, multi-ticker screeners, parameter sensitivity grids.

Pros

Structured workflow prevents skipping the overfitting check
Forces explicit signal logic — no implicit library assumptions

Cons

Requires a clear strategy description upfront; vague inputs produce generic backtests

Best for: Quants who test 5–10 strategy variants per week and need reproducible, comparable results across all of them.

2. Market Data Pipeline — EODHD Integration

Source: JoelLewis/finance_skills · trading-operations plugin

npx skills add JoelLewis/finance_skills --plugin trading-operations

This skill handles the full data ingestion layer. Its recipe standardizes how Claude fetches and structures market data — EOD prices, intraday bars, fundamentals, and real-time quotes — from a single provider.

SKILL RECIPE (market-data-pipeline):
1. Identify data type needed: EOD / intraday / fundamentals / real-time
2. Select the correct EODHD endpoint for that data type
3. Build the request with proper params (symbol format, date range, interval)
4. Normalize response to a DataFrame with standard column names
5. Apply corporate-action adjustments for historical price analysis
6. Cache the result to avoid redundant API calls in the same session
7. Return the DataFrame ready for indicator computation

Bad data is the silent killer of backtests. Survivorship bias, unadjusted prices, missing corporate actions — these don't throw errors. They just make your strategy look better than it is.

import requests
import pandas as pd

API_KEY = "YOUR_EODHD_KEY"

def fetch_eod(symbol: str, start: str, end: str) -> pd.DataFrame:
    r = requests.get(
        f"https://eodhd.com/api/eod/{symbol}",
        params={"api_token": API_KEY, "from": start, "to": end, "period": "d", "fmt": "json"}
    )
    df = pd.DataFrame(r.json())
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date")[["open", "high", "low", "close", "adjusted_close", "volume"]]

def fetch_intraday(symbol: str, interval: str = "1m") -> pd.DataFrame:
    r = requests.get(
        f"https://eodhd.com/api/intraday/{symbol}",
        params={"api_token": API_KEY, "interval": interval, "fmt": "json"}
    )
    df = pd.DataFrame(r.json())
    df["datetime"] = pd.to_datetime(df["datetime"])
    return df.set_index("datetime")[["open", "high", "low", "close", "volume"]]

def fetch_fundamentals(symbol: str) -> dict:
    r = requests.get(
        f"https://eodhd.com/api/fundamentals/{symbol}",
        params={"api_token": API_KEY, "fmt": "json"}
    )
    return r.json()

# Usage
aapl     = fetch_eod("AAPL.US", "2023-01-01", "2024-12-31")
fund     = fetch_fundamentals("AAPL.US")
eps      = fund["Highlights"]["EPS"]
print(f"EPS: {eps} | Latest adjusted close: ${aapl['adjusted_close'].iloc[-1]:.2f}")

EODHD covers 70+ exchanges worldwide — US equities, ETFs, forex, crypto — with corporate-action-adjusted prices and a free tier for prototyping.

👉 Get started with EODHD and get 10% off any paid plan: eodhd.com

Pros

Adjusted EOD + intraday (1-minute) + fundamentals + real-time from a single API
Free tier available; paid plans from €19.99/mo

Cons

Real-time non-delayed quotes require a paid plan

Best for: Anyone building a serious backtesting or live system who needs institutional-quality data at indie-developer prices.

3. Signal Generator — Strategy Logic to Executable Code

Source: ScientiaCapital/skills · active/signal-generation

git clone https://github.com/scientiacapital/skills.git
cp -r skills/active/signal-generation ~/.claude/skills/

You have a strategy. It lives in your head, in a research note, or in a TradingView Pine Script. You need it as clean, vectorized Python. This skill handles the translation.

SKILL RECIPE (signal-generation):
1. Parse strategy rules from natural language into explicit conditions
2. Map each condition to a pandas/numpy operation
3. Compute indicators using vectorized operations (no row-by-row loops)
4. Build entry and exit Series separately
5. Apply time-of-day or session filters if specified
6. Output DataFrame: [close, *indicators, signal, position]
7. Verify: no lookahead bias (all indicators shifted before signal comparison)

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"

r = requests.get(
    "https://eodhd.com/api/eod/TSLA.US",
    params={"api_token": API_KEY, "from": "2023-01-01", "to": "2024-12-31", "period": "d", "fmt": "json"}
)
df = pd.DataFrame(r.json())
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")[["high", "low", "adjusted_close"]].rename(columns={"adjusted_close": "close"})

# EMA crossover + ADX filter — no TA-Lib
def ema(s, n):
    return s.ewm(span=n, adjust=False).mean()

def compute_adx(df, n=14):
    tr = pd.concat([
        df["high"] - df["low"],
        (df["high"] - df["close"].shift()).abs(),
        (df["low"]  - df["close"].shift()).abs()
    ], axis=1).max(axis=1)
    dm_pos = (df["high"] - df["high"].shift()).clip(lower=0)
    dm_neg = (df["low"].shift() - df["low"]).clip(lower=0)
    atr    = tr.ewm(span=n, adjust=False).mean()
    di_pos = 100 * dm_pos.ewm(span=n, adjust=False).mean() / atr
    di_neg = 100 * dm_neg.ewm(span=n, adjust=False).mean() / atr
    dx     = (100 * (di_pos - di_neg).abs() / (di_pos + di_neg))
    return dx.ewm(span=n, adjust=False).mean()

df["ema20"] = ema(df["close"], 20)
df["ema50"] = ema(df["close"], 50)
df["adx"]   = compute_adx(df)

cross_up     = (df["ema20"] > df["ema50"]) & (df["ema20"].shift() <= df["ema50"].shift())
adx_confirmed = df["adx"] > 25
df["signal"] = (cross_up & adx_confirmed).astype(int)

print(df[df["signal"] == 1][["close", "ema20", "ema50", "adx"]].tail())

Pros

Lookahead-bias check is baked into the recipe — Claude flags it before delivering code
Produces vectorized pandas operations: production-ready, not tutorial code

Cons

Always validate signal logic manually before connecting to live capital

Best for: Traders who think in strategy rules and want Claude to handle the Python translation.

4. Risk Manager — Position Sizing and Exposure Control

Source: JoelLewis/finance_skills · wealth-management plugin (risk-measurement skill)

npx skills add JoelLewis/finance_skills --plugin wealth-management

Strategy without risk management is speculation with extra steps. This skill gives Claude a structured decision framework for every sizing and exposure calculation.

SKILL RECIPE (risk-management):
1. Calculate ATR-based stop distance for the current setup
2. Apply fixed-fractional sizing (default: 1% account risk per trade)
3. Check portfolio heat: flag if total exposure > 5% of equity
4. Compute Historical VaR (95% confidence) on the current portfolio
5. Output: entry, stop, shares, dollar risk, R-multiple target
6. Define kill-switch threshold: halt new entries if drawdown > X%

import requests
import pandas as pd
import numpy as np

API_KEY = "YOUR_EODHD_KEY"

r = requests.get(
    "https://eodhd.com/api/eod/AAPL.US",
    params={"api_token": API_KEY, "from": "2024-10-01", "to": "2024-12-31", "period": "d", "fmt": "json"}
)
df = pd.DataFrame(r.json())
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date")[["high", "low", "adjusted_close"]].rename(columns={"adjusted_close": "close"})

# ATR (14-period)
tr  = pd.concat([
    df["high"] - df["low"],
    (df["high"] - df["close"].shift()).abs(),
    (df["low"]  - df["close"].shift()).abs()
], axis=1).max(axis=1)
atr = tr.ewm(span=14, adjust=False).mean().iloc[-1]

def size_position(equity, risk_pct, entry, stop):
    risk_per_share = abs(entry - stop)
    if risk_per_share == 0:
        return 0
    return int((equity * risk_pct / 100) / risk_per_share)

equity      = 10_000
entry_price = df["close"].iloc[-1]
stop_price  = entry_price - (2 * atr)
shares      = size_position(equity, 1.0, entry_price, stop_price)

print(f"Entry:         ${entry_price:.2f}")
print(f"Stop (2×ATR):  ${stop_price:.2f}  |  ATR: ${atr:.2f}")
print(f"Position size: {shares} shares")
print(f"Dollar risk:   ${shares * abs(entry_price - stop_price):.2f}")

Pros

Generates reusable, parameterized modules — not hardcoded values per trade
Recipe includes portfolio heat check alongside per-trade sizing

Cons

Sizing models require human review — Claude won't know your personal drawdown tolerance

Best for: Systematic traders running multiple strategies simultaneously who need a consistent, auditable risk framework.

5. Live Signal Monitor — Real-Time Alerts

Source: roman-rr/trading-skills · trading-signals skill

git clone https://github.com/roman-rr/trading-skills.git
cp -r trading-skills/trading-signals ~/.claude/skills/

The final skill closes the loop from research to live monitoring. Instead of running backtests, you're watching for signals in real time and triggering alerts when conditions are met.

SKILL RECIPE (live-signal-monitor):
1. Fetch real-time quote and recent EOD bars via EODHD REST API
2. Maintain a rolling window of bars in memory
3. Recompute indicator(s) on each new bar
4. Evaluate signal conditions — entry, exit, or hold
5. On signal trigger: log timestamp, symbol, price, indicator values
6. Send alert (print / Telegram / email)
7. Never execute orders directly — output signal only

import requests
import pandas as pd
import numpy as np
import time
from datetime import datetime

API_KEY = "YOUR_EODHD_KEY"

def fetch_live_quote(symbol: str) -> float:
    r = requests.get(
        f"https://eodhd.com/api/real-time/{symbol}",
        params={"api_token": API_KEY, "fmt": "json"}
    )
    return r.json().get("close", None)

def fetch_recent_eod(symbol: str, n: int = 30) -> pd.Series:
    r = requests.get(
        f"https://eodhd.com/api/eod/{symbol}",
        params={"api_token": API_KEY, "period": "d", "fmt": "json"}
    )
    df = pd.DataFrame(r.json()).tail(n)
    df["date"] = pd.to_datetime(df["date"])
    return df.set_index("date")["adjusted_close"].rename("close")

def compute_rsi(series, n=14):
    delta = series.diff()
    gain  = delta.clip(lower=0).rolling(n).mean()
    loss  = -delta.clip(upper=0).rolling(n).mean()
    return 100 - (100 / (1 + gain / loss))

symbol = "AAPL.US"
print(f"Monitoring {symbol} | {datetime.now():%Y-%m-%d %H:%M}")

while True:
    close_series = fetch_recent_eod(symbol, n=30)
    live_price   = fetch_live_quote(symbol) or close_series.iloc[-1]

    # Append live price as today's bar
    today = pd.Timestamp.now().normalize()
    close_series[today] = live_price

    rsi    = compute_rsi(close_series).iloc[-1]
    status = "OVERSOLD → BUY WATCH" if rsi < 30 else "OVERBOUGHT → SELL WATCH" if rsi > 70 else "NEUTRAL"

    print(f"[{datetime.now():%H:%M:%S}] {symbol} | ${live_price:.2f} | RSI: {rsi:.1f} | {status}")

    if rsi < 30:
        print(f"  🔔 ALERT: RSI oversold at {rsi:.1f} — review entry")

    time.sleep(60)

Pair this with a Telegram bot and you have automated signal detection running 24/7 — no manual chart watching.

👉 Get started with EODHD and unlock 10% off any paid plan: eodhd.com

Pros

Polling approach works with the free EODHD tier — no WebSocket subscription required
Skill enforces the signal/execution separation — no accidental live orders

Cons

60-second polling isn't suitable for sub-minute strategies (use EODHD's WebSocket feed for those)

Best for: Swing and intraday traders who want automated signal detection without building a full execution system.

The shift

Claude Code skills aren't magic. They're structured recipes that eliminate the "figure it out from scratch" tax on every new project.

Five skills. One reliable data layer. The bottleneck shifts from implementation to what it should always have been: deciding which strategies are worth testing.

Most quants don't lack ideas. They lack the bandwidth to implement fast enough to find the ones that actually work.

That's what changes.

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

5 Best Onchain Data APIs for Developers in 2026

Kevin Meneses González — Tue, 14 Apr 2026 08:38:42 +0000

Most developers underestimate the data problem until it's too late.

You've built the logic. The strategy is solid. The architecture makes sense. Then you connect a price feed and realize it's cached. Or that the token you need isn't listed. Or that you're paying $99/month for a provider that covers 80% of what you actually need — and the missing 20% is exactly the part that matters.

The onchain data layer is where crypto products quietly break.

If you're:

building a trading bot that needs to react in seconds, not minutes,
designing a wallet dashboard that tracks PnL across multiple chains,
or shipping a DeFi tool that depends on newly listed tokens,

the provider you choose will define how far you can go before hitting a wall.

The problem isn't that good APIs don't exist. The problem is that most comparisons treat them as interchangeable — as if "blockchain data API" means the same thing regardless of what you're building.

It doesn't.

An indexer optimized for historical compliance data is a completely different product from a real-time trading infrastructure layer. A decentralized protocol built for protocol-specific subgraphs solves a different problem than a multi-chain wallet analytics API. Choosing the wrong one doesn't mean your product fails immediately — it means you hit the ceiling at exactly the wrong moment.

This guide cuts through that.

We compare five of the best onchain data APIs available to developers in 2026 — Mobula, Moralis, Bitquery, The Graph, and GoldRush (Covalent) — focusing on features, data coverage, pricing, free tiers, and what each one is actually built for.

By the end, you'll know which one fits your stack.

Overview of the Top 5 Onchain Data API Providers

1. Mobula — Real-Time Onchain Data + Execution in One Platform

Platform: mobula.io

Mobula is the only provider on this list that combines a real-time data layer with a built-in execution layer. You can fetch live prices, stream wallet activity, and route onchain swaps through the same API — no second provider needed.

At the core is the Octopus engine: a multi-chain, composable pricing system that aggregates prices using volume weighting and liquidity ponderation directly from DEX pools. It covers everything from Bitcoin and Ethereum down to tokens listed on obscure DEXs in the last hour, with prices refreshing every 5 seconds and no caching on any tier — including free.

Data Coverage and Features

Mobula's API surface is wide. The platform exposes 50+ REST endpoints and 10+ real-time WebSocket streams, covering:

Live token prices, 24h change, volume, and market cap for any asset on any supported chain
OHLCV historical data for backtesting and charting
Wallet portfolio analytics: balances, historical PnL, DeFi positions, NFT holdings, and wallet labels across chains
Pair-level and pool-level data: trades, liquidity, pool creation, newly listed tokens
Token security checks and holder distribution
Execution layer: swap quotes and onchain trade routing via a single API call

All of this is accessible via REST, WebSocket streams, a TypeScript SDK, and a GraphQL interface. The team responds to support queries in under an hour across Telegram, Slack, and Discord.

Beyond standard data retrieval, the Octopus engine specifically handles what most providers fail at: long-tail tokens. New listings on any DEX, low-liquidity assets, freshly deployed contracts — the engine picks them up as soon as they have trading activity.

Chain Coverage

Ethereum, Solana, BNB Chain, Base, Arbitrum, Optimism, Polygon, Avalanche, and many others. Multi-chain wallet queries aggregate across all supported networks in a single call.

Pricing and Limits

Mobula offers a free API key with immediate access to the full endpoint suite, including no-cache pricing. No credit card required to start.

Paid plans scale with usage through the Mobula dashboard, priced by request volume rather than a flat monthly subscription. For teams running lean bots or early-stage apps, this model is significantly more cost-efficient than paying $49–$99/month flat. Enterprise and custom plans available via Telegram or email.

Pros

No-cache 5-second price refresh on all tiers, including free
Data + execution in one API — fetch price and route the swap without switching providers
Broadest long-tail token coverage via the Octopus aggregation engine
Full wallet analytics: PnL, DeFi positions, NFT holdings, wallet labels
REST + WebSocket + TypeScript SDK + GraphQL — developer-first from day one
Sub-1h support response time

Cons

Requires coding — no visual interface or no-code builder
Execution layer is newer than the data layer
Smaller community than Moralis or The Graph

Best for: Developers building trading bots, price aggregators, wallet dashboards, or any product that needs real-time onchain data and the ability to act on it — from a single provider.

👉 Get your free Mobula API key

2. Moralis — Enterprise-Grade Web3 Backend Infrastructure

Platform: moralis.com

Moralis is the most complete Web3 backend platform on this list. It started as a Firebase-for-blockchain and has evolved into a full-stack data infrastructure layer trusted by MetaMask, Blockchain.com, and hundreds of production applications processing billions of API requests per month.

Data Coverage and Features

The platform covers multiple distinct product lines:

Data APIs: token prices, wallet history, NFT metadata, DeFi positions, token holders, swap data
Streams API: real-time blockchain event monitoring for any wallet, contract, or address — with a 100% delivery guarantee and webhook delivery
Datashare: bulk export of blockchain datasets to Snowflake, BigQuery, and S3 for data warehousing and AI pipelines
Cortex API: an AI-native, LLM-ready crypto data layer for building onchain AI agents

Moralis uses a Compute Units (CUs) pricing model. Every API request consumes a different number of CUs depending on complexity — a simple token balance check costs fewer CUs than a multi-chain portfolio aggregation.

The Streams API deserves special attention. If your product needs to react the moment a wallet receives a token, a smart contract emits an event, or a liquidation threshold is crossed — Moralis Streams handles it reliably at scale with a 100% delivery guarantee.

Chain Coverage

Ethereum, Solana, BNB Chain, Base, Polygon, Avalanche, Arbitrum, Optimism, and many more EVM-compatible chains.

Pricing and Limits

Moralis offers a free Starter plan with limited CUs per month. Paid plans start at approximately $49/month and scale to $199/month for higher CU allowances, premium endpoints, and auto-scaling. Enterprise plans with SOC 2 Type II compliance and ISO 27001 certification are available.

Pros

Streams API: 100% delivery guarantee for real-time event monitoring
Broadest EVM + Solana coverage among enterprise providers
SOC 2 Type II and ISO 27001 certified
Cortex AI layer for LLM-ready data pipelines
Trusted by MetaMask, Blockchain.com, and other large-scale apps

Cons

CU pricing can be unpredictable for complex or high-frequency workloads
No built-in execution layer — data only
Higher entry price for serious production use

Best for: Teams building production-grade dApps, portfolio trackers, AI agents, or compliance tools that need enterprise reliability and event-driven architecture.

3. Bitquery — Deep Blockchain Analytics via GraphQL and Kafka

Platform: bitquery.io

Bitquery is the go-to choice when you need granular, custom queries across 40+ blockchains. Its GraphQL API lets you filter, aggregate, and stream data at a depth that REST-based APIs simply don't expose. Since July 2025 it also offers a dedicated multi-chain Price Index API and Kafka streams for ultra-high-throughput pipelines.

Data Coverage and Features

Using its GraphQL interface, developers can query:

Real-time and historical DEX trade data across all supported chains
Token prices via the Price Index: OHLCV, SMA, WMA, EMA, cross-chain and cross-DEX aggregations at 1-second granularity
Wallet transactions, token transfers, internal calls, and failed transactions
Mempool data — useful for MEV detection, front-running analysis, and liquidation bots
NFT trades, smart contract events, and protocol-level analytics
Kafka streams and WebSocket subscriptions

Chain Coverage

40+ chains including Ethereum, BNB Chain, Solana, Polygon, Arbitrum, Bitcoin (non-EVM), and Tron.

Pricing and Limits

Bitquery uses a points-based pricing system where queries consume points based on infrastructure resource usage. A free community tier is available for development and light use. Paid plans are usage-based and customized through the sales team — no publicly listed flat-rate tiers for production.

Pros

40+ chains including non-EVM networks like Bitcoin
1-second price granularity via Kafka streams
Mempool data access — rare among providers, critical for MEV research
Extremely flexible querying: aggregations, filters, cross-chain joins in one call
OHLCV + SMA + WMA + EMA pre-calculated in the Price Index

Cons

Steep GraphQL learning curve — not beginner-friendly
Pricing is opaque: no clear public flat-rate tiers, requires sales contact
No execution layer

Best for: Blockchain analytics, MEV research, algorithmic trading requiring tick-level data, compliance tools, and deeply customized cross-chain queries.

4. The Graph — Decentralized Indexing Protocol

Platform: thegraph.com

The Graph takes a fundamentally different architectural approach. Rather than a centralized API, it's a decentralized protocol where developers deploy subgraphs — custom indexing schemas tied to specific smart contracts. Query fees are paid in GRT tokens to a network of indexers.

Data Coverage and Features

The value of The Graph depends on what subgraphs already exist. For major DeFi protocols — Uniswap, Aave, Compound, Curve, Balancer — there are well-maintained, community-curated subgraphs that deliver highly efficient, protocol-specific data.

For anything outside supported protocols, developers must build their own subgraph: define a schema, write mapping logic in AssemblyScript, deploy to the decentralized network. Significant setup overhead.

Chain Coverage

Primarily EVM chains: Ethereum, Arbitrum, Optimism, Polygon, Base, Avalanche, Gnosis, and others.

Pricing and Limits

The Graph uses a token-economic model where consumers pay GRT for queries. No flat monthly fee — costs scale directly with usage. The Graph Foundation offers grants and subsidies for education and public good infrastructure projects.

Pros

Censorship-resistant and decentralized — no vendor dependency
Highly efficient for protocol-specific indexed data
Large library of existing subgraphs for major DeFi protocols
Open source — full visibility into data pipelines
No vendor lock-in

Cons

Significant setup overhead for custom subgraphs
Not suitable for real-time arbitrary token price feeds
No wallet-level analytics or cross-protocol coverage out of the box
GRT costs are less predictable than flat subscriptions
No execution layer

Best for: dApp developers building on specific, well-supported DeFi protocols who need reliable, decentralized, protocol-specific indexed data.

5. GoldRush (Covalent) — Historical Depth Across 100+ Chains

Platform: goldrush.dev

GoldRush, the rebranded product from Covalent, specializes in structured historical onchain data with a clean, standardized REST interface. It covers 100+ blockchains — the broadest chain support of any provider on this list — and delivers every endpoint in a consistent schema, making it fast to integrate and easy to switch chains without rewriting queries.

Data Coverage and Features

GoldRush focuses on making historical blockchain data accessible and structured:

Full transaction history for any wallet address across all supported chains
Token balances and portfolio snapshots at any block height
NFT metadata, floor prices, and ownership history
Token approval tracking — useful for security audits and revoke tools
DEX liquidity and swap data
Historical PnL and unrealized/realized gains per token via the upnlForWallet GraphQL endpoint
A terminal-first interface for developers and AI agents to query data without writing code

Particularly strong for audit-grade historical accuracy: compliance tools, tax reporting, portfolio analytics, and any product that needs to reconstruct wallet state at an arbitrary point in the past. GoldRush maintains a full archival copy of every supported blockchain from the genesis block — every balance, transaction, and log event.

Chain Coverage

100+ chains including Ethereum, BNB Chain, Polygon, Avalanche, Base, Optimism, Arbitrum, and a large number of smaller EVM-compatible networks.

Pricing and Limits

GoldRush offers a 14-day free trial with access to all APIs and 25,000 API credits. After the trial:

Vibe Coding: $10/month — 10,000 credits, community Discord support, full historical data
Professional: $250/month — 300,000 credits, auto-scaling flex credits, production-grade performance
Inner Circle (Enterprise): Custom pricing — dedicated support, SLAs, NDAs

Pros

100+ chains — the widest coverage of any provider on this list
Consistent REST schema across all chains — one integration pattern for everything
Strong historical depth: full transaction history from genesis block
upnlForWallet endpoint for PnL and cost basis — ideal for tax reporting tools
Transparent, predictable credit-based pricing
Terminal-first interface for AI agents and developer tooling

Cons

Not optimized for real-time price feeds or active trading use cases
No execution layer
Significant pricing gap between $10 and $250 tiers

Best for: Portfolio trackers, compliance and audit tools, tax reporting platforms, and any product that needs structured historical onchain data across a wide range of chains.

Side-by-Side Comparison

	Mobula	Moralis	Bitquery	The Graph	GoldRush
Real-time prices	✅ 5s, no cache	✅ Block-level	✅ 1s via Kafka	⚠️ Protocol-specific	⚠️ Not focused
Execution layer	✅	❌	❌	❌	❌
Long-tail tokens	✅ Octopus engine	⚠️ Major tokens	✅ DEX trades	⚠️ Subgraph needed	✅ Historical
Chain coverage	✅ Multi-chain	✅ EVM + Solana	✅ 40+ chains	✅ EVM-focused	✅ 100+ chains
Wallet analytics	✅	✅	⚠️ Custom queries	❌	✅ Historical
Historical data	✅	✅	✅	✅	✅ Deep
Real-time streams	✅ WebSocket	✅ Streams API	✅ Kafka/WS	❌	❌
Mempool data	❌	❌	✅	❌	❌
Free tier	✅ Free API key	✅ Limited CU	✅ Limited	✅ GRT-based	✅ 14-day trial
Pricing model	Usage-based	CU-based	Points-based	GRT tokens	Credit-based
Entry price	Free → usage	Free → ~$49/mo	Free → custom	Free → GRT	Free trial → $10/mo
Learning curve	Low-Medium	Low	High	High	Low
Execution API	✅	❌	❌	❌	❌

Ready to Build with Onchain Data That Moves at Market Speed?

If you want real-time token prices with no caching, multi-chain wallet analytics, and the ability to execute swaps — all from a single provider, without stitching together three different APIs — Mobula is the practical pick.

Why Mobula wins for most developer teams:

All-in-one: data + execution in one API — no second provider for swap routing
Honest refresh rate: 5-second no-cache pricing on every tier, including free
Long-tail coverage: Octopus engine tracks any token the moment it has liquidity
Developer-first: REST + WebSocket + TypeScript SDK + GraphQL, sub-1h support
Start free: full API access, no credit card, no sandbox limitations

What you can ship this week:

Live price monitors for any token across any supported chain
Multi-wallet PnL dashboards with historical balance tracking
Bot triggers based on real-time price thresholds
Swap execution flows without switching providers

👉 Start for free with Mobula — grab your API key and make your first request in minutes.

FAQs

What is the best onchain data API for building a crypto trading bot?

Mobula is the strongest option for trading bots. It provides real-time prices with 5-second no-cache refresh, covers long-tail tokens via the Octopus engine, and includes a swap execution layer — all from a single REST API. Most other providers require combining a data API with a separate execution provider, which adds latency and complexity.

Which onchain API has the best free tier?

Mobula offers a free API key with immediate access to the full endpoint suite including no-cache pricing — no credit card required. GoldRush offers a 14-day free trial with 25,000 credits and access to all APIs. Moralis has a free Starter plan with limited CUs. Bitquery provides a free community tier with limited daily query allowances.

What is the difference between an onchain data API and a blockchain RPC node?

A blockchain RPC node gives you raw access to chain state — but you need to parse and index everything yourself. An onchain data API does that indexing and aggregation for you, delivering structured, application-ready data through clean endpoints. For most product teams, onchain data APIs are significantly faster to integrate and easier to scale.

Which onchain API covers the most chains?

GoldRush (Covalent) leads with 100+ supported chains. Bitquery covers 40+ chains including non-EVM networks like Bitcoin. Mobula and Moralis focus on the most-used chains with deep per-chain coverage rather than maximum breadth.

Can I use an onchain data API without coding experience?

Most providers require development knowledge. Moralis is the most accessible for Web3 newcomers. GoldRush offers a terminal interface for AI agents and non-coders. For production bot-building or custom analytics, you will need to write code regardless of provider.

Onchain data is infrastructure. The provider you choose defines your latency, your coverage, and your cost structure as you scale.

The ceiling you hit six months from now is the decision you make today.

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

Top 6 Cryptocurrency Data APIs: Comprehensive Comparison (2026)

Kevin Meneses González — Mon, 13 Apr 2026 19:56:09 +0000

Most developers building crypto tools make the same mistake.

They grab the first API with a free tier, get it working, then six months later realize they're juggling three providers, paying for overlapping data, and still missing what they actually need.

The right API depends on what you're building:

A trading bot that reacts to live market moves
A portfolio tracker spanning DeFi, wallets, and CEX balances
A quantitative model that needs 10 years of clean OHLCV history
An on-chain research dashboard tracking blockchain fundamentals

Let's start with the one that covers the most ground.

1. CoinStats — The All-in-One Crypto Data & Wallet Layer

Most crypto APIs answer one question well. CoinStats answers all of them.

The platform powers the CoinStats app with over 1M monthly users, and the same infrastructure is available to any developer via API key.

What you get:

Real-time prices, market caps, volumes, and OHLCV charts for 100,000+ coins
Wallet balances and transaction histories for any address across 120+ blockchains
Staking, lending, and LP positions across 10,000+ DeFi protocols — auto-detected per wallet
Tickers and trading pairs from 200+ exchanges with consistent response formatting
Aggregated crypto news, trending topics, and sentiment data

MCP Server for AI agents:

That's a significant differentiator for teams building AI-powered tools in 2025.

What you can build:

Portfolio trackers, trading bots and signal engines, tax and accounting tools, multi-chain wallet explorers, and AI crypto assistants.

Pros:

Widest integration surface: one API key, one schema across 120+ chains
DeFi positions auto-detected — no manual protocol setup
MCP server ready for AI agent workflows
Free tier with credit-based pricing (not flat limits)

Cons:

Newer API compared to established players — ecosystem still maturing
Credit-based model requires more upfront planning for high-volume use
Not the right choice if you only need clean multi-asset historical data (stocks + crypto)

Pricing: Free tier available. Credit-based pricing scaled to endpoint complexity rather than flat monthly limits. Get your API key at openapi.coinstats.app.

Best for: Developers building portfolio trackers, multi-chain explorers, AI agents, or any product that needs wallet + market + DeFi data in a single call.

2. Mobula — Developer-First Onchain Data & Execution Layer

Platform: Mobula Official Site
Standout feature: Stream-based, real-time onchain API with sub-second latency, multi-chain coverage, and a built-in execution layer.

Most trading bot platforms give you a pre-packaged interface and call it a day. Mobula gives you the raw infrastructure to build exactly the bot you want.

Data covered:

Token prices, wallet balances, historical PnL, pair trades, pool states, OHLCV data
Wallet labels, token security checks
Execution layer: route swaps and execute onchain trades programmatically

Mobula supports Ethereum, Solana, BNB Chain, Base, and many more, with a TypeScript SDK and GraphQL alongside the REST API.

Pros:

Blazing fast, no-cache data — prices refresh every 5 seconds on any tier
Data + execution in one platform — skip stitching together multiple providers
Broadest onchain coverage including long-tail tokens and newly listed DEX pairs
Developer-first: REST, WebSocket, TypeScript SDK, GraphQL, real-world cookbooks

Cons:

Requires coding — no no-code interface
No visual strategy builder
Execution layer features are relatively recent

Best for: Technically proficient developers building custom bots, dashboards, or AI agents who need institutional-grade onchain data including DeFi tokens and cross-chain wallet tracking.

3. EODHD — All-in-One Multi-Asset Data

Platform: eodhd.com
Standout feature: Up to 30 years of historical data across stocks, forex, and 2,600+ crypto pairs under one API.

For crypto specifically:

Historical OHLCV with records for major coins going back to 2009
Live crypto price quotes via REST and WebSocket
Fundamental metrics: market cap, diluted valuation, circulating/total/max supply, all-time highs/lows
Bulk API endpoints for efficient data ingestion
No-code add-ons for Excel and Google Sheets

Pros:

All-in-one: crypto + equities + FX under a single, consistent API
Best-in-class historical depth — 30 years for equities, full crypto history since Bitcoin genesis
Excellent price-to-performance ratio
24/7 live customer support and thorough documentation

Cons:

No native on-chain/DeFi metrics
Not focused exclusively on crypto — specialists may find other APIs deeper on chain data

Pricing:

Free: 20 calls/day (no credit card required)
From $19.99/mo: 100,000 calls/day, end-of-day + live crypto data
$29.99/mo: adds real-time WebSocket streaming
$99.99/mo: All-in-One (historical, intraday, real-time, fundamentals, news)
Enterprise and student (50% discount) plans available

Best for: Developers and analysts building cross-asset tools, backtesting pipelines, or dashboards that need both crypto and traditional finance data from one provider.

4. CoinMarketCap — Industry-Standard Market Data

Platform: coinmarketcap.com/api
Standout feature: Data on 10,000+ assets aggregated from hundreds of exchanges — the reference standard for market cap rankings.

CoinMarketCap is the most recognized name in crypto market data. Its API is the go-to for current prices, rankings, and exchange statistics.

Key data:

Real-time price quotes, market cap, trading volume, and rankings for thousands of assets
Global market metrics: total market cap, Bitcoin dominance, total volume
Exchange-level data: listings, trading pair metadata, liquidity scores
Derivatives market data (futures, options) on higher plans

Historical data is locked behind paid tiers. The free plan covers only current market data.

Pros:

Industry-recognized data, used by Yahoo Finance and major financial platforms
Robust documentation with straightforward RESTful endpoints
Covers derivatives and exchange analytics

Cons:

No on-chain metrics
Historical data requires paid upgrade
Can become expensive at scale — enterprise tiers are priced for enterprise budgets

Pricing:

Free: 10,000 credits/month (~333 calls/day), 11 core endpoints
Hobbyist: ~$29/mo — ~50,000 calls/month, more endpoints
Startup: ~$79/mo | Standard: ~$199/mo
Professional/Enterprise: from $699/mo and up

Best for: Apps that need authoritative market cap rankings and real-time prices for a broad asset universe, especially when credibility of the data source matters to end users.

5. CoinGecko — Broad Coverage & Community Focus

Platform: coingecko.com/en/api
Standout feature: 13,000+ cryptocurrencies tracked including DeFi, NFTs, and community metrics — with one of the best free tiers in the industry.

Key data:

Real-time prices, market caps, and volumes for 13,000+ assets
Historical market charts (daily/hourly granularity)
Exchange data, trading pairs, categories, and asset contract addresses
Developer and social metrics: GitHub stats, Twitter followers, Reddit subscribers
DeFi protocol data and NFT collections

No WebSocket support — REST only, with polling intervals from 1–5 min (free) to ~30 sec (Pro).

Pros:

One of the best free tiers in the space
Exceptionally wide asset coverage including small-cap and emerging tokens
Community/developer metrics are unique to CoinGecko
Very easy to integrate — clean documentation, simple GET requests

Cons:

REST only — no WebSocket streaming
Not suited for high-frequency or ultra-low-latency use cases
Paid plans can get expensive for heavy usage

Pricing:

Free (Demo): ~10–30 calls/min, most endpoints included
Analyst: ~$129/mo — 500,000 calls/mo at 500 req/min
Pro: ~$499/mo — 2,000,000 calls/mo
Enterprise: ~$999/mo+

Best for: Developers who need broad asset coverage on a budget, or analysts who want community and developer activity metrics alongside price data.

6. CryptoCompare — Full Market Data + Sentiment + On-Chain

Key data:

5,700+ coins and 260,000+ trading pairs across 170+ exchanges (CEX and DEX)
Real-time quotes, order book snapshots, trade history, OHLCV candlesticks
Historical daily and intraday (minute) data — up to 1 year of minute-level history on enterprise
Blockchain metrics: transaction counts, wallet address data for major chains
News feeds and social sentiment endpoints

Infrastructure supports up to 40,000 API calls per second in bursts — suitable for demanding real-time dashboards.

Pros:

Enormous trading pair coverage across a wide exchange universe
Mix of price + news + sentiment + basic on-chain in one integration
High-performance infrastructure for real-time applications
Well-documented with Python client libraries

Cons:

Not as deep on on-chain metrics as dedicated platforms like Glassnode
Historical minute data beyond 7 days is enterprise-only
Free tier limits are not explicitly published — less transparent than competitors

Pricing:

Free: non-commercial, API key required (a few thousand calls/day reported)
Paid: from ~$80/mo basic to ~$200/mo advanced
Enterprise: custom pricing for unlimited usage, custom feeds, white-label

Best for: Quantitative researchers and analysts who want a mid-range provider combining market depth, news/sentiment signals, and basic on-chain context without committing to enterprise pricing.

Side-by-Side Summary

Provider	Real-Time	Historical	On-Chain/DeFi	Multi-Chain Wallets	MCP/AI Ready	Free Tier	Starting Price
CoinStats	✅	✅	✅ Deep	✅ 120+ chains	✅ Native	✅ Credits	Free
Mobula	✅ Sub-second	✅	✅ DEX/DeFi	✅ Multi-chain	Partial	✅	Usage-based
EODHD	✅ WebSocket	✅ 30yrs	❌	❌	❌	✅ 20 calls/day	$19.99/mo
CoinMarketCap	✅ (~1-2 min)	Paid only	❌	❌	❌	✅ Limited	$29/mo
CoinGecko	✅ REST	✅	Partial	❌	❌	✅ Generous	$129/mo
CryptoCompare	✅ WebSocket	✅ Minute	Basic	❌	❌	✅ Limited	~$80/mo

Which One Should You Use?

There's no single winner — it depends entirely on what you're building.

Pick Mobula if you're building automated trading systems that need real-time, no-cache DEX/DeFi data and want the execution layer included.

Pick EODHD if your product spans crypto and traditional finance, and you need decades of clean historical data across asset classes.

Pick CoinMarketCap if your use case requires the industry-recognized market cap reference and exchange-level data with a reliable SLA.

Pick CoinGecko if you're prototyping fast, working on a budget, or need community/developer metrics alongside prices.

Pick CryptoCompare if you're a researcher who wants price, sentiment, and basic on-chain data blended in one API at a mid-range price.

The worst outcome is picking one and discovering three months in that it doesn't cover your actual use case. Start with a clear list of what your product needs to query — then pick accordingly.

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

The 7 Best MCP Servers for Stock Market Data (2026)

Kevin Meneses González — Sun, 12 Apr 2026 11:04:17 +0000

Everyone is building MCP servers.

Almost nobody is talking about data quality.

If you're:

building AI agents that trade or analyze markets,
connecting LLMs to financial workflows,
or replacing a fragile API wrapper with something that actually scales,

The MCP you choose isn't a minor implementation detail. It's your data foundation.

And a bad foundation breaks everything downstream.

The Problem Nobody Mentions

Here's what typically happens.

A developer finds an MCP server, connects it in ten minutes, runs a few queries, gets clean JSON back. Looks great. Ships it.

Then, three weeks later:

Rate limits hit during a live session. Fundamentals are six months stale. The free tier silently returns incomplete data without an error. The endpoint for options chains requires a separate paid plan that wasn't in the docs.

The MCP worked. The data didn't.

That's the real problem with most MCP server comparisons: they evaluate the connector, not what's behind it.

How to Read This Comparison

Each server is evaluated on five criteria:

Data depth — prices, fundamentals, options, macroeconomic data
Real-time quality — latency, update frequency, free vs. paid tier gap
MCP maturity — official support, stability, documentation
Developer experience — setup speed, response structure, Python integration
Best-fit use case — where it actually wins

This is not a "best overall" ranking. It's a best-for-your-job guide.

1. EODHD — Best for Fundamentals + OHLCV in One Call

EODHD (End-of-Day Historical Data) is the most complete financial data provider for developers who need both price data and company fundamentals without juggling multiple APIs.

Its MCP server exposes the same clean REST infrastructure that powers production fintech workflows — covering global equities, ETFs, forex, crypto, macroeconomic indicators, and earnings calendars through a single, predictable interface.

Pros

Fundamentals and OHLCV data in one endpoint — no merging from separate sources
Broad global coverage: US, Europe, Asia, 70+ exchanges
Consistent response structure, automation-friendly (no surprise field changes)
Financial news API with sentiment analysis included

Cons

Free tier limited to 20 API calls/day — sufficient for testing, not for production
Some niche datasets (full options chains) require higher-tier plans
Less brand recognition than Alpha Vantage among beginners

Best for: AI agents doing fundamental analysis, backtesting pipelines, n8n/Python automation workflows that need price + financials in one call.

Here's what a basic integration looks like:

import requests
import pandas as pd

api_key = "YOUR_EODHD_API_KEY"
ticker = "AAPL.US"

# Historical OHLCV
url = f"https://eodhd.com/api/eod/{ticker}?api_token={api_key}&fmt=json"
df = pd.DataFrame(requests.get(url).json())
df["returns"] = df["close"].pct_change()

# Fundamentals in the same session
fund_url = f"https://eodhd.com/api/fundamentals/{ticker}?api_token={api_key}&filter=Highlights,Valuation"
fundamentals = requests.get(fund_url).json()

print(df.tail(5))
print("PE Ratio:", fundamentals["Highlights"]["PERatio"])

From here you can build:

Stock screeners combining price momentum and valuation
AI agent contexts with full financial snapshots
Automated research reports with no manual data merging

👉 Get started with EODHD APIs here: eodhd.com

2. Financial Modeling Prep (FMP) — Best for Deep Fundamental Screening

FMP is the go-to choice when your agent needs to go deeper than prices — income statements, balance sheets, cash flow, DCF valuations, insider transactions, and analyst estimates, all available through a clean REST interface.

Its MCP server makes it straightforward to connect these datasets directly into AI workflows, without building custom parsers for SEC filings.

Pros

Exceptional fundamentals depth: 10+ years of standardized financials per company
Built-in valuation endpoints (DCF, P/E comparison, EV/EBITDA)
Affordable entry point (~$19.99/month for serious access)
Google Sheets add-on for non-code workflows

Cons

Free tier: 250 calls/day — hits limits fast in multi-ticker workflows
Real-time data is on paid plans; free tier is end-of-day only
Not a streaming solution — snapshot-based only

Best for: Equity analysts, AI-powered stock screeners, any workflow that needs multi-year financials without writing a Bloomberg integration.

👉 Explore FMP pricing plans: financialmodelingprep.com

3. Alpaca — Best for Agents That Execute Trades

Alpaca is the only option on this list that combines market data with a commission-free brokerage API. This means your AI agent can go from analysis to order placement in the same workflow, without switching platforms.

The MCP server exposes both the data layer and the trading layer — real-time quotes, historical bars, account management, and order execution — all through the same interface.

Pros

Data + execution in one API: no brokerage integration required
Paper trading environment included — test strategies with live data risk-free
Free core tier with real-time US equity data
Python SDK is excellent; community is active

Cons

US equities and crypto only — no international markets
Live trading requires KYC and US residency (or select other countries)
Data depth is narrower than dedicated providers (no deep fundamentals)

Best for: Trading bots, strategy automation, AI agents that need to close the loop between signal and execution.

4. Alpha Vantage — Best Free Tier for Beginners

Alpha Vantage is the most widely known financial data provider for developers learning to build with market data. Its MCP server makes the same accessible infrastructure available to AI agents — stocks, forex, crypto, commodities, and built-in technical indicators.

The free tier is genuinely useful for prototyping, which is why it appears in so many tutorials and side projects.

Pros

Built-in technical indicators (RSI, MACD, Bollinger Bands) via direct API call
Official Nasdaq data vendor — data reliability is solid for US equities
Free tier covers real-time US quotes: no credit card required to start
Extensive community examples and documentation

Cons

Free limit: 25 calls/day (standard), 5 calls/minute — hits walls fast
Fundamentals are basic compared to EODHD or FMP
International market coverage is limited on lower tiers
Paid plans start at $29.99/month but rate limits still feel restrictive at entry level

Best for: Learning, prototyping, agents that need quick technical indicators without building them manually.

5. Polygon.io — Best for Real-Time US Market Data

Polygon is built for speed. If your agent needs tick-by-tick price data, WebSocket streaming, or low-latency US equity quotes, Polygon is the specialist choice.

Its MCP server exposes the same infrastructure used by trading desks and fintech startups that can't afford delayed data.

Pros

WebSocket streaming: live trades and quotes with minimal latency
Full tick-level historical data for backtesting high-frequency strategies
Strong documentation with interactive API explorer
Covers stocks, options, forex, and crypto under one account

Cons

Primarily US-focused — limited international equity coverage
Real-time professional-grade data gets expensive quickly (hundreds/month)
Fundamentals and news coverage is thinner than EODHD or FMP
Free tier: 5 requests/minute, 2 years of historical data

Best for: Day trading agents, live market dashboards, HFT-adjacent workflows where latency is the primary constraint.

6. Finnhub — Best for News + Sentiment Integration

Finnhub covers a broad range of financial data types under one API — real-time quotes, fundamentals, earnings calendars, and financial news with sentiment scores. Its free tier is among the most generous: 60 API calls per minute.

For agents that need to monitor news flow alongside price data, Finnhub is the easiest path to a combined signal.

Pros

60 calls/minute on the free tier — highest in this list
Financial news with sentiment analysis included at no extra cost
Corporate calendars: earnings, IPOs, economic events
Multilingual news coverage and alternative data (ESG, COVID-19 stats)

Cons

Full fundamentals and international data require paid plans ($49–50/month per market)
Pricing can stack up fast if you need multiple markets
Response structure is less consistent across endpoints than EODHD or FMP
No WebSocket streaming for real-time price feeds on the free tier

Best for: News-driven agents, sentiment analysis workflows, event-based trading strategies.

7. QuantConnect — Best for Full Algo Trading Pipelines

QuantConnect is a different category entirely. It's not a data provider with an MCP wrapper — it's an end-to-end algorithmic trading platform that exposes its backtesting engine, strategy deployment, and brokerage integration through the MCP protocol.

If you're building AI agents that design, test, and execute trading strategies (not just analyze data), QuantConnect closes the entire loop.

Pros

Full backtesting engine: equities, options, futures, forex, crypto
Research-to-live-trading pipeline in one platform
Open-source strategy library with thousands of community algorithms
Brokerage integrations for real-money execution

Cons

Steep learning curve — this is a serious platform, not a quick integration
Pricing scales with compute usage, not just API calls
Not suitable if you only need data — it's overkill for read-only workflows
Python/C# required for strategy logic; no no-code option

Best for: Serious algo traders who want AI agents to assist in the full strategy lifecycle — from signal generation to live execution.

Quick Selection Guide

Use Case	Best Option
Fundamentals + prices in one call	EODHD
Deep financial statement analysis	FMP
Trading bot with execution	Alpaca
Learning / prototyping	Alpha Vantage
Real-time US streaming	Polygon.io
News + sentiment signals	Finnhub
Full algo trading pipeline	QuantConnect
Global market coverage	EODHD or FMP
Best free tier (calls/min)	Finnhub
Best free tier (data depth)	Alpha Vantage

The Insight Most Guides Miss

An MCP server is not a data source.

It's a protocol layer on top of a data source.

The quality of your financial agent depends almost entirely on what sits behind that layer — the coverage, consistency, and reliability of the underlying data. Two MCP servers can expose identical tool names and return fundamentally different results at production scale.

Choose the connector that matches your data requirements first. Then evaluate the MCP implementation.

FAQs

❓ What is an MCP server in the context of financial data?
✅ MCP (Model Context Protocol) is a standard that lets AI agents connect to external tools and data sources through a consistent interface. A financial MCP server exposes market data, fundamentals, or trading capabilities as tools that an LLM can call directly — without custom API wrappers or manual parsing.

❓ Which MCP server has the best free tier for developers?
✅ Finnhub offers 60 API calls per minute for free, which is the most generous rate limit in this list. Alpha Vantage is the better choice if you need a broader mix of data types (prices + indicators + some fundamentals) for prototyping. For production work, both require paid plans.

❓ Can I use these MCP servers with Claude or other AI agents?
✅ Yes. All servers in this list are compatible with MCP-enabled clients including Claude Desktop, Cursor, and VS Code. EODHD, FMP, and Alpha Vantage also expose standard REST APIs, which means you can integrate them directly into Python-based agent frameworks (LangChain, CrewAI, n8n) regardless of MCP support.

❓ Is EODHD better than Alpha Vantage for financial agents?
✅ For production workflows, yes. EODHD covers both OHLCV data and company fundamentals under a single API with global exchange coverage — which eliminates the need to merge from multiple sources. Alpha Vantage is easier to start with and has excellent built-in technical indicators, but its free tier limits (25 calls/day) and thinner fundamentals make it less practical at scale.

❓ Do I need coding skills to use these MCP servers?
✅ For most of them, basic Python knowledge is enough to get started. EODHD, FMP, and Alpha Vantage all have clear documentation with copy-paste examples. QuantConnect is the exception — strategy development there requires solid Python or C# skills. If you prefer no-code workflows, EODHD and FMP both offer Google Sheets integrations.

Final Thoughts

MCP is changing how financial data connects to AI systems.

But the protocol is not the product. The data is.

Pick the server that solves your actual data problem — not the one with the best GitHub stars or the most tutorials on YouTube.

If you need one place to start, EODHD gives you the widest data surface for the least integration complexity. Fundamentals, prices, macroeconomics, and news — one API key, one clean interface.

👉 Get started with EODHD: eodhd.com

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

Forem: Kevin Meneses González

How I Automated My Investment Research With 50 Lines of Python

The Problem: Too Much Noise, Not Enough Signal

The Shift: From Checking Stocks to Filtering Them

What This System Actually Does

Step 1: Define Your Watchlist

Step 2: Define Your Conditions

Step 3: Fetch Real-Time Data

Step 4: Apply the Logic

Step 5: Filter the Market

Step 6: Get a Clean Output

What Changed for Me

The Hidden Cost of API Calls

Why Data Quality Matters

FAQs

Final Thought

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

Why the Usual Options Don't Work

What I Built

What the API Actually Returns

GET /coins?limit=50

GET /markets

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

GET /news?limit=6

Project Setup

The Data Hooks

useCoinList — The main table data

useMarketStats — Global market cards

useChartData — Price history per coin

useNews — News feed

Section 1: Global Market Stats

Section 2: Coin Table with Sort and Search

Section 3: The Inline Price Chart

Section 4: News Feed

Composing the App

How Many API Calls Does the Dashboard Make?

API Key Security

FAQ

Wrapping Up

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

Why Unofficial APIs Break (and What to Use Instead)

What Is EODHD and What's Free

Getting Historical Stock Data in Python: Step by Step

1. The base request

2. Build a multi-ticker price matrix

3. Compute returns and volatility

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

Advanced Use Cases

Use Case 1: Correlation matrix for portfolio analysis

Use Case 2: RSI indicator from scratch

Use Case 3: Backtesting a moving average crossover

Use Case 4: Multi-asset momentum ranking

Free vs Paid: What Changes When You Upgrade

FAQs

Closing

Top 6 Cryptocurrency Data APIs: Comprehensive Comparison (2026)

1. CoinStats — The All-in-One Crypto Data & Wallet Layer

2. Mobula — Developer-First Onchain Data & Execution Layer

3. EODHD — All-in-One Multi-Asset Data

4. CoinMarketCap — Industry-Standard Market Data

5. CoinGecko — Broad Coverage & Community Focus

6. CryptoCompare — Full Market Data + Sentiment + On-Chain

Side-by-Side Summary

Which One Should You Use?

How to Connect Claude to Real Financial Data with FMP MCP

Why Financial AI Tools Break at the Data Layer

What FMP MCP Actually Does

Setup in Under 10 Minutes

1. Get your FMP API key

2. Install the MCP server

3. Configure Claude Desktop

4. Test the connection

3 Systems You Can Build This Week

System 1 — Morning Portfolio Brief (15 minutes saved daily)

System 2 — Earnings Prep Autopilot (2 hours saved per company)

System 3 — Fundamental Screening on Demand

What This Looks Like in a Python Workflow

Practical Tips for Investors Using This Stack

How to Build a Portfolio Dashboard with FMP + Python

Architecture Overview

`GET /coins?limit=50`

`GET /markets`

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

`GET /news?limit=6`

`useCoinList` — The main table data

`useMarketStats` — Global market cards

`useChartData` — Price history per coin

`useNews` — News feed