5 Free Exchange Rate APIs With No API Key Required (2026)
Compared 5 production-ready exchange rate APIs that work with zero registration. Update frequency, currency coverage, historical data support, rate limits, and copy-paste curl examples.
Context above, deep read below. Use the TOC to move section by section without losing the thread.
5 Free Exchange Rate APIs With No API Key Required (2026)
If you're prototyping a checkout flow, a remittance tool, a travel app, or a quick personal-finance script, the last thing you want to do is sign up for an account, hand over a credit card, and rotate an API key — just to convert USD to EUR.
This is a real comparison of 5 exchange rate APIs that you can hit right now, with zero registration, from a fresh terminal. I tested every endpoint on the day of writing (2026-05-16); every code sample below ran successfully against the actual service.
TL;DR — pick by use case:
| Use case | Best pick | Why |
|---|---|---|
| Quickest "just give me USD rates" | open.er-api.com | Single GET, 166 currencies, JSON |
| Need historical data (any date) | Frankfurter | Time-series endpoint, ECB rates |
| Maximum currency coverage (incl. crypto) | Fawazahmed0 currency-api | 341 currencies, static JSON via jsdelivr CDN |
| Official Eurozone reference rate | ECB XML feed | Direct from European Central Bank |
| CAD-pair / Canadian official rates | Bank of Canada Valet | Official, signed-by-central-bank quality |
Why "no API key" matters
People search for "no API key" not because they don't understand authentication — they understand it perfectly well. They want one of three things:
- Speed of prototyping — a hackathon, a sketch, a one-off script. You'll measure the API in seconds-to-first-response, not in monthly invoice.
- Avoiding key-rotation overhead — if you don't have a secret, you can't leak it, you can't accidentally commit it, and you don't need a vault.
- Avoiding lock-in to a commercial vendor — most "free" APIs that require a key gate the good stuff behind a paid tier and quietly track your traffic.
For low-volume reads of public, daily-updated data like exchange rates, no-key is a perfectly defensible production choice. The "use a paid commercial API" answer kicks in when you need sub-minute updates, SLAs, or commercial guarantees — and we'll cover that threshold at the end.
1. open.er-api.com — the simplest possible answer
ExchangeRate-API runs a no-key endpoint at open.er-api.com. It's the closest thing to "what most people actually need."
curl https://open.er-api.com/v6/latest/USD
Response (truncated):
{
"result": "success",
"base_code": "USD",
"time_last_update_utc": "Sat, 16 May 2026 00:02:31 +0000",
"rates": {
"EUR": 0.859854,
"JPY": 158.55,
"CNY": 6.8106,
"GBP": 0.7401,
"...": "..."
}
}
| Property | Value |
|---|---|
| Currencies | 166 |
| Update frequency | Daily (24h) |
| Base currency | USD only on the no-key endpoint (other bases require a key) |
| Historical data | No (key required) |
| HTTPS | Yes |
| Rate limit | Fair-use; no published hard cap |
| Format | JSON |
Best for: any app where USD is your home base and "yesterday's rate" is fresh enough. Watch out: you must pin USD as base. If your home base is EUR/CNY/etc., you'll either need to derive rates client-side (rate[X] / rate[Y]) or use a different API.
2. Frankfurter — historical data and ECB rates, no key
Frankfurter (now at api.frankfurter.dev — the older api.frankfurter.app returns a 301 redirect) is built around the European Central Bank reference rates and is the only no-key option here with a real historical endpoint.
# Latest
curl 'https://api.frankfurter.dev/v1/latest?base=USD&symbols=EUR,JPY,CNY'
# Historical (any date back to 1999)
curl 'https://api.frankfurter.dev/v1/2024-01-02?base=USD&symbols=EUR'
# Time series
curl 'https://api.frankfurter.dev/v1/2026-01-01..2026-05-16?base=USD&symbols=EUR'
Response from the latest endpoint:
{
"amount": 1.0,
"base": "USD",
"date": "2026-05-15",
"rates": { "CNY": 6.8106, "EUR": 0.85999, "JPY": 158.55 }
}
| Property | Value |
|---|---|
| Currencies | ~30 (ECB reference set) |
| Update frequency | Daily, ~16:00 CET on TARGET2 business days |
| Base currency | Any of the supported currencies |
| Historical data | Yes — back to 1999 |
| Time series | Yes — single endpoint |
| HTTPS | Yes |
| Rate limit | None published; be a good citizen |
| Format | JSON |
Best for: any app that needs charts, backfills, or "show me USD/EUR on the day I bought it." Watch out: only 30-ish currencies (the major liquid pairs). No exotic crosses, no crypto.
3. Fawazahmed0 currency-api — widest coverage via CDN
This one is structurally different from the rest: it's not a hosted API, it's a daily-updated static JSON dataset served from the jsdelivr CDN. Which means: no rate limit, edge-cached globally, and 341 currencies including crypto.
# All USD pairs (~341 currencies)
curl https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.json
# Single pair (USD → EUR)
curl https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd/eur.json
# Specific date
curl https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@2024-01-02/v1/currencies/usd.json
Response:
{
"date": "2026-05-16",
"usd": {
"eur": 0.86023046,
"cny": 6.80859036,
"jpy": 158.62,
"btc": 0.0000172,
"...": "..."
}
}
| Property | Value |
|---|---|
| Currencies | 341 (including crypto) |
| Update frequency | Daily |
| Base currency | Any |
| Historical data | Yes (date in URL) |
| HTTPS | Yes (via jsdelivr) |
| Rate limit | None — it's a static CDN file |
| Format | JSON |
Best for: apps that need exotic currencies, crypto-fiat conversions, or zero-latency edge delivery. Watch out: it's a community-maintained dataset. Mission-critical compliance use cases should use an official source. The repo lives on GitHub — give it a star.
4. European Central Bank XML feed — straight from the source
If you want the canonical, central-bank-issued reference rate with no intermediary, the ECB publishes a daily XML file at a stable URL that's been alive for two decades:
curl https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml
Response (excerpt):
<Cube>
<Cube time='2026-05-16'>
<Cube currency='USD' rate='1.1628'/>
<Cube currency='JPY' rate='184.36'/>
<Cube currency='GBP' rate='0.87050'/>
<Cube currency='CNY' rate='8.0210'/>
</Cube>
</Cube>
| Property | Value |
|---|---|
| Currencies | 30 (against EUR base) |
| Update frequency | ~16:00 CET, TARGET2 business days only |
| Base currency | EUR only |
| Historical data | Yes — separate URLs for 90-day and "all dates since 1999" archives |
| HTTPS | Yes |
| Rate limit | None published; clearly intended for periodic polling, not high-frequency reads |
| Format | XML |
Best for: any app where you want the most institutionally-credible source, or where you're already in the Eurozone and don't need a USD base.
Watch out: XML, not JSON — you'll parse with xml2js, lxml, etc. EUR-only base.
5. Bank of Canada Valet — official Canadian rates
If you're building anything Canada-centric, the Bank of Canada exposes a clean, no-key REST API called Valet. It's the canonical source for CAD pairs.
# Latest USD/CAD observation
curl 'https://www.bankofcanada.ca/valet/observations/FXUSDCAD/json?recent=1'
# Last 30 days
curl 'https://www.bankofcanada.ca/valet/observations/FXUSDCAD/json?recent=30'
Response:
{
"observations": [
{ "d": "2026-05-15", "FXUSDCAD": { "v": "1.3752" } }
]
}
| Property | Value |
|---|---|
| Currencies | All CAD pairs the Bank of Canada publishes (~25) |
| Update frequency | Once per business day, ~16:30 ET |
| Base currency | CAD (each series is one pair) |
| Historical data | Yes — go back to inception of each series |
| HTTPS | Yes |
| Rate limit | Fair-use, no hard cap published |
| Format | JSON or XML or CSV (choose via URL) |
Best for: Canadian fintech, anything where you need a regulator-grade CAD source. Watch out: Each currency pair is a separate series. You request one pair at a time.
When to outgrow the free tier
The honest threshold:
- Updates more frequent than daily → you need a commercial feed (e.g., Open Exchange Rates paid, ExchangeRate-API paid, Frankfurter has no realtime). Daily is the bound on every API in this list.
- SLAs or signed agreements → commercial vendor or self-hosted snapshot of a paid feed.
- More than ~100k requests/day → check Terms of Use. Most of these will tolerate it for legitimate apps but it's polite to cache aggressively at your edge.
- Anything regulated (FX trading, broker-dealer use, AML) → use a regulator-approved source. The free APIs above are reference data, not transactional data.
For 95% of side-project, internal-tool, and small-SaaS use cases, you'll never cross that line.
Recap — pick your default
| If you remember nothing else… | …default to |
|---|---|
| Generic "give me rates" | open.er-api.com |
| You need historical | Frankfurter |
| You need crypto or exotic currencies | Fawazahmed0 currency-api |
| You need an official central bank source | ECB (Eurozone) or Bank of Canada Valet (Canada) |
All five are still alive, free, and key-less as of May 2026 — every code sample above was tested against the live endpoint.
Related on XScanHub:
Jump to a section
Pass this article along
Send it to your preferred platform or copy the link.
Before you move on
Next step
Finished reading? Continue comparing tools in the directory.
Browse tools