Historical Exchange Rate API: 6 Best Free Options Compared (2026)
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.
- Data source: institutional foreign exchange market data
- History depth: Up to 1 year of daily market rates; central-bank archives go back decades
- Currencies: 160+ including majors, minors, and exotics
- Rate type: Mid-market (no bank markup)
- Granularity: Daily (including weekends and holidays)
- Free tier: latest rates only; historical data needs a paid plan from €4.99/mo
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']}") - History depth: Since 1999
- Free tier: 1,000 req/mo, hourly, latest rates only — historical data from $12/mo
- Granularity: Daily
- Limitation: Free tier locked to USD base; no time-series endpoint on basic plans
- Credit card: Required for historical access
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") - History depth: Since 1999 (ECB data)
- Free tier: Keyless, no published request caps
- Currencies: ~30 on v1; 165+ on the 2026 v2 (official sources)
- Granularity: Daily, business days only (no weekends or holidays)
- Limitation: No exotic currencies (no INR, BRL, MXN, etc.); no weekend data
- Credit card: Not required
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']}") - History depth: Since 1999
- Free tier: 100 req/mo, hourly, EUR base, HTTPS, historical included, non-commercial
- Granularity: Daily
- Limitation: 100 requests/month runs out fast on date-by-date lookups; commercial use needs a paid plan from $14.99/mo
- Credit card: Not required for the free tier
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']}") - History depth: Limited (varies by plan)
- Free tier: Latest rates only, 1,500 req/mo, daily updates
- Granularity: Daily
- Limitation: Historical data requires Pro ($10/mo) or higher; no time-series or date range queries
- Credit card: Required for historical access
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") - History depth: Since 1999
- Free tier: Keyless, no caps
- Currencies: ~30 (ECB euro reference rates)
- Granularity: Daily, business days only
- Limitation: XML/SDMX format is complex; no JSON; no exotic currencies; no weekends
- Credit card: Not required
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:
- Low entry price: Open Exchange Rates and ExchangeRate-API put history on paid plans, and so does AllRatesToday; its Small plan starts at €4.99/mo, with history billed per currency per month of data.
- 160+ currencies: ECB-based sources (Frankfurter, ECB direct) only cover ~30 currencies. AllRatesToday covers 160+, including exotic pairs like USD/NGN, EUR/BRL, and GBP/INR that accountants working with emerging markets need.
- Two kinds of history: mid-market rates aggregated from institutional foreign exchange market data, plus official rates from 100+ central banks and tax authorities, each with the publishing source named.
- Daily data including weekends: Unlike ECB data, AllRatesToday provides rates for every calendar day, which matters for accurate transaction-date lookups.
- Date range queries: Fetch up to a year of market data in a single API call. No need to loop through individual dates.
- Try before you pay: The free tier (no credit card) lets you test the API on latest rates before upgrading for historical access.
- JSON responses: Clean, predictable JSON output that converts directly to pandas DataFrames or CSV. Compare this to the ECB's SDMX/XML format.
- Python SDK:
pip install allratestodayfor a Pythonic interface to historical data, or userequests/cURLdirectly with the REST API.
Which One Should You Pick?
- Free, long ECB history (EUR, USD, GBP, JPY, CHF and ~25 others): Frankfurter, or the ECB directly if you can handle SDMX/XML. No key, no caps, data back to 1999.
- Free, a few hundred lookups a month, non-commercial: Fixer, currencylayer or exchangeratesapi.io all include historical dates on their free tiers.
- Official central-bank rates across 100+ institutions, or multi-source history in one API: AllRatesToday on a paid plan from €4.99/mo. The free API key is for latest rates and non-commercial testing only.
- Deep market history (1999+) for 160+ currencies with a large budget: Open Exchange Rates or Fixer paid plans.
Quick Reference
- Historical rate (specific date):
GET /api/v1/rates?source=USD&target=EUR&from=2025-12-31&to=2025-12-31(paid plans) - Historical range:
GET /api/v1/rates?source=USD&target=EUR&from=2026-01-01&to=2026-09-30(paid plans) - Python SDK:
client.get_historical_rates("USD", "EUR", "30d") - Auth:
Authorization: Bearer YOUR_API_KEY - PyPI: pypi.org/project/allratestoday
- GitHub: allratestoday/exchange-rates-api
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