Historical Exchange Rate API: 6 Best Free Options Compared (2026)

Reviewed by Madhushan, Fintech Developer — November 2026
Financial data analysis and reporting

Historical exchange rate data is essential for financial reporting, tax calculations, audit trails, and trend analysis. Accountants need last quarter's EUR/USD rate for revenue reconciliation. Analysts need five years of GBP/JPY data to model volatility. Fintech developers need to display the rate that applied when a transaction was processed, not today's rate.

The problem: most currency APIs lock historical data behind expensive paid plans. The few that offer it for free either limit you to a handful of ECB currencies, restrict query ranges to 30 days, or require a credit card to sign up. If you are building a financial application that needs to look up past rates reliably, the wrong API choice will cost you money or force a migration later.

This article compares 6 historical exchange rate APIs in 2026, with code examples in Python and cURL. Vendor limits and prices below were re-checked on 24 October 2026. Short version: if it has to be free, Frankfurter (ECB data, ~30 currencies) is the pick; Fixer's free tier also includes historical dates for non-commercial use; if you need 160+ currencies or official central-bank archives, AllRatesToday serves historical rates on paid plans from €4.99/mo. We build AllRatesToday, so read that entry with that in mind.

Looking for live rates rather than history? Our companion guide ranks the best free currency APIs in 2026 for real-time conversion, with the same free-tier detail applied to current-rate endpoints.

Side-by-Side Comparison

Here is how the 6 historical exchange rate APIs compare (checked 2026-10-24):

API History Depth Free Tier Granularity Data Source Credit Card Required
AllRatesToday 1 year (market); decades (central banks) Paid only (from €4.99/mo) Daily FX market aggregate + 100+ central banks Yes (paid plan)
Open Exchange Rates Since 1999 History paid only (free: 1,000 req/mo, latest, USD base) Daily Multiple aggregated Yes (from $12/mo)
Frankfurter Since 1999 Keyless, no caps Daily (business days) ECB reference rates No
Fixer.io Since 1999 100 req/mo incl. history (non-commercial) Daily Multiple aggregated No (paid from $14.99/mo)
ExchangeRate-API Limited History paid only (free: 1,500 req/mo, latest) Daily Multiple aggregated Yes (Pro from $10/mo)
ECB (direct) Since 1999 Keyless, no caps Daily (business days) ECB reference rates No

Key takeaway: Frankfurter and the ECB are free with no key and no caps, limited to ~30 currencies on business days. Fixer includes historical dates on its 100 req/mo free tier, for non-commercial use. Open Exchange Rates, ExchangeRate-API and AllRatesToday put historical data on paid plans. AllRatesToday's start at €4.99/mo and cover 160+ market currencies plus official central-bank archives.

Also checked but not ranked in detail: currencylayer (free tier daily, HTTPS, historical included, paid from $14.99/mo), exchangeratesapi.io (free tier daily, historical included, paid from $14.99/mo) and CurrencyAPI (free 300 req/mo, daily, paid from $9.99/mo). All three are worth a look if a small monthly cap of daily data is enough.

1. AllRatesToday — Market History Plus 100+ Central Banks

AllRatesToday provides historical exchange rate data on every paid plan, starting with Small at €4.99/mo (the free tier covers latest rates only and is for non-commercial use). Market history is aggregated from institutional foreign exchange market data, covering 160+ currencies with daily granularity for up to a year back; official central-bank archives from 100+ institutions go back decades. History is billed per currency per month of data requested, so a one-year USD/EUR range counts as 12 units. You can query specific dates, date ranges, and preset time-series periods.

cURL: Fetch a historical rate for a specific date

curl -X GET "https://allratestoday.com/api/v1/rates?source=USD&target=EUR&from=2025-12-31&to=2025-12-31" \
  -H "Authorization: Bearer YOUR_API_KEY"

Response:

{
  "source": "USD",
  "target": "EUR",
  "date": "2025-12-31",
  "rate": 0.9234,
  "type": "mid-market"
}

cURL: Fetch a date range

curl -X GET "https://allratestoday.com/api/v1/rates?source=USD&target=EUR&from=2026-01-01&to=2026-03-31" \
  -H "Authorization: Bearer YOUR_API_KEY"

Python: Historical rates with the SDK

from allratestoday import AllRatesToday

client = AllRatesToday("YOUR_API_KEY")

# Get historical rates for a specific period
history = client.get_historical_rates("USD", "EUR", "30d")

for point in history["rates"]:
    print(f"{point['time']}: 1 USD = {point['rate']} EUR")

Python: Historical rates with requests

import requests

API_KEY = "YOUR_API_KEY"

# Fetch USD/EUR rate for a specific date
response = requests.get(
    "https://allratestoday.com/api/v1/rates",
    params={
        "source": "USD",
        "target": "EUR",
        "from": "2026-06-15",
        "to": "2026-06-15"
    },
    headers={"Authorization": f"Bearer {API_KEY}"}
)

data = response.json()
print(f"USD/EUR on {data['date']}: {data['rate']}")

Python: Build a historical rates DataFrame

import requests
import pandas as pd

API_KEY = "YOUR_API_KEY"

# Fetch USD/EUR data for 2026 so far
response = requests.get(
    "https://allratestoday.com/api/v1/rates",
    params={
        "source": "USD",
        "target": "EUR",
        "from": "2026-01-01",
        "to": "2026-09-30"
    },
    headers={"Authorization": f"Bearer {API_KEY}"}
)

data = response.json()

# Convert to pandas DataFrame
df = pd.DataFrame(data["rates"])
df["time"] = pd.to_datetime(df["time"])
df.set_index("time", inplace=True)

# Summary statistics for financial reporting
print(f"Period: {df.index.min().date()} to {df.index.max().date()}")
print(f"Average rate: {df['rate'].mean():.4f}")
print(f"Min rate:     {df['rate'].min():.4f}")
print(f"Max rate:     {df['rate'].max():.4f}")
print(f"Std dev:      {df['rate'].std():.4f}")
print(f"Data points:  {len(df)}")

# Export to CSV for accountants
df.to_csv("usd_eur_2026_rates.csv")

Tip for accountants: Export historical rates to CSV and import directly into Excel, QuickBooks, or your ERP system. The DataFrame output matches standard accounting date formats.

2. Open Exchange Rates

Open Exchange Rates has historical data going back to 1999, but it is locked behind paid plans (from $12/mo). The free tier gives 1,000 requests per month, hourly updates and a USD base, on the /latest.json endpoint. /historical/YYYY-MM-DD.json needs a paid plan.

# Requires paid plan
curl "https://openexchangerates.org/api/historical/2025-12-31.json?app_id=YOUR_APP_ID"
import requests

# Note: This requires a paid plan
APP_ID = "YOUR_APP_ID"

response = requests.get(
    "https://openexchangerates.org/api/historical/2025-12-31.json",
    params={"app_id": APP_ID, "base": "USD"}
)

data = response.json()
print(f"USD/EUR on 2025-12-31: {data['rates']['EUR']}")

3. Frankfurter

Frankfurter is a free, open-source API that wraps European Central Bank (ECB) reference rates. It is a strong free option if the ~30 currencies the ECB publishes are enough: no key, no request caps, history back to 1999. However, ECB data only covers business days (no weekends or holidays) and updates once per day at 16:00 CET.

# Fetch a specific historical date
curl "https://api.frankfurter.app/2025-12-31?from=USD&to=EUR,GBP,JPY"
# Fetch a date range
curl "https://api.frankfurter.app/2025-01-01..2025-12-31?from=USD&to=EUR"
import requests

# No API key needed
response = requests.get(
    "https://api.frankfurter.app/2025-01-01..2025-03-31",
    params={"from": "USD", "to": "EUR"}
)

data = response.json()

for date, rates in sorted(data["rates"].items()):
    print(f"{date}: 1 USD = {rates['EUR']} EUR")

When Frankfurter works: If you only need EUR, USD, GBP, JPY, CHF, and a handful of other major currencies with no weekend data, Frankfurter is a solid free option. For currencies outside ECB coverage, or for official rates from other central banks, you need a different source.

4. Fixer.io

Fixer has historical data going back to 1999, and unlike Open Exchange Rates its free tier includes the historical date endpoint. The free tier is 100 requests per month, hourly updates, EUR base, HTTPS supported, and limited to non-commercial use. Paid plans start at $14.99/mo.

# Free tier: 100 req/mo, non-commercial
curl "https://data.fixer.io/api/2025-12-31?access_key=YOUR_KEY&base=EUR&symbols=USD,GBP"
import requests

# Free tier: 100 req/mo, EUR base, non-commercial use
API_KEY = "YOUR_API_KEY"

response = requests.get(
    "https://data.fixer.io/api/2025-12-31",
    params={
        "access_key": API_KEY,
        "base": "EUR",
        "symbols": "USD,GBP,JPY"
    }
)

data = response.json()
if data.get("success"):
    print(f"EUR/USD on 2025-12-31: {data['rates']['USD']}")

5. ExchangeRate-API

ExchangeRate-API offers historical data on paid plans only (Pro from $10/mo). The free tier provides 1,500 requests per month with daily updates but is restricted to the /latest/ endpoint. There is no time-series endpoint.

# Requires paid plan (pair-specific historical lookup)
curl "https://v6.exchangerate-api.com/v6/YOUR_KEY/history/USD/2025/12/31"
import requests

# Note: Historical endpoint requires paid plan
API_KEY = "YOUR_API_KEY"

response = requests.get(
    f"https://v6.exchangerate-api.com/v6/{API_KEY}/history/USD/2025/12/31"
)

data = response.json()
if data.get("result") == "success":
    print(f"USD/EUR on 2025-12-31: {data['conversion_rates']['EUR']}")

6. ECB (European Central Bank) — Direct Access

You can access the ECB's Statistical Data Warehouse directly via their SDMX API. This is the raw source that Frankfurter wraps. It is free and requires no API key, but the SDMX/XML response format is cumbersome compared to JSON APIs.

# Fetch daily USD/EUR from ECB's SDMX API (XML response)
curl "https://data-api.ecb.europa.eu/service/data/EXR/D.USD.EUR.SP00.A?startPeriod=2025-01-01&endPeriod=2025-12-31"
import requests
import xml.etree.ElementTree as ET

# Fetch USD/EUR from ECB SDMX API
response = requests.get(
    "https://data-api.ecb.europa.eu/service/data/EXR/D.USD.EUR.SP00.A",
    params={
        "startPeriod": "2025-01-01",
        "endPeriod": "2025-03-31"
    },
    headers={"Accept": "application/xml"}
)

# Parse XML response (SDMX format)
root = ET.fromstring(response.text)
ns = {
    "generic": "http://www.sdmx.org/resources/sdmxml/schemas/v2_1/data/generic"
}

for obs in root.findall(".//generic:Obs", ns):
    date = obs.find("generic:ObsDimension", ns).get("value")
    rate = obs.find("generic:ObsValue", ns).get("value")
    print(f"{date}: 1 USD = {rate} EUR")

Use Case: Monthly Revenue Reconciliation

Accountants frequently need the exchange rate on the exact date a transaction was invoiced. Here is how to build a reconciliation script with AllRatesToday:

import requests
import pandas as pd
from datetime import datetime

API_KEY = "YOUR_API_KEY"

# Sample invoice data (date, amount, currency)
invoices = [
    {"date": "2026-01-15", "amount": 5000, "currency": "EUR"},
    {"date": "2026-02-03", "amount": 12000, "currency": "GBP"},
    {"date": "2026-02-20", "amount": 800000, "currency": "JPY"},
    {"date": "2026-03-10", "amount": 25000, "currency": "CAD"},
    {"date": "2026-04-01", "amount": 150000, "currency": "INR"},
]

base_currency = "USD"
results = []

for inv in invoices:
    response = requests.get(
        "https://allratestoday.com/api/v1/rates",
        params={
            "source": inv["currency"],
            "target": base_currency,
            "from": inv["date"],
            "to": inv["date"]
        },
        headers={"Authorization": f"Bearer {API_KEY}"}
    )

    data = response.json()
    rate = data["rate"]
    usd_amount = round(inv["amount"] * rate, 2)

    results.append({
        "Invoice Date": inv["date"],
        "Original Amount": inv["amount"],
        "Currency": inv["currency"],
        "Exchange Rate": rate,
        "Amount (" + base_currency + ")": usd_amount
    })

# Create accounting report
df = pd.DataFrame(results)
print(df.to_string(index=False))
col = "Amount (" + base_currency + ")"
total = df[col].sum()
print("\nTotal Revenue (USD): $" + format(total, ",.2f"))

# Export for accounting software
df.to_csv("revenue_reconciliation_q1_2026.csv", index=False)
print("\nExported to revenue_reconciliation_q1_2026.csv")

Use Case: Currency Volatility Analysis

Analysts tracking exchange rate trends can use AllRatesToday's historical data to compute rolling averages and standard deviations:

import requests
import pandas as pd

API_KEY = "YOUR_API_KEY"

# Fetch 1 year of GBP/USD data
response = requests.get(
    "https://allratestoday.com/api/v1/rates",
    params={
        "source": "GBP",
        "target": "USD",
        "from": "2025-10-16",
        "to": "2026-10-16"
    },
    headers={"Authorization": f"Bearer {API_KEY}"}
)

data = response.json()
df = pd.DataFrame(data["rates"])
df["time"] = pd.to_datetime(df["time"])
df.set_index("time", inplace=True)

# Calculate rolling statistics
df["ma_30"] = df["rate"].rolling(window=30).mean()
df["ma_90"] = df["rate"].rolling(window=90).mean()
df["volatility_30d"] = df["rate"].rolling(window=30).std()

# Monthly summary
monthly = df["rate"].resample("M").agg(["mean", "min", "max", "std"])
monthly.columns = ["Avg Rate", "Min", "Max", "Volatility"]
print("\nMonthly GBP/USD Summary:")
print(monthly.to_string())

# Identify highest volatility months
most_volatile = monthly["Volatility"].idxmax()
print(f"\nMost volatile month: {most_volatile.strftime('%B %Y')}")
print(f"Volatility (std): {monthly.loc[most_volatile, 'Volatility']:.4f}")

cURL Quick Reference

For analysts and developers who prefer command-line access:

# Specific date
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR&from=2025-12-31&to=2025-12-31"

# Date range
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR&from=2026-01-01&to=2026-09-30"

# Multiple targets
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR,GBP,JPY&from=2025-12-31&to=2025-12-31"

# Pipe to jq for clean output
curl -s -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR&from=2026-01-01&to=2026-01-31" \
  | jq '.rates[] | "\(.time): \(.rate)"'

Where AllRatesToday Fits

After comparing all six options, here is where AllRatesToday is a reasonable choice for historical exchange rates, and where it is not:

Which One Should You Pick?

Quick Reference

Access Historical Exchange Rate Data

Get your free API key in 30 seconds (no credit card) to test latest rates, then upgrade from €4.99/mo for historical rates on 160+ currencies and 100+ central banks. Compare all options on our Exchange Rate API page.

Get Your Free API Key

Related Articles