Use Frankfurter when: You need completely free with no API key management EUR/ECB base rates are acceptable for your use case You want to self-host the API for compliance or reliability reasons Daily update frequency is sufficient Use ExchangeRate-API when: You need any base currency on the free tier 1,500 requests/month is sufficient with server-side caching You want the best free-tier UX and documentation quality Use Open Exchange Rates when: You're building a production app with USD as the pr

Best Free Currency Exchange Rate API 2026

Most developer projects that need currency conversion don't need enterprise SLAs — they need a free or near-free API that won't fail in production. But the "free" label on currency APIs hides significant differences: some cap at 100 requests/month, others give 1,500/month with no rate limiting, and one is completely unlimited with no API key required. This guide ranks the best free currency exchange rate APIs specifically for developers who want to spend nothing (or very little) while getting reliable, current rates.

TL;DR

Rank	API	Free Tier	Key Constraint
1	Frankfurter	Unlimited	ECB rates only (weekdays), no key required
2	ExchangeRate-API	1,500 req/month	Daily updates on free tier
3	Open Exchange Rates	1,000 req/month	USD base only on free
4	Fixer	100 req/month	EUR base only on free
5	Currencybeacon	5,000 req/month	Hourly updates

Frankfurter is the best for zero-cost projects — truly free, open source, no API key, self-hostable. ExchangeRate-API wins for the best free-tier balance: 1,500 requests/month, 160+ currencies, simple REST API, and daily rate updates. Currencybeacon wins if you need the highest request volume on a free plan.

Full Comparison

	Frankfurter	ExchangeRate-API	Open Exchange Rates	Fixer	Currencybeacon
Free Requests	Unlimited	1,500/month	1,000/month	100/month	5,000/month
Update Frequency	Daily (ECB, ~16:00 CET)	Daily	Hourly (free: hourly)	Hourly (free: daily)	Hourly
Currencies	33 (ECB basket)	160+	170+	170+	180+
Base Currency	EUR or any ECB currency	Any	USD only (free)	EUR only (free)	Any
API Key Required	No	Yes	Yes	Yes	Yes
HTTPS	Yes	Yes	Yes	Yes	Yes
Historical Rates	Yes (1999–present)	Yes (30-day on free)	Yes (2-year on free)	Yes (on paid)	Yes (30-day on free)
Time-series	Yes	No (free)	Yes	Yes (paid)	No (free)
Self-hostable	Yes	No	No	No	No
Crypto	No	No	No	No	Yes
Open Source	Yes	No	No	No	No

API Profiles

1. Frankfurter — Zero-Cost, No Key Required

Frankfurter is the cleanest solution for free currency data. It's powered by the European Central Bank's daily reference rates, requires no API key, has no rate limits, and is available as an open-source self-hosted option.

# Get current EUR rates
curl "https://api.frankfurter.app/latest"

# Convert 100 USD to EUR and GBP
curl "https://api.frankfurter.app/latest?amount=100&from=USD&to=EUR,GBP"

# Historical rates (2020-01-15)
curl "https://api.frankfurter.app/2020-01-15"

# Time series (last 30 days)
curl "https://api.frankfurter.app/2025-03-01..2025-04-01?from=USD&to=EUR"

// Node.js integration — no SDK needed
async function convertCurrency(
  amount: number,
  from: string,
  to: string
): Promise<number> {
  const res = await fetch(
    `https://api.frankfurter.app/latest?amount=${amount}&from=${from}&to=${to}`
  );
  const data = await res.json();
  return data.rates[to];
}

Limitations: ECB only publishes rates on business days (16:00 CET), so there are no weekend rates. The currency basket covers 33 major currencies — missing many emerging market currencies. Not suitable for crypto or real-time forex trading.

Best for: Invoicing systems, financial reports, pricing display in apps where ECB rates are acceptable and daily updates are sufficient.

2. ExchangeRate-API — Best Free Tier for General Use

ExchangeRate-API offers the best balance of free-tier generosity and feature coverage for typical developer use cases.

const BASE_URL = 'https://v6.exchangerate-api.com/v6';
const API_KEY = process.env.EXCHANGE_RATE_API_KEY;

// Get all rates for USD base
const res = await fetch(`${BASE_URL}/${API_KEY}/latest/USD`);
const { conversion_rates } = await res.json();
// conversion_rates.EUR, .GBP, .JPY, etc.

// Pair conversion
const pairRes = await fetch(`${BASE_URL}/${API_KEY}/pair/USD/EUR/100`);
const { conversion_result } = await pairRes.json();
// conversion_result: 91.50 (100 USD = 91.50 EUR)

Free tier: 1,500 requests/month = 50 requests/day. With daily rate caching (rates only change once per day), 1,500 requests serves most applications. Free tier supports any base currency — a significant advantage over Open Exchange Rates and Fixer.

Caching strategy for the free tier:

// Cache rates in Redis/memory to stay within free limits
import { cache } from './cache';

export async function getExchangeRates(base: string): Promise<Record<string, number>> {
  const cacheKey = `rates:${base}:${new Date().toISOString().slice(0, 10)}`;
  
  const cached = await cache.get(cacheKey);
  if (cached) return JSON.parse(cached);
  
  const res = await fetch(`${BASE_URL}/${API_KEY}/latest/${base}`);
  const { conversion_rates } = await res.json();
  
  // Cache until midnight UTC
  const secondsUntilMidnight = 86400 - (Date.now() / 1000) % 86400;
  await cache.set(cacheKey, JSON.stringify(conversion_rates), Math.floor(secondsUntilMidnight));
  
  return conversion_rates;
}

3. Open Exchange Rates — Developer Standard for Production

Open Exchange Rates is the most widely deployed currency API in production, used by Shopify, Etsy, and thousands of enterprise apps. Their free tier (1,000 requests/month) limits you to USD as the base currency — converting between non-USD pairs requires client-side math (GBP/EUR = GBP/USD ÷ EUR/USD).

import OpenExchangeRates from 'open-exchange-rates';

const oxr = new OpenExchangeRates({ appId: APP_ID });
const rates = await oxr.latest();

// Convert USD to GBP
function convertUSD(amount: number, to: string): number {
  return amount * rates[to]; // rates always relative to USD
}

// Convert EUR to GBP (via USD)
function convert(amount: number, from: string, to: string): number {
  const usdAmount = amount / rates[from];
  return usdAmount * rates[to];
}

Best for: Apps that primarily work in USD or can tolerate the cross-rate calculation. Paid plans ($12–$97/month) unlock hourly updates, any base currency, and historical data.

4. Fixer — APILayer's ECB-Powered Option

Fixer (by APILayer) provides ECB reference rates with a very restrictive free tier: 100 requests/month, EUR base only. Despite these limits, it's worth knowing for its historical data depth (back to 1999) and the AIXLayer ecosystem.

# Fixer free tier — EUR base only
curl "http://data.fixer.io/api/latest?access_key=$FIXER_KEY&symbols=USD,GBP,JPY"

# Historical rates
curl "http://data.fixer.io/api/2024-01-15?access_key=$FIXER_KEY"

Honest assessment: 100 requests/month is impractical for any live application without aggressive caching. The free tier is really for evaluation. Paid plans start at $14/month for 10K requests with any base currency.

5. Currencybeacon — Highest Free Request Volume

Currencybeacon's free tier is the most generous by request count: 5,000 requests/month with hourly rate updates and support for 180+ currencies and cryptocurrencies.

const res = await fetch(
  `https://api.currencybeacon.com/v1/latest?api_key=${API_KEY}&base=USD&symbols=EUR,GBP,JPY`
);
const { rates } = await res.json();

Catch: The API reliability and documentation quality are a step below ExchangeRate-API and Open Exchange Rates. Community reports of occasional 5-10 minute outages make it less suitable for mission-critical currency display. Best for internal tools, analytics, or scenarios where brief unavailability is acceptable.

Choosing for Your Use Case

Static Display (pricing, e-commerce labels)

Use Frankfurter — cache the daily rate at server start, no API key management, no request limits to worry about.

User-facing currency conversion (10–100 users/day)

Use ExchangeRate-API free tier — 1,500 requests/month is comfortable, any base currency, clean API.

Production app with moderate traffic

Use Open Exchange Rates free tier with aggressive caching (update rates once per hour, cache for all users). 1,000 requests/month = 33/day = once every 45 minutes for a single rate fetch.

Need historical data for analytics

Use ExchangeRate-API paid ($8/month) for 30-day history, or Open Exchange Rates paid for 2-year history. Frankfurter's free API includes history back to 1999 if ECB rates are acceptable.

Crypto + fiat in one API

Use Currencybeacon — the only free option supporting both asset classes.

Rate Caching Best Practices

The key to staying within free tiers is server-side caching. Exchange rates are stable within a day — there's no reason to fetch rates per user request.

// Centralized rate cache with 1-hour TTL
class CurrencyCache {
  private rates: Map<string, { data: Record<string, number>; ts: number }> = new Map();
  private TTL = 60 * 60 * 1000; // 1 hour

  async getRates(base: string): Promise<Record<string, number>> {
    const cached = this.rates.get(base);
    if (cached && Date.now() - cached.ts < this.TTL) {
      return cached.data;
    }
    
    const data = await this.fetchRates(base);
    this.rates.set(base, { data, ts: Date.now() });
    return data;
  }

  private async fetchRates(base: string) {
    const res = await fetch(
      `https://v6.exchangerate-api.com/v6/${process.env.EXCHANGE_RATE_API_KEY}/latest/${base}`
    );
    const json = await res.json();
    return json.conversion_rates;
  }
}

With a 1-hour cache, a single ExchangeRate-API free account (1,500 requests/month) supports 730 distinct base-currency rate fetches per month — sufficient for most production applications. Only large-scale platforms with many distinct base currencies need to move to paid plans.

When to Use Which

Use Frankfurter when:

You need completely free with no API key management
EUR/ECB base rates are acceptable for your use case
You want to self-host the API for compliance or reliability reasons
Daily update frequency is sufficient

Use ExchangeRate-API when:

You need any base currency on the free tier
1,500 requests/month is sufficient with server-side caching
You want the best free-tier UX and documentation quality

Use Open Exchange Rates when:

You're building a production app with USD as the primary currency
You want the most established API with the deepest ecosystem integrations
You're comfortable upgrading to a paid plan as traffic grows

Use Currencybeacon when:

You need crypto + fiat coverage
You want the highest free request volume (5,000/month)
Occasional brief outages are tolerable (internal tools, analytics)