5 Best APIs for Real-Time Forex Data in 2026
If you are building a fintech application, a forex trading platform, a cross-border payments system, or a multi-currency portfolio tracker, the quality of your exchange rate data determines whether your users trust your product. Stale rates cost real money. Retail rates with hidden markups erode user confidence. And an API that goes down during a market-moving event is a liability, not a feature.
The problem: "real-time" means different things to different providers. Some APIs claim real-time but only update hourly. Others provide genuine tick-level data but charge thousands per month. For payments and invoicing, rates refreshed every 60 seconds from a reliable source are usually enough and affordable. For trading, charting or anything that reacts to price moves, you need a streaming or tick-level feed, and that is a different category of product.
This article compares 5 APIs that come up for real-time forex data in 2026: data source transparency, update frequency and delivery (REST vs streaming), mid-market vs retail rates, and cost. The short version: AllRatesToday (our own product) is the best fit when a mid-market rate refreshed every 60 seconds over REST is sufficient, which is the case for payments, invoicing, pricing and portfolio apps. If you need streaming, tick data, bid/ask or intraday candles, OANDA or Twelve Data are the better choice, and we say so below.
Mid-Market vs Retail Rates: Why It Matters
Before comparing APIs, you need to understand the difference between mid-market and retail exchange rates, because this single factor determines whether your application shows accurate data or misleading data.
Mid-market rate (interbank rate)
The mid-market rate is the midpoint between the buy (bid) and sell (ask) prices on the global foreign exchange market. It is the "true" exchange rate — the one used by banks when they trade with each other, displayed by market-data terminals and on Google Finance. No markup, no spread, no hidden fee.
Retail rate
The retail rate is the mid-market rate plus a markup (spread) added by a bank, broker, or money transfer service. This markup typically ranges from 0.5% to 5% depending on the provider and the currency pair. When your app shows a retail rate, users are seeing an inflated price that benefits the rate provider, not the user.
Example: If the mid-market EUR/USD rate is 1.0850, a bank might show a retail rate of 1.0750 (buy) and 1.0950 (sell). That is a 1% spread. On a $100,000 transaction, that is $1,000 in hidden markup. For fintech applications, you want mid-market rates so your users see the real price and you add your own transparent fee on top.
Which APIs provide mid-market rates?
Not all of them. Some providers source data from central banks (daily reference rates, not true market rates). Others aggregate from retail sources that include spreads. Only a few provide genuine mid-market rates aggregated from institutional market data. This is one of the key differentiators in the comparison below.
Side-by-Side Comparison
Here is how the 5 APIs compare. Competitor figures are taken from each provider's public pricing or documentation page as of October 2026 and can change; check the provider before committing.
| API | Update Frequency | Data Source | Delivery | Free Tier | Entry Paid Plan |
|---|---|---|---|---|---|
| AllRatesToday | Every 60s (mid-market) | Institutional FX market data | REST only | Free API key, no CC (non-commercial) | From €4.99/mo |
| OANDA | Streaming / tick-level (per its docs) | Proprietary pricing engine | REST + streaming | No free data API | Quote-based |
| Twelve Data | Real-time quotes + intraday candles (1min) | Multiple feeds | REST + WebSocket | 800 req/day, 8/min | Per its pricing page |
| Alpha Vantage | Real-time quote + intraday candles (1min) | Multiple feeds | REST | 25 req/day | Per its pricing page |
| Fixer.io | Hourly (free), faster on paid tiers per its pricing page | ECB + commercial | REST | 100 req/mo, HTTPS, historical | $14.99/mo |
Key takeaway: Two different products are being compared here. OANDA, Twelve Data and Alpha Vantage are market-data vendors with streaming or intraday candle data for trading and charting. AllRatesToday and Fixer are rate APIs: a single mid-market (or reference) rate per pair, refreshed on a schedule, priced for payments and back-office use. Pick by category first, then by price. Not in the table but in the same category as Fixer: Open Exchange Rates (free 1,000 req/mo, hourly, USD base; paid from $12/mo).
1. AllRatesToday — Best Fit for Payments, Invoicing and Pricing
AllRatesToday, our own service, aggregates institutional foreign exchange market data into a mid-market rate per pair, refreshed every 60 seconds and served over REST, alongside the official tables of 123 central banks and 6 tax authorities. It is built for developers who need a dependable current rate for payments, invoicing, pricing and portfolio valuation without market-data vendor pricing.
Why Institutional FX Market Data Matters
When AllRatesToday says "mid-market rate," it means a midpoint derived from institutional market bid/ask quotes, not an average of retail rates or a once-a-day central bank reference rate. You get one mid rate per pair with a timestamp; you do not get the underlying bid and ask.
Fetch Real-Time Rates
// JavaScript / Node.js
const response = await fetch(
"https://allratestoday.com/api/v1/rates?source=USD&target=EUR",
{
headers: { "Authorization": "Bearer YOUR_API_KEY" }
}
);
const data = await response.json();
console.log(`USD/EUR: ${data.rate}`);
console.log(`Updated: ${data.time}`); // Timestamp of last update Python — Real-Time Rate with Timestamp
from allratestoday import AllRatesToday
client = AllRatesToday("YOUR_API_KEY")
# Get real-time mid-market rate
rate = client.get_rate("EUR", "USD")
print(f"EUR/USD mid-market: {rate}")
# Get all rates against EUR
all_rates = client.get_rates("EUR")
for currency, value in all_rates.items():
print(f"EUR/{currency}: {value}") Polling for Near-Real-Time Updates (no WebSocket)
import time
import requests
API_KEY = "YOUR_API_KEY"
PAIR = ("USD", "JPY")
while True:
response = requests.get(
"https://allratestoday.com/api/v1/rates",
params={"source": PAIR[0], "target": PAIR[1]},
headers={"Authorization": f"Bearer {API_KEY}"}
)
data = response.json()
print(f"[{data['time']}] {PAIR[0]}/{PAIR[1]}: {data['rate']}")
time.sleep(60) # Poll every 60 seconds (matches API update frequency) Historical Rates for Backtesting (paid plans)
import requests
import pandas as pd
API_KEY = "YOUR_API_KEY"
response = requests.get(
"https://allratestoday.com/api/historical-rates",
params={
"source": "EUR",
"target": "USD",
"period": "30d"
},
headers={"Authorization": f"Bearer {API_KEY}"}
)
data = response.json()
df = pd.DataFrame(data["data"])
df["date"] = pd.to_datetime(df["date"])
df.set_index("date", inplace=True)
# Calculate daily returns for backtesting
df["return"] = df["rate"].pct_change()
print(f"Annualized volatility: {df['return'].std() * (252 ** 0.5):.4f}") Data source transparency: AllRatesToday explicitly states that its rates come from institutional foreign exchange market data. Many competing APIs are vague about their data sources, saying only "multiple providers" or "commercial data." When you are building a financial product, you need to know where your data comes from.
- Data source: institutional foreign exchange market data
- Rate type: Mid-market (no markup)
- Update frequency: Every 60 seconds
- Currencies: 160+ including majors, minors, and exotics
- Free tier: no credit card required (non-commercial)
- SDKs: Official packages for Python (PyPI), JavaScript (npm), and PHP (Packagist)
- Historical data: Included on paid plans from €4.99/mo
2. OANDA — Best for Trading and Execution
OANDA is one of the most recognized names in forex. It is a regulated broker and a licensed market-data vendor: its v20 trading API streams prices (bid and ask) over HTTP streaming and provides candles down to 5-second granularity, and its separate Exchange Rates API serves averaged bid/ask/midpoint rates for business use. For anything that reacts to price moves, this is the right category of product and the fastest on this list.
The catch: there is no free data API. The trading API requires a funded or demo trading account, and the Exchange Rates API is licensed commercially with pricing by quote. Onboarding is geared toward enterprise integrations rather than a quick developer sign-up.
import requests
# OANDA Exchange Rates API (paid)
response = requests.get(
"https://www.oanda.com/rates/api/v2/rates/spot.json",
params={
"base": "EUR",
"quote": "USD",
"decimal_places": "all"
},
headers={"Authorization": "Bearer YOUR_OANDA_API_KEY"}
)
data = response.json()
midpoint = data["quotes"][0]["midpoint"]
print(f"EUR/USD midpoint: {midpoint}") - Data source: Proprietary pricing engine
- Rate type: Midpoint of bid/ask (effectively mid-market)
- Update frequency: Streaming / tick-level on the trading API; averaged rates on the Exchange Rates API (per its docs)
- Currencies: 200+ (Exchange Rates API)
- Free tier: None — trading account or commercial licence required
- Best for: Trading platforms, execution, anything needing bid/ask or sub-second data
- Limitation: No free tier, quote-based pricing, enterprise sales process
3. Twelve Data — Best for Charting and Multi-Asset Apps
Twelve Data is a multi-asset market-data provider (stocks, ETFs, crypto, forex). For forex it offers real-time quotes, intraday candles down to 1-minute, and a WebSocket stream on paid plans, which makes it a genuine option for charting and lightweight trading tools. The free tier offers 800 API requests per day at 8 per minute, which is fine for development but tight for production traffic.
import requests
API_KEY = "YOUR_TWELVE_DATA_KEY"
response = requests.get(
"https://api.twelvedata.com/exchange_rate",
params={
"symbol": "EUR/USD",
"apikey": API_KEY
}
)
data = response.json()
print(f"EUR/USD: {data['rate']}")
print(f"Updated: {data['timestamp']}") - Data source: Multiple aggregated feeds
- Rate type: Varies — data source not explicitly stated
- Update frequency: Real-time quotes, 1-minute candles, WebSocket streaming on paid plans (per its docs)
- Currencies: 120+ forex pairs
- Free tier: 800 requests/day, 8 requests/minute
- Best for: Charting, dashboards, apps that need forex alongside stocks and ETFs
- Limitation: Tight rate limits on the free tier; streaming is paid; upstream sources not named
4. Alpha Vantage — Good for Academic and Research Use
Alpha Vantage is well known in the academic and hobbyist community for its broad financial data coverage. Its forex endpoints provide a real-time quote with bid and ask, plus intraday (1-minute and up), daily, weekly and monthly candles. The free tier is limited to 25 requests per day, which is fine for a research notebook but unusable for any production application; paid plans raise the limits per its pricing page.
import requests
API_KEY = "YOUR_ALPHA_VANTAGE_KEY"
response = requests.get(
"https://www.alphavantage.co/query",
params={
"function": "CURRENCY_EXCHANGE_RATE",
"from_currency": "EUR",
"to_currency": "USD",
"apikey": API_KEY
}
)
data = response.json()
rate_data = data["Realtime Currency Exchange Rate"]
print(f"EUR/USD: {rate_data['5. Exchange Rate']}")
print(f"Bid: {rate_data['8. Bid Price']}")
print(f"Ask: {rate_data['9. Ask Price']}") - Data source: Multiple aggregated feeds
- Rate type: Provides bid, ask, and exchange rate
- Update frequency: Real-time quote plus intraday candles from 1-minute (per its docs)
- Currencies: 150+ pairs
- Free tier: 25 requests/day
- Best for: Academic research, Jupyter notebooks, prototyping
- Limitation: Extremely restrictive free tier, verbose JSON response format, upstream sources not named
5. Fixer.io — Hourly Reference Rates, Not Real-Time
Fixer is included because it appears in many "best forex API" lists. It is a solid rate API, but it is not a real-time feed. Per its pricing page, the free plan gives 100 requests per month, hourly updates, HTTPS and historical rates; paid plans start at $14.99/mo and update more often. Rates are blended from ECB and commercial sources.
If you need sub-minute data, Fixer is not the right tool. It suits accounting, invoicing and reporting where an hourly reference rate is sufficient.
import requests
API_KEY = "YOUR_FIXER_KEY"
response = requests.get(
"https://data.fixer.io/api/latest",
params={
"access_key": API_KEY,
"base": "EUR",
"symbols": "USD,GBP,JPY,CHF"
}
)
data = response.json()
for currency, rate in data["rates"].items():
print(f"EUR/{currency}: {rate}") - Data source: ECB reference rates + commercial feeds (paid plans)
- Rate type: Reference rate (not true mid-market)
- Update frequency: Hourly on free; faster on paid tiers per its pricing page
- Currencies: 170+
- Free tier: 100 requests/month, HTTPS, historical included
- Paid: From $14.99/mo
- Best for: Hourly reference rates for accounting and invoicing (not real-time forex)
- Limitation: Not real-time, tiny free quota, no streaming
Data Source Transparency: Why It Matters for Fintech
When you are building a financial application, regulators and auditors will ask where your exchange rate data comes from. "We use an API" is not a sufficient answer. You need to know the upstream data source, and your compliance team needs to be able to verify it.
Here is how the five APIs compare on data source transparency:
- AllRatesToday: States that rates are mid-market, aggregated from institutional foreign exchange market data, timestamped on every response. Does not name individual upstream providers and is not a licensed market-data vendor.
- OANDA: Proprietary pricing engine fed by its own liquidity providers. A regulated broker and licensed vendor, which is the strongest provenance on this list for trading use; the methodology itself is proprietary.
- Twelve Data: States "multiple data feeds" without naming specific providers. Acceptable for general use but may not satisfy compliance requirements.
- Alpha Vantage: Vague about sources. Documentation does not specify upstream data providers for forex data.
- Fixer.io: States ECB plus commercial sources without naming the commercial providers.
For production fintech applications: Choose an API that states what it serves. For compliance, audit and regulatory reporting, the rate that is usually cited is an official central-bank rate rather than any vendor's market rate; AllRatesToday also serves official central-bank tables under each bank's own publication date for exactly that purpose.
Latency and Performance for Production Apps
Response time matters when your application displays rates in a UI or converts during a checkout flow. We do not publish competitor latency figures here because they depend heavily on client region, plan and time of day, and a one-off measurement would not be reproducible. Two general points hold: REST latency is dominated by network distance, so an edge-served API will usually answer in tens of milliseconds from most regions, while an origin-served API will vary more; and for anything under about 100ms, the difference is invisible in a checkout flow. For AllRatesToday's own numbers and methodology see our performance benchmarks.
Building a Real-Time Forex Widget
Here is a practical example of a live forex rate ticker using AllRatesToday. The keyed API is meant to be called from your server so your key stays private (it does not allow cross-origin browser calls), so a small backend route holds the key and caches rates for 60 seconds:
// server.js (Express): your backend holds the key
let cache = { at: 0, rates: null };
app.get("/api/fx", async (req, res) => {
if (!cache.rates || Date.now() - cache.at > 60000) {
const response = await fetch(
"https://allratestoday.com/api/v1/rates?source=USD&target=EUR,GBP,JPY,CHF,AUD,CAD",
{ headers: { "Authorization": `Bearer ${process.env.ALLRATESTODAY_API_KEY}` } }
);
const rows = await response.json(); // [{ rate, source, target, time }, ...]
cache = { at: Date.now(), rates: Object.fromEntries(rows.map(r => [r.target, r.rate])) };
}
res.set("Cache-Control", "public, max-age=60").json({ rates: cache.rates });
}); The ticker in the page then reads from your own route:
// Real-time forex ticker (browser JavaScript)
const BASE = "USD";
const TARGETS = ["EUR", "GBP", "JPY", "CHF", "AUD", "CAD"];
async function fetchRates() {
const response = await fetch("/api/fx"); // your own backend route
return response.json();
}
async function updateTicker() {
const data = await fetchRates();
const container = document.getElementById("forex-ticker");
container.innerHTML = TARGETS.map(currency => {
const rate = data.rates[currency];
return `<span class="ticker-item">${BASE}/${currency}: ${rate.toFixed(4)}</span>`;
}).join("");
}
// Update every 60 seconds
updateTicker();
setInterval(updateTicker, 60000); Caching Strategy for Production
Whatever your plan, you should cache exchange rates to minimize API calls and improve response times for your users:
import redis
import json
import requests
r = redis.Redis(host="localhost", port=6379, db=0)
API_KEY = "YOUR_API_KEY"
def get_rate(source: str, target: str) -> float:
"""Get exchange rate with 60-second Redis cache."""
cache_key = f"fx:{source}:{target}"
cached = r.get(cache_key)
if cached:
return float(cached)
response = requests.get(
"https://allratestoday.com/api/v1/rates",
params={"source": source, "target": target},
headers={"Authorization": f"Bearer {API_KEY}"}
)
rate = response.json()["rate"]
r.setex(cache_key, 60, str(rate)) # Cache for 60 seconds
return rate
# Usage
eur_rate = get_rate("USD", "EUR")
print(f"USD/EUR: {eur_rate}") Which One Should You Pick?
- Trading, execution, bid/ask, sub-second data: OANDA. It is the only regulated broker and licensed market-data vendor on this list, with streaming prices and 5-second candles. Budget for a commercial licence or a trading account.
- Charting, dashboards, intraday candles, multi-asset apps: Twelve Data. Real-time quotes, 1-minute candles and a WebSocket stream on paid plans, with forex alongside stocks and crypto.
- Research notebooks and prototypes: Alpha Vantage. Bid/ask and intraday candles for free, but 25 requests a day rules out production.
- Payments, invoicing, checkout pricing, portfolio valuation: AllRatesToday. A mid-market rate refreshed every 60 seconds over REST, 160+ currencies, a free API key with no credit card for non-commercial use, historical data and commercial use from €4.99/mo, official Python, JavaScript and PHP SDKs. Not for trading: no streaming, no ticks, no bid/ask.
- Accounting and reporting on an hourly reference rate: Fixer ($14.99/mo) or Open Exchange Rates ($12/mo). If the rule you follow names a central bank, use that bank's official rate instead; AllRatesToday serves those too.
If you are unsure, ask one question: does anything in your product react to a price move within a minute? If yes, you need a streaming vendor. If no, a 60-second mid-market REST API is cheaper and simpler to operate.
Quick Reference
- Latest rates:
GET /api/v1/rates?source=USD&target=EUR - All pairs:
GET /api/v1/rates?source=USD - Historical:
GET /api/historical-rates?source=USD&target=EUR&period=30d(paid plans) - Convert:
GET /api/v1/rates?source=USD&target=JPY&amount=10000 - Auth:
Authorization: Bearer YOUR_API_KEY - Data source: institutional foreign exchange market data feeds
- Rate type: Mid-market (no markup)
- Update frequency: Every 60 seconds (REST only; no streaming)
Get Real-Time Mid-Market Forex Rates
Mid-market exchange rates updated every 60 seconds over REST, for payments, invoicing and pricing. Free API key, no credit card, official SDKs for Python, JavaScript, and PHP. Compare all options on our AllRatesToday exchange rate API page.
Get Your Free API Key