DEV Community: Exchange Rate API

Exchange Rate API Unit Testing: Mocks, Fixtures and Contract Tests

Exchange Rate API — Wed, 11 Nov 2026 14:29:29 +0000

Code that depends on live FX is awkward to test. The rate changes every minute, the network may be down in CI, and a test that asserts 0.9215 passes today and fails tomorrow. This guide shows how to test exchange rate API code properly: inject a rate provider, use fixtures with the real response shape, mock HTTP in Vitest or Jest with msw and in Python with responses, cover the 401 and 429 paths, and run one contract test against the real API every night.

Rule one: never assert on live values

A test that calls the real API and checks a number is not a test. It is a coin toss with a delay. Split the work in two:

Unit tests run offline with frozen rates. They check your logic: rounding, cross rates, caching, error handling.
A contract test runs on a schedule against the real API. It checks that the response still has the shape your code expects.

Inject a rate provider

The easiest code to test never calls fetch from business logic. It depends on an interface, and the HTTP client is one implementation of it.

// rates.ts
export interface RateProvider {
  getRate(source: string, target: string): Promise<number>;
}

export class RateError extends Error {
  constructor(public code: string, public status: number, public resetsAt?: string | null) {
    super(code);
  }
}

export class AllRatesProvider implements RateProvider {
  constructor(private apiKey: string, private fetchFn: typeof fetch = fetch) {}

  async getRate(source: string, target: string): Promise<number> {
    const url = `https://allratestoday.com/api/v1/rates?source=${source}&target=${target}`;
    const res = await this.fetchFn(url, {
      headers: { Authorization: `Bearer ${this.apiKey}` },
    });
    if (res.status === 401) throw new RateError('unauthorized', 401);
    if (res.status === 429) {
      throw new RateError('rate_limited', 429, res.headers.get('X-Monthly-Resets'));
    }
    if (!res.ok) throw new RateError('http_error', res.status);
    const data = await res.json();
    // The endpoint returns an array, even for one pair.
    if (!Array.isArray(data) || data.length === 0) throw new RateError('bad_response', res.status);
    return data[0].rate;
  }
}

export class FixedRateProvider implements RateProvider {
  constructor(private rates: Record<string, number>) {}
  async getRate(source: string, target: string): Promise<number> {
    const rate = this.rates[`${source}/${target}`];
    if (rate === undefined) throw new RateError('unknown_pair', 0);
    return rate;
  }
}

Business logic takes a RateProvider and never knows which one it got:

// pricing.ts
import type { RateProvider } from './rates';

export async function priceInMinorUnits(cents: number, currency: string, rates: RateProvider) {
  if (currency === 'USD') return cents;
  const rate = await rates.getRate('USD', currency);
  return Math.round(cents * rate);
}

Its tests need no network and no mocks, just frozen numbers:

// pricing.test.ts
import { describe, it, expect } from 'vitest';
import { FixedRateProvider } from './rates';
import { priceInMinorUnits } from './pricing';

const rates = new FixedRateProvider({ 'USD/EUR': 0.9215, 'USD/JPY': 151.37 });

describe('priceInMinorUnits', () => {
  it('converts and rounds', async () => {
    expect(await priceInMinorUnits(1999, 'EUR', rates)).toBe(1842);
  });
  it('leaves USD alone', async () => {
    expect(await priceInMinorUnits(1999, 'USD', rates)).toBe(1999);
  });
});

Fixtures with the real response shape

The HTTP client itself still needs tests, and those need fixtures that match the API exactly. The most common bug in exchange rate code is reading res.rate when the response is an array. A fixture with the real shape catches it.

[
  { "rate": 0.9215, "source": "USD", "target": "EUR", "time": "2026-04-03T12:00:00Z" }
]

Keep one fixture per case: a single pair, several targets (target=EUR,GBP,JPY returns one array with three objects), the 401 body and a 429. The 401 body is:

{ "error": "A valid API key is required", "hint": "Get a free API key at https://allratestoday.com/register" }

Mocking fetch with msw in Vitest or Jest

msw intercepts requests at the network layer, so your real client code runs unchanged. This works in Vitest and in Jest.

// rates.test.ts
import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
import { setupServer } from 'msw/node';
import { http, HttpResponse } from 'msw';
import { AllRatesProvider, RateError } from './rates';

const API = 'https://allratestoday.com/api/v1/rates';

const server = setupServer(
  http.get(API, ({ request }) => {
    const url = new URL(request.url);
    if (request.headers.get('Authorization') !== 'Bearer test-key') {
      return HttpResponse.json({ error: 'A valid API key is required' }, { status: 401 });
    }
    return HttpResponse.json([
      { rate: 0.9215, source: url.searchParams.get('source'),
        target: url.searchParams.get('target'), time: '2026-04-03T12:00:00Z' },
    ]);
  }),
);

beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));
afterEach(() => server.resetHandlers());
afterAll(() => server.close());

describe('AllRatesProvider', () => {
  it('reads the rate from the first array element', async () => {
    const p = new AllRatesProvider('test-key');
    expect(await p.getRate('USD', 'EUR')).toBe(0.9215);
  });

  it('throws unauthorized on 401', async () => {
    const p = new AllRatesProvider('wrong-key');
    await expect(p.getRate('USD', 'EUR')).rejects.toMatchObject({ code: 'unauthorized' });
  });

  it('surfaces the reset time on 429', async () => {
    server.use(http.get(API, () => new HttpResponse(null, {
      status: 429,
      headers: { 'X-Monthly-Limit': '5000', 'X-Monthly-Used': '5000',
                 'X-Monthly-Resets': '2026-12-01T00:00:00Z' },
    })));
    const err = await new AllRatesProvider('test-key').getRate('USD', 'EUR').catch((e) => e);
    expect(err).toBeInstanceOf(RateError);
    expect(err.resetsAt).toBe('2026-12-01T00:00:00Z');
  });
});

onUnhandledRequest: 'error' makes any request you did not mock fail the test, so a stray call to the real API never slips into a unit run. The quota headers only appear on 429 responses; a 200 carries no rate-limit headers, so do not write code that expects them there.

Python with responses and pytest

The same pattern in Python. The client:

# rates.py
import requests

API = "https://allratestoday.com/api/v1/rates"

class RateLimited(Exception):
    def __init__(self, resets_at):
        super().__init__("rate limited")
        self.resets_at = resets_at

def get_rate(source, target, key, session=requests):
    r = session.get(API, params={"source": source, "target": target},
                    headers={"Authorization": f"Bearer {key}"}, timeout=10)
    if r.status_code == 429:
        raise RateLimited(r.headers.get("X-Monthly-Resets"))
    r.raise_for_status()
    return r.json()[0]["rate"]

The tests, with responses matching both the query string and the header:

# test_rates.py
import pytest, requests, responses
from responses import matchers
from rates import API, get_rate, RateLimited

@responses.activate
def test_reads_first_element():
    responses.get(API,
        json=[{"rate": 0.9215, "source": "USD", "target": "EUR", "time": "2026-04-03T12:00:00Z"}],
        match=[matchers.query_param_matcher({"source": "USD", "target": "EUR"}),
               matchers.header_matcher({"Authorization": "Bearer test-key"})])
    assert get_rate("USD", "EUR", key="test-key") == 0.9215

@responses.activate
def test_401_raises():
    responses.get(API, status=401, json={"error": "A valid API key is required"})
    with pytest.raises(requests.HTTPError):
        get_rate("USD", "EUR", key="bad")

@responses.activate
def test_429_exposes_reset():
    responses.get(API, status=429, headers={"X-Monthly-Resets": "2026-12-01T00:00:00Z"})
    with pytest.raises(RateLimited) as exc:
        get_rate("USD", "EUR", key="test-key")
    assert exc.value.resets_at == "2026-12-01T00:00:00Z"

For logic above the client, pass a fake in place of get_rate with monkeypatch, exactly as with FixedRateProvider.

Freeze time as well as rates

If you cache rates, the cache has a TTL, and TTLs need a clock. Use vi.useFakeTimers() in Vitest, jest.useFakeTimers() in Jest or freezegun in Python, then advance the clock past 60 seconds and assert that the second call goes to the provider. Rates refresh every 60 seconds, so a 60-second cache is a sensible default; the caching guide covers the options.

A nightly contract test against the real API

Mocks only prove your code matches your fixtures. A contract test proves the fixtures still match the API. Keep it small, run it on a schedule, and read the key from CI secrets.

// tests/contract/rates.contract.test.ts
import { describe, it, expect } from 'vitest';

const KEY = process.env.ALLRATES_API_KEY;

describe.skipIf(!KEY)('AllRatesToday contract', () => {
  it('returns an array of rate objects', async () => {
    const res = await fetch('https://allratestoday.com/api/v1/rates?source=USD&target=EUR,GBP', {
      headers: { Authorization: `Bearer ${KEY}` },
    });
    expect(res.status).toBe(200);
    const data = await res.json();
    expect(Array.isArray(data)).toBe(true);
    expect(data.map((d: any) => d.target).sort()).toEqual(['EUR', 'GBP']);
    for (const d of data) {
      expect(d.source).toBe('USD');
      expect(typeof d.rate).toBe('number');
      expect(d.rate).toBeGreaterThan(0);
      expect(Date.now() - Date.parse(d.time)).toBeLessThan(24 * 3600 * 1000);
    }
  });

  it('rejects a bad key with 401', async () => {
    const res = await fetch('https://allratestoday.com/api/v1/rates?source=USD&target=EUR', {
      headers: { Authorization: 'Bearer not-a-real-key' },
    });
    expect(res.status).toBe(401);
  });
});

Schedule it in GitHub Actions:

name: rates-contract
on:
  schedule:
    - cron: '17 3 * * *'
  workflow_dispatch:
jobs:
  contract:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npx vitest run tests/contract
        env:
          ALLRATES_API_KEY: ${{ secrets.ALLRATES_API_KEY }}

The first test is one request, because several targets cost one request. The 401 test is free, since rejected 401, 403 and 429 requests are not charged. Use a dedicated key for CI so you can rotate it without touching production. The free plan is a one-off allowance meant for evaluation, so a job that runs every night belongs on a paid plan's key; see pricing.

What to assert, and what not to

Assert	Do not assert
Response is an array; `[0].rate` is a positive number	A specific rate value
`source` and `target` echo the request	That two calls return the same rate
`time` parses and is recent	Rate-limit headers on a 200
401 on a bad key, 429 handling in mocks	That the live API is reachable in unit tests

The API docs list every response shape for your fixtures. If you are still picking a provider, the free currency API comparison sets out the options.

FAQ

Should unit tests call the real exchange rate API?

No. Unit tests should run offline and give the same result every time. Inject a fixed rate provider or mock the HTTP layer. Call the real API only from a separate contract test that checks the response shape on a schedule.

What should a contract test assert if rates change every minute?

The shape, never the value. Check that the response is an array, that rate is a positive number, that source and target echo the request, and that time parses as a recent timestamp.

How do I test the rate limit path?

Mock it. Return a 429 with the X-Monthly-Limit, X-Monthly-Used and X-Monthly-Resets headers and assert that your code backs off or falls back to a cached rate. Those headers appear only on 429 responses, so do not expect them on a 200.

Does testing a bad key against the real API use up my quota?

No. Rejected 401, 403 and 429 requests are not charged, so a contract test can check the 401 path with a deliberately wrong key at no cost.

Can I use msw with Jest as well as Vitest?

Yes. msw intercepts requests at the network level in Node, so the same handlers work in Vitest and Jest. Only the import of describe, it and expect differs.

Originally published at allratestoday.com.

Exchange Rates API Data in a Database: Schema, Indexes and As-Of Queries

Exchange Rate API — Wed, 11 Nov 2026 14:27:42 +0000

Sooner or later, every app that uses an exchange rates API needs its own copy of the rates. Invoices must be reproducible next year. Reports must use the rate of the transaction date, not today's. And you do not want a page view to depend on a network call. This guide gives a schema that holds up: one table, the right keys, an as-of lookup, idempotent loading and a retention plan. The SQL is for PostgreSQL, with notes for MySQL and SQLite at the end.

The table

CREATE TABLE fx_rate (
  base        CHAR(3)        NOT NULL,             -- ISO 4217, e.g. 'USD'
  quote       CHAR(3)        NOT NULL,             -- 1 base = rate quote
  rate        NUMERIC(20,10) NOT NULL CHECK (rate > 0),
  rate_type   TEXT           NOT NULL CHECK (rate_type IN ('mid', 'official')),
  source      TEXT           NOT NULL,             -- 'allratestoday', 'ecb', 'rbi', ...
  rate_date   DATE           NOT NULL,             -- the date the rate applies to
  rate_time   TIMESTAMPTZ,                         -- the provider's own timestamp, if any
  fetched_at  TIMESTAMPTZ    NOT NULL DEFAULT now(),
  PRIMARY KEY (base, quote, rate_type, source, rate_date)
);

CREATE INDEX fx_rate_date_idx ON fx_rate (rate_date);

Why each column is there:

base and quote fix the direction. A row USD, EUR, 0.9215 means 1 USD = 0.9215 EUR. Write that rule in a comment, because direction bugs are the most expensive kind.
rate as NUMERIC(20,10), never FLOAT or DOUBLE. Floating point turns 0.9215 into 0.92149999... and those errors show up as one-cent differences in totals. Ten decimal places covers small-unit currencies against strong ones, and ten integer digits covers rates such as USD/IRR or USD/VND.
rate_type separates a live mid-market rate from an official central bank rate. They are different numbers with different purposes, and a report must never mix them by accident.
source names who produced the rate. For official rates it is the institution, such as ecb. This is the column an auditor asks about.
rate_date is the business date the rate applies to. rate_time is the provider's timestamp. fetched_at is when your system got it. Keep all three; they answer different questions.

Primary key and indexes

The primary key (base, quote, rate_type, source, rate_date) says: one rate per pair, per type, per source, per day. That is the right grain for invoices, accounting and reports.

The column order is deliberate. Lookups filter on pair, type and source, then range on date, so the primary key index serves the as-of query directly. The extra index on rate_date is for retention jobs and for "all rates on a date" exports.

If you also keep intraday snapshots, put them in a separate table keyed on rate_time instead of rate_date. Mixing grains in one table makes every query ask "which row of the day?".

As-of lookups: the latest rate on or before a date

Rates do not exist for every date. Official rates skip weekends and holidays, and your loader might miss a day. The standard question is "the latest rate on or before date D".

For several currencies at once, DISTINCT ON is the idiomatic Postgres answer:

SELECT DISTINCT ON (quote)
       quote, rate, rate_date
FROM fx_rate
WHERE base = 'USD'
  AND quote IN ('EUR', 'GBP', 'JPY')
  AND rate_type = 'mid'
  AND source = 'allratestoday'
  AND rate_date <= DATE '2026-11-08'
ORDER BY quote, rate_date DESC;

To attach a rate to each row of another table, use LATERAL. This converts invoices into USD with the rate on or before each invoice date, and refuses rates more than seven days older than the invoice:

SELECT i.id,
       i.amount,
       i.currency,
       r.rate,
       r.rate_date,
       CASE WHEN i.currency = 'USD' THEN i.amount
            ELSE round(i.amount / r.rate, 2) END AS amount_usd
FROM invoice i
LEFT JOIN LATERAL (
  SELECT rate, rate_date
  FROM fx_rate
  WHERE base = 'USD'
    AND quote = i.currency
    AND rate_type = 'mid'
    AND source = 'allratestoday'
    AND rate_date <= i.invoice_date
    AND rate_date >= i.invoice_date - 7
  ORDER BY rate_date DESC
  LIMIT 1
) r ON true;

Each lateral subquery is a single index probe on the primary key. LEFT JOIN ... ON true keeps invoices with no rate, so you see a NULL instead of silently losing rows. Since rate is EUR per USD, a EUR amount divided by the rate gives USD.

Why not store inverses

It is tempting to store both USD/EUR and EUR/USD. Do not:

They can disagree. If one is loaded and the other is not, or both are rounded, a * b stops being exactly 1, and two reports give two answers.
It doubles the rows and the load work for no new information.
It hides direction bugs. With one direction stored, a query that uses the wrong direction returns nothing, which you notice. With both stored, it returns a plausible wrong number.

Store one direction per source and compute the inverse when you need it: 1 / rate. With NUMERIC, the inverse is exact to the precision you ask for.

Triangulation through USD or EUR

You do not need rows for every pair either. With 160 currencies there are over 25,000 pairs. Store each currency against one base and derive the rest. EUR/GBP is USD/GBP divided by USD/EUR:

SELECT a.rate_date,
       round(b.rate / a.rate, 10) AS eur_gbp
FROM fx_rate a
JOIN fx_rate b USING (base, rate_type, source, rate_date)
WHERE a.base = 'USD' AND a.quote = 'EUR'
  AND b.quote = 'GBP'
  AND a.rate_type = 'mid' AND a.source = 'allratestoday'
ORDER BY a.rate_date DESC
LIMIT 30;

The important rule: triangulate only within one source and one date. Official rates come in each institution's own base. The ECB quotes against EUR, a central bank in India quotes against INR. Store them as given, with their own base and source = 'ecb' and so on, and never combine an ECB rate with another bank's rate into a cross rate. The result would belong to no one. The base currency conversion guide goes deeper on cross rates.

Idempotent upserts with ON CONFLICT

Loaders get re-run: a cron fires twice, a job retries after a timeout, someone backfills a week by hand. The insert must be safe to repeat:

INSERT INTO fx_rate (base, quote, rate, rate_type, source, rate_date, rate_time)
VALUES ($1, $2, $3, 'mid', 'allratestoday', $4, $5)
ON CONFLICT (base, quote, rate_type, source, rate_date)
DO UPDATE SET rate       = EXCLUDED.rate,
              rate_time  = EXCLUDED.rate_time,
              fetched_at = now()
WHERE fx_rate.rate IS DISTINCT FROM EXCLUDED.rate;

Running it twice leaves one row. The WHERE clause skips writes when nothing changed, which keeps write volume and table bloat down. For official rates, consider DO NOTHING plus a log entry when a value differs, so a correction by the institution is visible rather than silently overwritten.

Loading daily from the exchange rates API

One request fetches every currency you need. The AllRatesToday rates endpoint takes a comma-separated target list and returns a JSON array; a multi-target call costs one request.

# load_rates.py   (pip install requests "psycopg[binary]")
import json
import os
from datetime import datetime
from decimal import Decimal

import psycopg
import requests

TARGETS = ["EUR", "GBP", "JPY", "CAD", "AUD", "CHF", "INR", "CNY"]

UPSERT = """
INSERT INTO fx_rate (base, quote, rate, rate_type, source, rate_date, rate_time)
VALUES (%s, %s, %s, 'mid', 'allratestoday', %s, %s)
ON CONFLICT (base, quote, rate_type, source, rate_date)
DO UPDATE SET rate = EXCLUDED.rate, rate_time = EXCLUDED.rate_time, fetched_at = now()
WHERE fx_rate.rate IS DISTINCT FROM EXCLUDED.rate
"""

resp = requests.get(
    "https://allratestoday.com/api/v1/rates",
    params={"source": "USD", "target": ",".join(TARGETS)},
    headers={"Authorization": f"Bearer {os.environ['ALLRATES_API_KEY']}"},
    timeout=15,
)
resp.raise_for_status()
rows = json.loads(resp.text, parse_float=Decimal)   # keep exact decimals

with psycopg.connect(os.environ["DATABASE_URL"]) as conn:
    for r in rows:
        ts = datetime.fromisoformat(r["time"].replace("Z", "+00:00"))
        conn.execute(UPSERT, (r["source"], r["target"], r["rate"], ts.date(), ts))

parse_float=Decimal keeps the rate exact from JSON to NUMERIC; going through a Python float would reintroduce rounding. Schedule the loader at a fixed time each day, for example just after your business close. If it runs twice the same day, the upsert keeps the later snapshot. Daily loading is about 30 requests a month, which fits any paid plan; commercial use starts on the Small plan, see pricing.

For backfills, /api/historical-rates?source=USD&target=EUR&period=1y returns weekly points and costs 12 requests per pair. For daily official rates over a date range, the central bank history endpoint, such as /api/v1/central-bank/ecb/history?source=USD&target=EUR&from=2026-01-01&to=2026-03-31, returns the institution's own dates and is billed per month of range. See the central bank rates API.

Retention

Daily rows are tiny. 160 currencies for one source is about 58,000 rows a year, a few megabytes with indexes. Keep daily rates forever; old invoices and audits need them.

Intraday snapshots are different. One snapshot a minute for 160 currencies is about 230,000 rows a day. Partition that table by month and drop partitions you no longer need, keeping only the daily row in fx_rate long term.

MySQL and SQLite notes

Topic	PostgreSQL	MySQL 8	SQLite
Rate column	`NUMERIC(20,10)`	`DECIMAL(20,10)`	`TEXT`, parse in the app
Upsert	`ON CONFLICT ... DO UPDATE`	`ON DUPLICATE KEY UPDATE`	`ON CONFLICT ... DO UPDATE` (3.24+)
As-of, many rows	`DISTINCT ON`	`ROW_NUMBER() OVER (PARTITION BY quote ORDER BY rate_date DESC)`	`ROW_NUMBER()` (3.25+)
As-of per row	`LATERAL`	`LATERAL` (8.0.14+) or correlated subquery	correlated subquery
Timestamps	`TIMESTAMPTZ`	`DATETIME` in UTC	ISO 8601 `TEXT` in UTC

SQLite deserves a warning: a column declared NUMERIC stores 0.9215 as a floating-point value. Store rates as text and convert with a decimal type in your application.

If you are still choosing where the data comes from, the free currency API comparison lists update frequencies, history depth and limits.

FAQ

What data type should I use for exchange rates in SQL?

Use NUMERIC or DECIMAL, for example NUMERIC(20,10). Never use FLOAT or DOUBLE, because binary floating point cannot represent most decimal rates exactly and the errors show up in totals.

How do I get the exchange rate for a date with no rate?

Use an as-of lookup: the latest rate on or before the date. In Postgres, use DISTINCT ON for many currencies or a LATERAL subquery with ORDER BY rate_date DESC LIMIT 1 per row, plus a maximum age.

Should I store both USD/EUR and EUR/USD?

No. Store one direction per source and compute the inverse as 1 divided by the rate. Storing both lets them drift apart.

How do I avoid duplicate rows when the loader runs twice?

Make the primary key the natural key (base, quote, rate type, source, rate date) and insert with ON CONFLICT DO UPDATE. Running the load again then updates or skips the row instead of adding one.

Can I mix official and mid-market rates in one table?

Yes, as long as rate_type and source are part of the key and every query filters on them. Never build a cross rate from two different sources.

Originally published at allratestoday.com.

Free Currency Converter API for iOS and Android: Swift and Kotlin

Exchange Rate API — Wed, 11 Nov 2026 14:25:55 +0000

A free currency converter API is easy to call from a mobile app. Doing it well takes three more things: the app must work offline with the last known rates, it must tell the user how old those rates are, and the API key must not be inside the app binary. This guide covers all three, with working code for iOS in Swift and Android in Kotlin.

The examples use the AllRatesToday rates endpoint, which returns mid-market rates for 160+ currencies, refreshed every 60 seconds.

The architecture: app, proxy, API

An iOS or Android app is a file the user downloads. Anything compiled into it, including an API key in Info.plist, BuildConfig or an obfuscated string, can be extracted with free tools in minutes. Once extracted, the key works from anywhere until you rotate it.

So the app never talks to the rates API directly:

The app calls https://rates.example.com/rates?source=USD&target=EUR,GBP,JPY on your own backend.
The backend adds Authorization: Bearer YOUR_API_KEY, calls AllRatesToday, caches the answer and returns the same JSON array.
The app decodes the array, saves it with a timestamp and converts amounts locally.

The proxy is about 40 lines on Cloudflare Workers or as a Next.js route handler. The full version, with caching, a currency allowlist and rate limiting, is in how to hide an exchange rate API key behind a proxy. The rest of this article assumes it exists and returns exactly what the API returns.

The free currency converter API response you decode

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR,GBP,JPY"

[
  {"rate":0.9215,"source":"USD","target":"EUR","time":"2026-04-03T12:00:00Z"},
  {"rate":0.7893,"source":"USD","target":"GBP","time":"2026-04-03T12:00:00Z"},
  {"rate":151.42,"source":"USD","target":"JPY","time":"2026-04-03T12:00:00Z"}
]

It is a JSON array even when you ask for one pair. Decode it as [Rate] in Swift and List<Rate> in Kotlin. Decoding into a single object is the most common error with this endpoint. All targets in one call cost one request.

Converting on the device

Fetch one base, USD, with every currency your app supports. Then any conversion is arithmetic:

USD to EUR: amount * rate[EUR]
EUR to USD: amount / rate[EUR]
EUR to JPY: amount / rate[EUR] * rate[JPY]

This keeps the app to one request per refresh and lets you cache one response for all users. Round only for display, never before the multiplication. The base currency conversion guide explains cross rates in more detail.

iOS: Swift with URLSession, async/await and Codable

import Foundation

struct Rate: Codable {
    let rate: Double
    let source: String
    let target: String
    let time: String
}

struct RatesSnapshot: Codable {
    let rates: [Rate]
    let fetchedAt: Date

    func rate(for code: String) -> Double? {
        code == "USD" ? 1 : rates.first { $0.target == code }?.rate
    }

    func convert(_ amount: Double, from: String, to: String) -> Double? {
        guard let f = rate(for: from), let t = rate(for: to) else { return nil }
        return amount / f * t
    }
}

final class RatesStore {
    private let endpoint = URL(string: "https://rates.example.com/rates")!
    private let cacheURL = FileManager.default
        .urls(for: .cachesDirectory, in: .userDomainMask)[0]
        .appendingPathComponent("rates.json")

    func fetch(targets: [String]) async throws -> RatesSnapshot {
        var components = URLComponents(url: endpoint, resolvingAgainstBaseURL: false)!
        components.queryItems = [
            URLQueryItem(name: "source", value: "USD"),
            URLQueryItem(name: "target", value: targets.joined(separator: ","))
        ]
        var request = URLRequest(url: components.url!)
        request.timeoutInterval = 10

        let (data, response) = try await URLSession.shared.data(for: request)
        guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        let rates = try JSONDecoder().decode([Rate].self, from: data)   // an array
        let snapshot = RatesSnapshot(rates: rates, fetchedAt: Date())
        try? JSONEncoder().encode(snapshot).write(to: cacheURL, options: .atomic)
        return snapshot
    }

    func cached() -> RatesSnapshot? {
        guard let data = try? Data(contentsOf: cacheURL) else { return nil }
        return try? JSONDecoder().decode(RatesSnapshot.self, from: data)
    }
}

time is decoded as a string so a change in timestamp precision can never break decoding. fetchedAt is the device's own record of when it last got fresh data; that is the value you show as "rates as of".

A minimal SwiftUI view model that shows cached rates first and refreshes in the background:

@MainActor
final class ConverterModel: ObservableObject {
    @Published var snapshot: RatesSnapshot?
    @Published var isStale = false
    private let store = RatesStore()
    private let maxAge: TimeInterval = 15 * 60

    func load() async {
        snapshot = store.cached()
        if let s = snapshot, Date().timeIntervalSince(s.fetchedAt) < maxAge { return }
        do {
            snapshot = try await store.fetch(targets: ["EUR", "GBP", "JPY", "INR", "CAD"])
            isStale = false
        } catch {
            isStale = snapshot != nil   // keep old rates, flag them
        }
    }
}

In the view, show Text("Rates as of \(snapshot.fetchedAt.formatted())"), and a warning when isStale is true. Call load() from .task and again when the scene becomes active.

Android: Kotlin with OkHttp and kotlinx.serialization

Add com.squareup.okhttp3:okhttp and org.jetbrains.kotlinx:kotlinx-serialization-json, and apply the kotlinx-serialization Gradle plugin.

import android.content.Context
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.Serializable
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.File
import java.io.IOException

@Serializable
data class Rate(val rate: Double, val source: String, val target: String, val time: String)

@Serializable
data class RatesSnapshot(val rates: List<Rate>, val fetchedAt: Long) {
    fun rateFor(code: String): Double? =
        if (code == "USD") 1.0 else rates.firstOrNull { it.target == code }?.rate

    fun convert(amount: Double, from: String, to: String): Double? {
        val f = rateFor(from) ?: return null
        val t = rateFor(to) ?: return null
        return amount / f * t
    }
}

class RatesRepository(context: Context, private val client: OkHttpClient = OkHttpClient()) {
    private val json = Json { ignoreUnknownKeys = true }
    private val cacheFile = File(context.cacheDir, "rates.json")

    suspend fun fetch(targets: List<String>): RatesSnapshot = withContext(Dispatchers.IO) {
        val url = "https://rates.example.com/rates".toHttpUrl().newBuilder()
            .addQueryParameter("source", "USD")
            .addQueryParameter("target", targets.joinToString(","))
            .build()
        client.newCall(Request.Builder().url(url).build()).execute().use { res ->
            if (!res.isSuccessful) throw IOException("HTTP ${res.code}")
            val rates = json.decodeFromString<List<Rate>>(res.body!!.string())  // an array
            RatesSnapshot(rates, System.currentTimeMillis()).also {
                cacheFile.writeText(json.encodeToString(it))
            }
        }
    }

    fun cached(): RatesSnapshot? =
        runCatching { json.decodeFromString<RatesSnapshot>(cacheFile.readText()) }.getOrNull()
}

If you prefer Ktor, the same code works with HttpClient(OkHttp) and the ContentNegotiation plugin: client.get(url).body<List<Rate>>(). The important part is the same: decode a list.

A ViewModel that mirrors the Swift version:

class ConverterViewModel(private val repo: RatesRepository) : ViewModel() {
    val snapshot = MutableStateFlow(repo.cached())
    val isStale = MutableStateFlow(false)
    private val maxAgeMs = 15 * 60 * 1000L

    fun refresh() = viewModelScope.launch {
        val current = snapshot.value
        if (current != null && System.currentTimeMillis() - current.fetchedAt < maxAgeMs) return@launch
        try {
            snapshot.value = repo.fetch(listOf("EUR", "GBP", "JPY", "INR", "CAD"))
            isStale.value = false
        } catch (e: IOException) {
            isStale.value = current != null
        }
    }
}

Call refresh() from onResume. Show "Rates as of" with DateFormat.getDateTimeInstance().format(Date(snapshot.fetchedAt)).

Offline behaviour

The cache file is the offline mode. The rules that make it honest:

Show cached rates immediately on launch, before any network call returns.
Always show the age. "Rates as of 11 Nov, 14:02" next to the result.
Flag old data. If the last fetch is more than a day old, show a visible warning, not just a timestamp.
Never invent a rate. If there is no cache and no network, say so instead of showing 1.0 or zero.

Refresh policy

The rates refresh every 60 seconds upstream, but a converter in someone's pocket does not need that. A sensible policy:

Refresh on app launch and when the app returns to the foreground, if the cache is older than 15 minutes.
Offer pull-to-refresh, limited to once a minute.
Do not refresh in the background unless your app has a real need, such as a rate alert.

Because the proxy caches the response, upstream usage depends on the proxy's cache time, not on your number of users. With one base and a 10-minute proxy cache, the proxy makes at most 144 calls a day, about 4,320 in 30 days, which fits the Small plan's 5,000 requests a month. One caveat: the Workers Cache API is per data centre, so a global user base can produce a few more upstream calls than that. The guide on caching exchange rates covers shared caches.

A free API key is fine for building and testing the app. A published app is commercial use, which starts on the Small plan; see pricing. If you are still comparing providers, the free currency API comparison has the limits side by side.

Rates are mid-market

The numbers are mid-market rates: the midpoint between buy and sell prices, with no bank margin. That is the right number for a converter. If your app shows what a bank or card will actually charge, label the result "mid-market rate" so users are not surprised. Mid-market vs retail rates explains the difference.

FAQ

Is there a free currency converter API for mobile apps?

Yes. You can get a free API key from AllRatesToday and call the rates endpoint from your own backend for development and testing. A published app counts as commercial use, which starts on the Small plan at 4.99 euros a month.

Can I put the API key in my iOS or Android app?

No. Anything in the app binary can be extracted, including obfuscated strings. Keep the key on a small backend proxy and have the app call the proxy.

Why does decoding fail with a type mismatch?

The rates endpoint always returns a JSON array, even for one pair. Decode [Rate] in Swift or List in Kotlin, not a single object.

How should the app work offline?

Save the last successful response together with the time you fetched it. On launch, show the cached rates and a "rates as of" time, then refresh when the network is available.

How often should a mobile converter refresh rates?

On launch and on return to the foreground when the cache is older than about 15 minutes, plus pull-to-refresh. Upstream rates refresh every 60 seconds, but a converter rarely needs more.

Originally published at allratestoday.com.

Currency Exchange Rates API for Invoices: Which Rate to Use

Exchange Rate API — Wed, 11 Nov 2026 14:24:08 +0000

When you issue an invoice in a foreign currency, two questions follow. Which rate converts the amounts into your reporting or tax currency? And which date does that rate come from? A currency exchange rates API for invoices has to answer both, and the answer is usually set by tax law, not by your preference. This guide covers the tax-point rule, the official rates that laws name, what to store on the invoice, and code to fetch an official rate for a given date.

Not tax advice. This is a developer's summary of common rules. Confirm the rule for your business and country with a tax adviser or the tax authority.

The date: tax point or date of supply

Most VAT and GST systems tie the conversion to one date: the tax point, also called the time or date of supply. That is the date the tax becomes due. Depending on the country and the transaction, it can be the delivery date, the invoice date or the payment date.

So the rule for your code is simple. Do not use "today's rate" when the invoice is generated. Use the rate for the tax-point date. If you generate an invoice on 12 November for a supply on 9 November, the rate date should follow 9 November, under whatever rule applies to you.

Official rates named by law

Many tax systems name the source of the rate as well as the date. Some examples:

UAE VAT. Article 69 of the VAT Decree-Law says amounts in a foreign currency are converted at the rate approved by the Central Bank of the UAE at the date of supply. The details, including weekends, are in our UAE VAT Article 69 guide.
UK customs and VAT. HMRC sets official monthly exchange rates, released before the start of each month. They are the rates for customs declarations and an accepted option for VAT on imports and invoices. See the HMRC exchange rate API.
EU VAT. Many EU countries allow the ECB euro reference rate for converting invoice amounts. Some also allow the national central bank's rate. Check your member state's rule.
India GST. Rule 34 of the CGST Rules points to the CBIC customs rates for goods and to accounting-standard rates for services. See the GST invoice exchange rate guide.

The pattern is the same across these: an institution, a date rule, and a table. Your system should fetch from that institution's table, not from a payment provider or a card network.

Mid-market for display, official for the tax line

An invoice system often needs two different rates, used for two different jobs.

Job	Rate	Why
Showing an estimated price in a quote or checkout	Mid-market, current	Closest to what the market is doing right now
Converting the VAT or GST amount on the invoice	The official rate the rule names	The tax authority checks against that table
Booking the invoice in the ledger	The rate your accounting policy names	Often the same official table, for consistency
Recording the payment received	The rate actually applied by the bank	Gives the realised FX gain or loss

Mixing these up is the most common mistake. A live mid-market rate is the right number to show a customer a price. It is not the rate a VAT rule names. More on the difference in mid-market vs retail exchange rates.

What to store on the invoice

Store enough to reproduce the number later without calling any API.

Rate. At the full precision of the official table. Round the converted amount once, not the rate.
Source. The institution, such as "Central Bank of the UAE" or "HMRC".
Rate date. The official date of the table you used. This may differ from the tax-point date on a weekend or holiday.
Tax-point date. The date the rule refers to.
Lookup time. When your system fetched the rate.
Converted amounts. Net, tax and gross in the tax currency.

Several systems also require the rate to be printed on the invoice itself. UAE tax invoices are one example. Even where it is not required, printing "Rate: 4.112542 AED per EUR, Central Bank of the UAE, 9 November 2026" answers most questions before they are asked.

Fetching an official rate for a date

The AllRatesToday central bank endpoint returns an institution's official table for a date: GET /api/v1/central-bank/{bank}/{YYYY-MM-DD}. The response carries the requested date, the institution's own rate_date, and the rates.

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://allratestoday.com/api/v1/central-bank/cbuae/2026-11-08"
# "requested_date": "2026-11-08", "rate_date": "2026-11-06",
# "published_on_requested_date": false,
# "rates": [ ... { "base": "EUR", "quote": "AED", "type": "reference", "value": 4.091466 }, ... ]

8 November 2026 is a Sunday. The CBUAE does not issue rates at weekends, so the response returns Friday's table and says so. Here is the same lookup in JavaScript, with the fields you need to store:

async function officialRate(bank, date, base, quote) {
  const res = await fetch(
    `https://allratestoday.com/api/v1/central-bank/${bank}/${date}`,
    { headers: { Authorization: `Bearer ${process.env.ALLRATES_API_KEY}` } }
  );
  if (!res.ok) throw new Error(`Official rate lookup failed: ${res.status}`);
  const table = await res.json();

  const row = table.rates.find((r) => r.base === base && r.quote === quote);
  if (!row) throw new Error(`${bank} has no ${base}/${quote} on ${table.rate_date}`);

  return {
    rate: row.value,
    source: bank,
    rateDate: table.rate_date,
    taxPointDate: date,
    publishedOnDate: table.published_on_requested_date,
    fetchedAt: new Date().toISOString(),
  };
}

// EUR invoice, VAT payable in AED, supply on 8 November 2026
const fx = await officialRate("cbuae", "2026-11-08", "EUR", "AED");
const netEur = 1000.0;
const vatEur = netEur * 0.05;
const vatAed = Math.round(vatEur * fx.rate * 100) / 100; // round once, at the end
console.log(`VAT AED ${vatAed.toFixed(2)} at ${fx.rate} (${fx.source}, ${fx.rateDate})`);

A few points about this code:

Direction. Each row has a base and a quote. Check you have the direction you need. If a table only quotes EUR/AED, then AED/EUR is 1 / value.
Weekend fallback. published_on_requested_date: false tells you the table came from an earlier day. Store both dates so the fallback is visible in an audit.
Rounding. Use the full official precision in the multiplication. Round the tax amount once. For money in production, use integer minor units or a decimal library rather than floats.
Cache by date. A past table does not change. Fetch it once per bank and date, then store it.

Swap cbuae for the institution your rule names: ecb, hmrc and the others are listed on the central bank rates API page. The @allratestoday/central-bank package on npm and allratestoday-central-bank on PyPI wrap the same endpoint. Dated tables and history are on paid plans, and the Official plan covers any past date with JSON, CSV, XML and XLSX output for ERP imports.

A checklist for your invoicing code

The rate date follows the tax-point date, not the generation date.
The source is the institution your tax rule names.
Weekend and holiday fallback is written down and applied the same way every time.
Rate, source, rate date and lookup time are stored with the invoice.
Rounding happens once, on the converted amount.
Display prices may use a live mid-market rate. The tax line does not.

If you are still choosing a provider for the display side, the free currency API comparison covers update frequency and limits. For the tax side, the question is simpler: which institution does the rule name, and can you get its table for a date.

FAQ

Which exchange rate should I use on a foreign-currency invoice?

For the tax amount, use the rate your tax rule names, taken on the tax point or date of supply. Many countries name an official rate, such as the Central Bank of the UAE rate for UAE VAT or HMRC's monthly rates for UK customs. For showing a price before the sale, a mid-market rate is fine.

Can I use a mid-market rate for VAT on an invoice?

Only if your tax rule allows it. Where the law names an official rate, use that rate for the tax line. A mid-market rate is a market snapshot, not the rate a tax authority names.

What should I store with each invoice?

Store the rate, the source institution, the official rate date of the table, the date you looked it up, and the converted amounts. That lets you reproduce the figure in an audit.

What if the date of supply is a weekend or a holiday?

Most central banks do not issue rates on non-working days. The usual practice is to use the latest table before the date. Write that fallback into your policy and apply it the same way every time.

Is this tax advice?

No. It is a developer's summary of common rules. Confirm the rule that applies to your business with your tax adviser or the tax authority.

Originally published at allratestoday.com.

Exchange Rate API Free for Commercial Use? What Free-Tier Terms Say

Exchange Rate API — Wed, 11 Nov 2026 14:22:21 +0000

Searching for "exchange rate api free" returns plenty of options. The harder question comes later: can you put that free API in a product that makes money? Many free tiers say no, some say yes, and a few say yes with conditions. This guide walks through what free-tier terms typically say, what "commercial" usually covers, and how to check a provider before you ship.

Not legal advice. This is a summary of public terms at the time of writing. Terms change. Read the current version on each vendor's site before you rely on it.

What free exchange rate API terms typically say

Free tiers fall into four groups. The table shows where some popular providers sat at the time of writing.

Provider	Free tier	Commercial use on free tier
Fixer	100 requests/month, hourly	No, non-commercial only
currencylayer	100 requests/month, daily	No, non-commercial only
ExchangeRate-API	1,500 requests/month, daily	Allowed, but rates are "only suitable for informational or illustrative purposes"
Frankfurter	Free, open source, no key, no quotas	Yes
AllRatesToday	Free plan, personal use and testing	No. Commercial use from Small, 4.99 euros/month

1. Non-commercial clauses: Fixer and currencylayer

Fixer and currencylayer, both from APILayer, label their free plans as non-commercial. The free plan exists so you can build and evaluate. Once the app is used to run a business, the terms expect a paid plan. Paid plans start at 14.99 dollars a month for both at the time of writing.

2. Use allowed, fitness limited: ExchangeRate-API

ExchangeRate-API's terms say its rates are "only suitable for informational or illustrative purposes". That is a different kind of limit. It does not ban a commercial site from showing a converted price. It does tell you the vendor does not stand behind the numbers for anything binding, such as invoices, payments or accounting. Its open access endpoint also asks for attribution, covered below.

3. Commercial use allowed: Frankfurter

Frankfurter is free, open source and allows commercial use. It serves daily data from the ECB and many other central banks. The trade-off is daily data, no support contract and no service level. For many apps that is fine. For a checkout that needs a current rate, it usually is not.

4. Free for testing, paid for business: AllRatesToday

Our Free plan is for personal use and testing. It includes the latest mid-market rates, refreshed every 60 seconds, and the latest official central bank rates, at 10 requests a minute. It has no historical data, and the free usage is a one-off allowance that does not reset. Commercial use starts on the Small plan at 4.99 euros a month, which also adds history. Full details are on the pricing page.

Attribution requirements

Attribution is a separate question from commercial use. A provider can allow commercial use and still require a credit link.

ExchangeRate-API's open access endpoint says: "We require attribution on the pages you're using these rates with the link below", with the link text "Rates By Exchange Rate API". It notes the link can be styled to fit your page. Its keyed plans have their own terms.

When you read terms, look for three things:

Where the credit must appear: every page that shows a rate, or one page such as an About or Credits page.
What it must say: exact link text, a logo, or just the provider name.
When it applies: often only on the free tier or only on public pages.

If a free API requires attribution and your design cannot carry it, that alone is a reason to pay.

What "commercial" usually covers

Most developers think of commercial use as "I charge for it". Terms usually draw the line much earlier. These are the cases that typically count:

SaaS products. Any paid app, or a free tier of a paid app, that shows or uses rates.
Ad-supported or affiliate sites. A free converter page with ads is earning money from the rates.
E-commerce. Showing prices in a local currency to drive sales. See exchange rates for e-commerce.
Internal business tools. A finance dashboard, a pricing spreadsheet or an ERP sync used inside a company. Nobody outside sees it, but it runs the business.
Client work. An agency building a site for a paying client.

What usually does not count: a personal budget app you use alone, a university assignment, or a prototype you are testing before launch. Even then, check the wording. Some terms define commercial use as any use "by or on behalf of a business".

How to check exchange rate API terms in ten minutes

Open the terms page, not the pricing page. Pricing tables simplify. The terms are what apply. Search the page for "commercial", "personal", "attribution", "resale" and "redistribute".
Check the plan matrix. Some vendors mark the free plan as non-commercial only on the pricing page. Treat that as part of the terms.
Look for a fitness clause. Phrases like "informational purposes" or "no warranty of accuracy" tell you not to use the rates for invoices, tax or payments.
Check redistribution rules. If you expose rates through your own API or export them to customers, many terms treat that as resale.
Check data licences separately. An open source server can serve data under a different licence from its code. Read both.
Save a copy. Note the date you read the terms. If the vendor changes them, you know what applied when you built the feature.
Ask if unsure. A short email to the vendor's support gets a written answer you can keep.

Testing on a free key, shipping on a paid one

A common pattern is to build and test on a free key, then switch to a paid key before launch. With AllRatesToday the code does not change between plans. Only the key does:

const res = await fetch(
  "https://allratestoday.com/api/v1/rates?source=USD&target=EUR,GBP,JPY",
  { headers: { Authorization: `Bearer ${process.env.ALLRATES_API_KEY}` } }
);
if (!res.ok) throw new Error(`Rate request failed: ${res.status}`);

const rates = await res.json(); // always an array
for (const r of rates) {
  console.log(`${r.source}/${r.target} = ${r.rate} at ${r.time}`);
}

The response is an array even for one pair, so read rates[0].rate, not rates.rate. Several targets in one call cost one request. Store the key in an environment variable and swap it at deploy time.

When free is the right answer

Free is right when the app is personal, when it is a prototype, or when a provider like Frankfurter allows commercial use and daily data is enough. Paid is right when the app earns money and the terms say so, when you need rates more current than once a day, or when you need someone to answer if the data is wrong. For a side-by-side view of limits and update frequency, see our free currency API comparison, and for the cost trade-offs, free vs paid exchange rate APIs.

One more point. Commercial use and fitness for purpose are different questions. Even a paid mid-market feed is a market snapshot. If a tax rule or a contract names a rate, use the official table it names. The central bank rates API serves 123 central banks and 6 tax authorities, each with the institution's own rate date.

FAQ

Can I use a free exchange rate API in a commercial app?

Sometimes. Fixer and currencylayer limit their free plans to non-commercial use. Frankfurter allows commercial use. ExchangeRate-API allows use but says its rates are only suitable for informational or illustrative purposes. The AllRatesToday Free plan is for personal use and testing; commercial use starts on the Small plan at 4.99 euros a month.

Does an ad-supported website count as commercial use?

Usually yes. Most terms treat any use that earns money, directly or indirectly, as commercial. A blog or tool page with ads or affiliate links generally falls on the commercial side.

Is an internal business tool commercial use?

In most terms, yes. A dashboard or spreadsheet used inside a company to run its business is commercial use even if nobody outside the company sees it.

Do free exchange rate APIs require attribution?

Some do. ExchangeRate-API's open access endpoint asks for a visible "Rates By Exchange Rate API" link on pages that use the rates. Check the terms of each provider, because attribution rules are usually tied to the plan.

Is this legal advice?

No. This article summarises public terms at the time of writing. Read the current terms yourself, and ask a lawyer if the answer matters to your business.

Originally published at allratestoday.com.

Live FX Rates API: Polling vs WebSocket, and How to Poll Efficiently

Exchange Rate API — Wed, 11 Nov 2026 14:20:33 +0000

A live FX rates API sounds like one thing, but "live" covers everything from a tick-by-tick trading stream to a rate that changes once a minute. Which one you need depends on what your app does with the number. This tutorial explains the difference, when polling a REST endpoint is the right design, and how to do it with one API call per minute no matter how many users you have.

To be clear up front: AllRatesToday is REST only. There is no WebSocket and no push feed. Each rate is a mid-market snapshot refreshed every 60 seconds. The code below shows how to turn that into a live feed for your own clients.

What "live" means for FX rates

There are three common meanings:

Kind	Update interval	Contains	Delivery
Tick stream	Every price change, many per second for major pairs	Bid and ask	WebSocket or HTTP stream from a broker or market data vendor
Snapshot	Every minute (or hourly, daily)	One mid-market rate per pair	REST
Fixing	Once a day or month	One official rate	REST or a file download

A tick stream is what a trading screen needs. A snapshot is what a shop, a billing system or a dashboard needs. Nobody re-prices a basket of shoes eight times a second.

Live FX rates API: polling REST vs WebSocket

Polling means your code calls a REST endpoint on a timer. It is stateless, works through every proxy and firewall, is easy to cache, and fails in a simple way: if one call fails, you keep the last value and try again next minute.

WebSocket or streaming means the server holds a connection open and pushes each change. It has lower latency and no wasted calls. It also needs reconnect logic, heartbeat handling, back-pressure, and a plan for what happens when the stream silently stops.

Use this rule:

Trading, order entry, tick charts: streaming from a broker or market data vendor. You need bid and ask, and latency matters.
Pricing, checkout, invoices, dashboards, alerts: polling a snapshot API. One-minute freshness is more than enough, and the rate is the same for every user.

If your source updates every 60 seconds, a stream would only push one message a minute anyway. Polling every 60 seconds gets you the same data with less machinery.

How to poll efficiently

Most of the cost of polling comes from doing it in the wrong place. Three rules:

Poll from the server, once. Not from each browser. A thousand open tabs should still mean one upstream call a minute.
Ask for every currency in one call. target=EUR,GBP,JPY,CAD,AUD returns one array and costs one request.
Fan out yourself. Keep the latest snapshot in memory (or Redis, or KV) and push it to clients over your own Server-Sent Events or WebSocket endpoint.

Do the arithmetic before you choose an interval. One call per minute is about 1,440 calls a day and about 43,200 in a 30-day month. On AllRatesToday that fits the Large plan (100,000 a month). Every 5 minutes is about 8,640 a month, which fits Medium (10,000). Every 15 minutes is about 2,880, which fits Small (5,000). The caching guide has more patterns.

Node example: poll once, broadcast via SSE

This uses only Node 18+ built-ins: fetch and http. Save it as server.mjs and run ALLRATES_API_KEY=YOUR_API_KEY node server.mjs.

import http from "node:http";

const API_KEY = process.env.ALLRATES_API_KEY;
const BASE = "USD";
const TARGETS = ["EUR", "GBP", "JPY", "CAD", "AUD"];
const POLL_MS = 60_000;
const URL_RATES =
  `https://allratestoday.com/api/v1/rates?source=${BASE}&target=${TARGETS.join(",")}`;

let latest = null;            // last good snapshot
const clients = new Set();    // open SSE responses

function send(res, snapshot) {
  res.write(`event: rates\ndata: ${JSON.stringify(snapshot)}\n\n`);
}

async function poll() {
  try {
    const res = await fetch(URL_RATES, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    if (res.status === 429) {
      console.warn("Monthly limit reached, resets:", res.headers.get("X-Monthly-Resets"));
      return;                 // keep serving the last snapshot
    }
    if (!res.ok) throw new Error(`HTTP ${res.status}`);

    const rows = await res.json();          // an array, one item per target
    const snapshot = {
      base: BASE,
      time: rows[0]?.time,
      fetchedAt: new Date().toISOString(),
      rates: Object.fromEntries(rows.map((r) => [r.target, r.rate])),
    };

    const changed =
      !latest || JSON.stringify(latest.rates) !== JSON.stringify(snapshot.rates);
    latest = snapshot;
    if (changed) for (const c of clients) send(c, snapshot);
  } catch (err) {
    console.error("Poll failed, keeping last snapshot:", err.message);
  }
}

const server = http.createServer((req, res) => {
  if (req.url === "/rates/stream") {
    res.writeHead(200, {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    });
    res.write("retry: 5000\n\n");           // browser reconnect delay
    if (latest) send(res, latest);          // new clients get data at once
    clients.add(res);
    req.on("close", () => clients.delete(res));
    return;
  }
  if (req.url === "/rates") {               // plain JSON for non-SSE clients
    res.writeHead(latest ? 200 : 503, { "Content-Type": "application/json" });
    res.end(JSON.stringify(latest ?? { error: "warming up" }));
    return;
  }
  res.writeHead(404).end();
});

// Comment line every 25 s so proxies do not close idle streams.
setInterval(() => { for (const c of clients) c.write(": ping\n\n"); }, 25_000);

await poll();
setInterval(poll, POLL_MS);
server.listen(3000, () => console.log("http://localhost:3000/rates/stream"));

What this does:

One upstream call per interval, whatever the number of connected clients.
Reads the array correctly. /api/v1/rates always returns an array, so the code maps over rows rather than reading res.rate.
Keeps the last good snapshot on errors and on 429, so clients never see an empty state after the first success.
Broadcasts only on change, so idle periods cost nothing on the client side.
Carries the rate time. time is when the rate refers to; fetchedAt is when you got it. Show or log both.

The browser side

EventSource is built into every modern browser and reconnects on its own:

<span id="eur">…</span>
<script>
  const es = new EventSource("/rates/stream");
  es.addEventListener("rates", (e) => {
    const snap = JSON.parse(e.data);
    document.getElementById("eur").textContent =
      `1 USD = ${snap.rates.EUR.toFixed(4)} EUR (as of ${new Date(snap.time).toLocaleTimeString()})`;
  });
</script>

The API key stays on your server. The browser only talks to your endpoint.

SSE or your own WebSocket?

SSE is one-way, server to client, over plain HTTP. That is exactly the shape of a rate feed. Use a WebSocket only if clients also need to send messages, for example to subscribe to a different set of currencies. In that case, keep the same design: one poller, one shared snapshot, and filter per subscription when you send.

If you run several server instances, put the snapshot in a shared store and let only one instance poll. A simple lock key with a 60-second expiry in Redis works, or a scheduled job that writes to the store while web instances only read.

Serverless: a scheduled job instead of a timer

On serverless platforms there is no long-running process to hold a setInterval. Split the work in two:

A scheduled job (a cron trigger, a scheduled function, or a cron entry on a small VM) calls /api/v1/rates once per interval and writes the snapshot to a shared store such as Redis, a key-value store or a database row.
Your request handlers only read that stored snapshot. They never call the rates API.

Clients can then poll your own endpoint as often as they like, with a short cache header such as Cache-Control: max-age=30, or you can keep the SSE endpoint on a small always-on service. Either way the upstream cost stays at one request per interval.

Staleness and failure

Polling makes failure handling simple, but you still need to handle it:

Mark stale data. If fetchedAt is more than a few intervals old, show a warning or disable checkout in foreign currencies.
Back off on errors. On repeated failures, poll less often instead of more.
Do not retry 401. A bad key will not fix itself. 401, 403 and 429 responses are not charged, but they will not return data either.

When this design is not enough

If you are building a trading screen, polling a one-minute mid-market snapshot is the wrong tool. You need bid and ask prices and a stream from a broker or a market data vendor. The real-time forex API roundup covers that space, and the free currency API comparison covers free snapshot APIs.

For everything else, one REST call a minute and your own SSE endpoint give every user a live rate with very little code.

FAQ

Does AllRatesToday offer a WebSocket feed?

No. It is REST over HTTPS only. Each rate is a one-minute mid-market snapshot, refreshed every 60 seconds. If you need push updates in your app, poll on your server and push to your clients with your own SSE or WebSocket endpoint.

How often should I poll a live FX rates API?

No faster than the provider refreshes. If rates update every 60 seconds, polling every 60 seconds gets every update. For most pricing pages every 5 to 15 minutes is enough.

When do I actually need WebSocket streaming for FX?

When you trade or show a trading screen: order entry, tick charts, or anything where a price a few seconds old is a problem. For that you need a broker or market data feed with bid and ask prices.

How many requests does polling every minute use?

About 1,440 a day, or about 43,200 in a 30-day month, if one call covers all your currencies. Poll every 5 minutes and that drops to about 8,640 a month.

Should browsers call the rates API directly?

No. Each visitor would use your quota and could see your key. Poll from your server, cache the result, and serve it to browsers from your own endpoint.

Live mid-market rates over REST. 160+ currencies refreshed every 60 seconds on every plan. One call returns as many targets as you need and counts as one request. Get a free API key

Originally published at allratestoday.com.

Best Exchange Rate API for Europe in 2026: 8 Compared for EUR Rates, ECB Reference Rates and VAT

Exchange Rate API — Tue, 10 Nov 2026 14:26:44 +0000

For a European business the euro reference rate from the European Central Bank is the default answer to every currency question, and several free APIs serve it. The choice gets harder when you also need a live rate for checkout, a non-euro official rate for a subsidiary in Poland or Switzerland, or output your accounting system can import.

This comparison looks at eight exchange rate APIs from the point of view of a team in Europe. Free-tier limits and prices were read from each provider's own pricing page on 10 November 2026; they change often, so confirm before you commit.

What a team in Europe needs from an exchange rate API

Live EUR pairs for pricing and checkout, not just a daily fixing.
ECB euro foreign exchange reference rates, the rate EU VAT rules allow for invoices in other currencies.
Other European central banks: Switzerland, Poland, Czechia, Sweden, Norway, Denmark, Hungary and the UK each publish their own table.
History by date, for the date VAT became chargeable.
Monthly averages, which Germany uses for VAT returns.

Quick comparison

Provider	Free tier	Updates on free	ECB reference rates	Cheapest paid plan
AllRatesToday	Free key	Every 60 seconds	ECB reference rates, plus the other European central banks and the Swiss customs table	€4.99/mo
Frankfurter	Free, no key, no monthly cap	Official fixings as each source releases them	ECB and other European central banks	No paid plan
ExchangeRate-API	1,500 requests a month	Once a day	No, market rates only	$10/mo
Open Exchange Rates	1,000 requests a month, USD base	Hourly	No, market rates only	$12/mo
CurrencyAPI	300 requests a month, private use only	Daily	No, market rates only	$12.99/mo
Fixer	100 calls a month, non-commercial	Hourly	No, market rates only	$14.99/mo
currencylayer	100 calls a month, non-commercial	Daily	No, market rates only	$14.99/mo
XE Currency Data	Trial only	Daily on the entry plan	No, market rates only	$599/yr

The European rates and what they are for

ECB euro reference rates. Published for 29 currencies, usually updated at around 16:00 CET every working day, from a concertation at about 14:10 CET. The ECB publishes them for information purposes only.
VAT Directive, Article 91(2). The exchange rate is the latest selling rate recorded on the most representative exchange market of the Member State when VAT becomes chargeable. Member States shall accept instead the latest exchange rate published by the European Central Bank at that time.
Germany. For VAT returns, section 16(6) of the German VAT Act requires conversion at the monthly average rates announced by the Federal Ministry of Finance, which are monthly averages of the ECB reference rates.
Outside the euro area. Each national central bank publishes its own table, and local rules usually name it. A group with entities in several countries needs each bank's table, not a euro cross rate.

The point for choosing an API: a market mid-rate and an official table are different products. A market rate is right for showing a customer a price. It is not the figure a tax form or an auditor asks for.

The eight providers

1. AllRatesToday

Best for: teams that need both kinds of rate. Mid-market rates for 160+ currencies refresh every 60 seconds on every plan, on any base currency, over HTTPS. The same key serves the official tables of 123 central banks and 6 tax authorities, each with the publisher's own date. For Europe that means: ECB reference rates, plus the other European central banks and the Swiss customs table. Output is JSON, CSV, XML or Excel from the same endpoints, with SDKs for JavaScript, Python, PHP, Go and Rust and an MCP server for AI agents. Paid plans start at €4.99 a month; dated tables and history are on paid plans.

2. Frankfurter

Best for: projects that only need official fixings and want them free. Frankfurter is open source, needs no key and has no monthly cap. It now aggregates 111 central banks and official sources. For Europe its source list covers: ECB and other European central banks. It serves official fixings, not a live market rate, and it is a free service with no paid tier or support contract.

3. ExchangeRate-API

Best for: dashboards and reports that need volume and can live with one update a day. The free plan gives 1,500 requests a month with daily updates; the Pro plan is $10 a month for 30,000 requests with hourly updates. Rates are a blended market figure, not a named institution's table.

4. Open Exchange Rates

Best for: teams that want a long-established vendor and work from a US dollar base. The free plan gives 1,000 requests a month with hourly updates on a USD base; other base currencies start with the $12 a month plan.

5. CurrencyAPI

Best for: small private projects. The free plan gives 300 requests a month with daily updates and is for private use only; paid plans start at $12.99 a month.

6. Fixer

Best for: teams already on the apilayer marketplace. The free plan gives 100 calls a month with hourly updates for non-commercial use, and base-currency switching is listed only on paid plans, which start at $14.99 a month.

7. currencylayer

Best for: the same apilayer stack with a dollar source. The free plan gives 100 calls a month with daily updates for non-commercial use; paid plans start at $14.99 a month.

8. XE Currency Data

Best for: banks and large companies that need a recognised vendor on an annual contract. There is a trial but no free plan; the entry plan is $599 a year for 10,000 requests a month with daily rates.

Try it for EUR

# live mid-market rate
curl "https://allratestoday.com/api/v1/rates?source=EUR&target=USD" \
  -H "Authorization: Bearer YOUR_API_KEY"

# ECB reference rates, latest table
curl "https://allratestoday.com/api/open/central-bank/ecb"

# the ECB rate on the date VAT became chargeable
curl "https://allratestoday.com/api/v1/central-bank/ecb/2026-10-15" \
  -H "Authorization: Bearer YOUR_API_KEY"

The first call needs a free API key. The official table responses carry the table's own date, so you can show which publication a figure came from.

Which one should you pick?

If you are building	Look at
A European store or SaaS that needs a rate at checkout	AllRatesToday for 60-second rates on a EUR base.
VAT invoices on the ECB rate	Frankfurter is free and keyless and is hard to beat for the ECB fixing alone. AllRatesToday adds CSV, XML and Excel output and live rates on the same key.
A group with entities outside the euro area	An API with each national central bank's table. AllRatesToday and Frankfurter both aggregate them.
A dashboard that refreshes once a day	ExchangeRate-API has the largest free quota for daily data.
An enterprise procurement process	XE, on an annual contract.

FAQ

What is the best exchange rate API for Europe in 2026?

For live EUR rates plus ECB and other European central bank tables on one key, AllRatesToday. For the ECB fixing free and without a key, Frankfurter. For the largest free quota of daily market rates, ExchangeRate-API.

Can I use the ECB rate for VAT invoices?

Article 91(2) of the EU VAT Directive says Member States shall accept the latest exchange rate published by the European Central Bank at the time the tax becomes chargeable, as an alternative to the latest selling rate on the most representative exchange market.

When are ECB reference rates published?

Usually at around 16:00 CET every working day, based on a concertation between central banks at about 14:10 CET.

Is there a free ECB exchange rate API?

Yes. Frankfurter serves ECB reference rates free without a key, and the ECB offers its own data portal. AllRatesToday serves the same table with live market rates alongside.

Originally published on AllRatesToday. Live EUR rates and official central bank tables as JSON, CSV, XML and Excel: allratestoday.com/exchange-rate-api/.

Best Exchange Rate API for Singapore in 2026: 8 Compared for SGD Rates, MAS Data and GST

Exchange Rate API — Tue, 10 Nov 2026 14:26:08 +0000

Singapore companies trade in dollars, euros, yen, ringgit and rupiah as a matter of routine, and report GST in Singapore dollars. IRAS is specific about where the exchange rate may come from and how consistently it must be used. An API that serves the Monetary Authority of Singapore table alongside live rates covers both the product and the GST return.

This comparison looks at eight exchange rate APIs from the point of view of a team in Singapore. Free-tier limits and prices were read from each provider's own pricing page on 10 November 2026; they change often, so confirm before you commit.

What a team in Singapore needs from an exchange rate API

Live SGD pairs across Asian and major currencies.
Monetary Authority of Singapore rates, one of the sources IRAS accepts for GST.
A fixed, documented source: IRAS requires the chosen rate to be used consistently.
Regional coverage: Malaysia, Indonesia, Thailand, Hong Kong and China on the same key.

Quick comparison

Provider	Free tier	Updates on free	MAS exchange rates	Cheapest paid plan
AllRatesToday	Free key	Every 60 seconds	MAS daily rates (21 currencies)	€4.99/mo
Frankfurter	Free, no key, no monthly cap	Official fixings as each source releases them	MAS	No paid plan
ExchangeRate-API	1,500 requests a month	Once a day	No, market rates only	$10/mo
Open Exchange Rates	1,000 requests a month, USD base	Hourly	No, market rates only	$12/mo
CurrencyAPI	300 requests a month, private use only	Daily	No, market rates only	$12.99/mo
Fixer	100 calls a month, non-commercial	Hourly	No, market rates only	$14.99/mo
currencylayer	100 calls a month, non-commercial	Daily	No, market rates only	$14.99/mo
XE Currency Data	Trial only	Daily on the entry plan	No, market rates only	$599/yr

The Singapore rates and what they are for

MAS exchange rates. Daily rates for 21 currencies against the Singapore dollar, described by MAS as the average of buying and selling interbank rates quoted around midday in Singapore, with weekly and monthly averages also published.
IRAS acceptable sources for GST. Local banks, locally circulated newspapers and MAS are acceptable local sources. Reputable news agencies and foreign central banks without exchange controls are acceptable global sources.
IRAS consistency rule. The exchange rate selected must be updated at least once every three months and used consistently for at least one year from the end of the accounting period in which the source was first used.
Imports. Input tax on imports is claimed on the Singapore dollar amounts shown in the import permits issued by Singapore Customs.

The eight providers

1. AllRatesToday

Best for: teams that need both kinds of rate. Mid-market rates for 160+ currencies refresh every 60 seconds on every plan, on any base currency, over HTTPS. The same key serves the official tables of 123 central banks and 6 tax authorities, each with the publisher's own date. For Singapore that means: MAS daily rates (21 currencies). Output is JSON, CSV, XML or Excel from the same endpoints, with SDKs for JavaScript, Python, PHP, Go and Rust and an MCP server for AI agents. Paid plans start at €4.99 a month; dated tables and history are on paid plans.

2. Frankfurter

Best for: projects that only need official fixings and want them free. Frankfurter is open source, needs no key and has no monthly cap. It now aggregates 111 central banks and official sources. For Singapore its source list covers: MAS. It serves official fixings, not a live market rate, and it is a free service with no paid tier or support contract.

3. ExchangeRate-API

4. Open Exchange Rates

5. CurrencyAPI

Best for: small private projects. The free plan gives 300 requests a month with daily updates and is for private use only; paid plans start at $12.99 a month.

6. Fixer

7. currencylayer

Best for: the same apilayer stack with a dollar source. The free plan gives 100 calls a month with daily updates for non-commercial use; paid plans start at $14.99 a month.

8. XE Currency Data

Try it for SGD

# live mid-market rate
curl "https://allratestoday.com/api/v1/rates?source=USD&target=SGD" \
  -H "Authorization: Bearer YOUR_API_KEY"

# MAS, latest table
curl "https://allratestoday.com/api/open/central-bank/mas"

# the MAS table for an invoice date
curl "https://allratestoday.com/api/v1/central-bank/mas/2026-09-30" \
  -H "Authorization: Bearer YOUR_API_KEY"

The first call needs a free API key. The official table responses carry the table's own date, so you can show which publication a figure came from.

Which one should you pick?

If you are building	Look at
A Singapore platform pricing across Southeast Asia	AllRatesToday for 60-second rates on an SGD base, with the region's central banks on the same key.
GST invoices on the MAS rate	AllRatesToday or Frankfurter. Pick one source, document it, and keep it for at least a year as IRAS requires.
An ERP or accounting rate feed	AllRatesToday returns the MAS table as CSV, XML and Excel.
A dashboard that refreshes once a day	ExchangeRate-API has the largest free quota for daily data.
An enterprise procurement process	XE, on an annual contract.

FAQ

What is the best exchange rate API for Singapore in 2026?

For live SGD rates plus the MAS table on one key, AllRatesToday. For MAS fixings free and without a key, Frankfurter. For the largest free quota of daily market rates, ExchangeRate-API.

Which exchange rate does IRAS accept for GST?

IRAS accepts rates from local banks, locally circulated newspapers and MAS, and from reputable news agencies and foreign central banks without exchange controls. The source must be updated at least every three months and used consistently for at least a year.

How many currencies does MAS publish?

21 currencies against the Singapore dollar, as daily rates with weekly and monthly averages.

Can I change my GST exchange rate source during the year?

IRAS requires the selected rate to be used consistently for at least one year from the end of the accounting period in which the source was first used.

Originally published on AllRatesToday. Live SGD rates and official central bank tables as JSON, CSV, XML and Excel: allratestoday.com/exchange-rate-api/.

Fed H.10 Exchange Rate History: Download Federal Reserve Daily Rates 2016 to 2025 as CSV, Excel or API

Exchange Rate API — Tue, 10 Nov 2026 14:03:25 +0000

The Federal Reserve's H.10 release is the standard public source for daily US dollar exchange rates: it is what tax preparers use for a transaction-date rate, what analysts use for a clean long series, and what many accounting policies name for translation. The Fed's own download tool works, but it hands you one wide file with its own codes and "ND" markers. This guide shows the series already tidied, and how to use it.

What H.10 is

The Federal Reserve describes the rates as "noon buying rates in New York for cable transfers payable in foreign currencies", "certified by the Federal Reserve Bank of New York for customs purposes as required by section 522 of the amended Tariff Act of 1930". The schedule: "On Mondays at 4:15 p.m. the Federal Reserve Board releases daily bilateral exchange rates and U.S. dollar indexes for the previous business week." If Monday is a federal holiday, the release moves to the next business day.

Three practical consequences:

The data is daily but arrives weekly. Monday's release contains the five business days of the week before. The rate for last Tuesday is not available until the following Monday.
No rate on federal holidays. The Fed's files show "ND" (no data). In 2025 the series has 250 daily tables.
Four currencies are quoted the other way round. The euro, pound, Australian dollar and New Zealand dollar are in US dollars per unit. Everything else is in currency units per US dollar.

The tidy series: one CSV per year

The central-bank-exchange-rates repository holds the official H.10 tables under data/fed/history/, one file per year from 2016:

https://raw.githubusercontent.com/AllRates-Today/central-bank-exchange-rates/main/data/fed/history/2025.csv

date,base,quote,type,value
2025-01-02,AUD,USD,reference,0.6208
2025-01-02,EUR,USD,reference,1.0261
...
2025-01-02,USD,JPY,reference,...

The base and quote columns make the direction explicit: EUR,USD,1.0261 is dollars per euro, USD,JPY is yen per dollar. Holidays are simply absent, with no "ND" rows to filter. The files cover 22 currencies. Licence: CC BY-NC 4.0, free for research, personal filing and internal non-commercial use with attribution; commercial systems use the API.

Excel and Google Sheets

In Excel: Data > Get Data > From Web, paste the raw URL, and Power Query loads a table you can filter by base or quote. In Google Sheets:

=QUERY(IMPORTDATA("https://raw.githubusercontent.com/AllRates-Today/central-bank-exchange-rates/main/data/fed/history/2025.csv"),
       "select Col1, Col5 where Col2 = 'EUR'", 1)

pandas: one frame, one direction

import pandas as pd
base = "https://raw.githubusercontent.com/AllRates-Today/central-bank-exchange-rates/main/data/fed/history/{}.csv"
df = pd.concat(pd.read_csv(base.format(y), parse_dates=["date"]) for y in range(2016, 2026))

# normalise everything to "foreign currency units per 1 USD"
inv = df.base != "USD"
df["ccy"] = df.quote.where(~inv, df.base)
df["per_usd"] = df.value.where(~inv, 1 / df.value)
wide = df.pivot(index="date", columns="ccy", values="per_usd")

print(wide.loc["2025-12-31", ["EUR", "GBP", "JPY", "CAD"]].round(4))
# EUR 0.8521, GBP 0.7437, JPY 156.8000, CAD 1.3712
print(wide.loc["2025"].mean()[["EUR", "GBP", "JPY"]].round(4))   # 2025 averages
print(wide["EUR"].asof("2025-12-25"))                            # holiday -> Dec 24 rate

Two details in that snippet are the ones that cause wrong numbers elsewhere. The inversion puts all currencies on one basis before you average or compare. And asof returns the last available rate for a holiday or weekend date, which is the usual fallback for a transaction dated on a non-business day.

Check values

Date	EUR (USD per EUR)	GBP (USD per GBP)	JPY per USD	CAD per USD	INR per USD
Dec 31, 2024	1.0351	1.2521	157.37	1.4400	85.55
Dec 31, 2025	1.1736	1.3447	156.80	1.3712	89.84
2025 average (250 days)	1.1306	1.3192	149.57	1.3973	87.15
2025 low	1.0209	1.2158	140.81	1.3556	84.27
2025 high	1.1848	1.3754	158.31	1.4601	91.03

One date, as an API call

The latest released table:

curl "https://allratestoday.com/api/open/central-bank/fed"
# "rate_date": "2026-11-06", "cadence": "weekly",
# "rates": [ { "base": "EUR", "quote": "USD", "type": "reference", "value": 1.1154 }, ... ]

A past date or a range:

curl -H "Authorization: Bearer YOUR_KEY" \
  "https://allratestoday.com/api/v1/central-bank/fed/2025-12-31"

curl -H "Authorization: Bearer YOUR_KEY" \
  "https://allratestoday.com/api/v1/central-bank/fed/history?symbol=EUR&from=2025-01-01&to=2025-12-31"

Add ?format=csv, xml or xlsx to any table endpoint. Dated tables and history are on paid plans; a history request counts as one call per currency per month of data.

What the series is used for

Transaction-date rates for a sale, dividend or bonus on a US return.
Payment-date rates and yearly averages for the foreign tax credit. See the Form 1116 guide.
Fiscal-year averages for Form 5471. See Form 5471 exchange rates.
Monthly averages for a salary on Form 2555. See the Form 2555 guide.

For the FBAR and Form 8938, do not use H.10: those forms call for the Treasury year-end rate. The three tables are compared in exchange rates as of December 31, 2025.

FAQ

Where can I download Federal Reserve H.10 historical exchange rates?

The Federal Reserve offers the series through its H.10 pages and data download program. The same official daily tables are available as one tidy CSV per year from 2016 in the AllRates-Today central-bank-exchange-rates repository, and by date through the AllRatesToday API.

How often is H.10 published?

Weekly. On Mondays at 4:15 p.m. the Federal Reserve Board releases daily rates for the previous business week, or on the next business day if Monday is a federal holiday.

Which H.10 currencies are quoted in dollars per unit?

The euro, the UK pound, the Australian dollar and the New Zealand dollar. All other currencies in the release are quoted in currency units per US dollar.

Why is there no H.10 rate for some dates?

No rate is published on US federal holidays or weekends. The Fed's files mark those dates ND for no data. Use the last available rate before the date.

Can I use H.10 rates for the FBAR?

No. The FBAR and Form 8938 instructions point to the Treasury rate for the last day of the year. H.10 is the usual source for transaction-date rates and for computing averages.

Originally published on AllRatesToday. The Treasury, Federal Reserve and IRS tables used above are served as JSON, CSV, XML and Excel at allratestoday.com/tax-authority-rates-api/.

Form 5471 Exchange Rates: Average Rate, Year-End Rate and the Divide-By Convention by Schedule

Exchange Rate API — Tue, 10 Nov 2026 14:02:50 +0000

Form 5471 is the information return for US persons with interests in foreign corporations. Its schedules mix functional-currency columns and dollar columns, and the instructions do not use one exchange rate throughout. Preparers lose time on two things: which rate each schedule wants, and how the rate itself must be written on the form. This guide maps both, from the Instructions for Form 5471 (revision December 2025).

Not tax advice. This is a practical summary for people who prepare the spreadsheets, scripts and working papers. Quotations are from the IRS, Treasury and Federal Reserve texts current in November 2026; read the instructions for your own tax year and confirm your case with a US tax adviser.

How the rate must be reported: the divide-by convention

The instructions are explicit: "all exchange rates must be reported using a 'divide-by convention' rounded to at least four places." That is, "the exchange rate must be reported as the units of foreign currency that equal one U.S. dollar, rounded to at least four places. Do not report the exchange rate as the number of U.S. dollars that equal one unit of foreign currency." You must round to more than four places if four would materially distort the rate or the dollar amount.

This trips up anyone taking euro, sterling, Australian dollar or New Zealand dollar rates from the Federal Reserve, which quotes those four in dollars per unit. They have to be inverted:

Source figure	As quoted	Divide-by rate for Form 5471
Fed H.10, EUR, average of 2025 daily rates	1.1306 USD per EUR	0.8845
Fed H.10, EUR, December 31, 2025	1.1736 USD per EUR	0.8521
Fed H.10, GBP, average of 2025 daily rates	1.3192 USD per GBP	0.7580
Fed H.10, JPY, average of 2025 daily rates	149.5686 JPY per USD	149.5686

Treasury and IRS tables are already in units per dollar, but they are published to three decimals (0.851, 0.886), which does not meet "at least four places" on its own. A daily series you can average and round yourself is the practical source.

Which rate on which schedule

Schedule	What the instructions say	Rate in practice
C, income statement	Report in functional currency in accordance with US GAAP "and translate using U.S. GAAP translation principles"	ASC 830: rates at the dates items are recognized, usually a weighted average for the period
F, balance sheet	Report in US dollars; the balance sheet is generally "translated to U.S. dollars using U.S. GAAP translation rules"	ASC 830: the current rate at the balance sheet date for assets and liabilities
E, foreign taxes	Translate "at the average exchange rate for the tax year to which the tax relates unless one of the exceptions below applies. See section 986(a)."	Average for the year; payment-date rate for the exceptions
H, current earnings and profits, line 5d	Translate "at the average exchange rate for the foreign corporation's tax year. See section 989(b)."	Average for the corporation's tax year
M, related-party transactions	"Use the average exchange rate for the foreign corporation's tax year. See section 989(b)."	Average for the corporation's tax year
I-1, GILTI information	Average rate for the CFC's year	Average for the corporation's tax year

The Schedule E exceptions mirror section 986(a): taxes paid before the year begins, taxes not paid within 2 years, a section 986(a)(1)(D) election, a cash-basis corporation, and inflationary currencies all use the payment-date rate. Corporations using the dollar approximate separate transactions method follow Reg. section 1.985-3 for Schedule F instead.

Section 989(b) in two lines

Actual distributions of earnings: "the spot rate on the date such distribution is included in income."
Subpart F inclusions under section 951(a)(1)(A): "the average exchange rate for the taxable year of the foreign corporation."

So a dividend paid on a specific day needs that day's rate, while the year's inclusion uses the year's average.

What "average for the tax year" means for a fiscal-year corporation

The average is for the foreign corporation's tax year, not the calendar year and not the US shareholder's year. A German subsidiary with a year ending September 30, 2025 needs the average of October 1, 2024 to September 30, 2025. The IRS calendar-year average table does not cover that; you compute it from a daily series:

import pandas as pd
base = "https://raw.githubusercontent.com/AllRates-Today/central-bank-exchange-rates/main/data/fed/history/{}.csv"
df = pd.concat(pd.read_csv(base.format(y), parse_dates=["date"]) for y in (2024, 2025))
eur = df[df.base == "EUR"].set_index("date").value            # USD per EUR
fy = eur["2024-10-01":"2025-09-30"]
print(round(1 / fy.mean(), 4))                                # divide-by rate, units per USD

State in the working papers that the average is the simple mean of the daily Federal Reserve H.10 rates for the business days of the period, and use the same construction every year.

Calendar 2025 reference rates

Units of foreign currency per one US dollar, in divide-by form:

Currency	2025 average (Fed H.10 daily mean)	IRS 2025 yearly average	Dec 31, 2025 (Fed H.10)	Dec 31, 2025 (Treasury)
EUR	0.8845	0.886	0.8521	0.851
GBP	0.7580	0.759	0.7437	0.743
CAD	1.3973	1.398	1.3712	1.369
JPY	149.5686	149.632	156.8000	156.61
CHF	0.8305	0.831	0.7936	0.792
INR	87.1468	87.133	89.8400	89.854
MXN	19.2052	19.212	18.0057	17.956
CNY	7.1875	7.129	6.9931	6.998

The year-end sources do not agree to the last digit: Treasury's quarterly table reflects rates reported for the last business day of the prior month, while H.10 is the noon buying rate on the day. Pick the source that matches your GAAP translation policy and use it for both the financial statements and Schedule F.

Pulling the rates

# the H.10 table for a balance sheet date
curl -H "Authorization: Bearer YOUR_KEY" \
  "https://allratestoday.com/api/v1/central-bank/fed/2025-12-31"

# a daily series for a fiscal-year average
curl -H "Authorization: Bearer YOUR_KEY" \
  "https://allratestoday.com/api/v1/central-bank/fed/history?symbol=EUR&from=2024-10-01&to=2025-09-30"

Every table endpoint returns JSON, CSV, XML or Excel through ?format=. Dated tables and history are on paid plans. For currencies outside the Federal Reserve's list, the same endpoints serve each country's own central bank table.

FAQ

How must exchange rates be reported on Form 5471?

Using the divide-by convention: units of foreign currency that equal one US dollar, rounded to at least four places. The instructions say not to report the number of US dollars per unit of foreign currency.

Which exchange rate does Schedule H use?

Line 5d of Schedule H translates current earnings and profits at the average exchange rate for the foreign corporation's tax year, citing section 989(b).

Which exchange rate does Schedule F use?

Schedule F is reported in US dollars and the balance sheet is generally translated using US GAAP translation rules, which means the current rate at the balance sheet date for assets and liabilities.

Which rate applies to foreign taxes on Schedule E?

The average exchange rate for the tax year to which the tax relates, under section 986(a), unless an exception applies. The exceptions, such as taxes not paid within 2 years or a cash-basis corporation, use the payment-date rate.

Can I use the IRS yearly average table for a fiscal-year foreign corporation?

The IRS table is a calendar-year average published to three decimals. A corporation with a different tax year needs an average over its own year, computed from a daily series, and Form 5471 asks for at least four places.

Originally published on AllRatesToday. The Treasury, Federal Reserve and IRS tables used above are served as JSON, CSV, XML and Excel at allratestoday.com/tax-authority-rates-api/.

20 Currency & Exchange Rate API Questions Answered (2026)

Exchange Rate API — Thu, 28 May 2026 08:46:18 +0000

Developers keep searching for the same set of questions about currency APIs, exchange rate APIs, and forex APIs: which ones are free, which are reliable, what Xe costs, whether Google has an API, how to build a converter in Python. We pulled the 20 most-asked from Google's People Also Ask and answered each one directly -- no fluff, no affiliate padding.

Is there a free API for currency conversion?
What is a currency API?
What is a forex API?
What is an FX API?
What is an open exchange rate?
Is the Frankfurter API free?
Is an exchange rate API free?
Is ExchangeRate-API free?
How much does ExchangeRate-API cost?
Does Xe have an API?
Is the Xe API free?
Is the Google Currency Converter API free?
Is Fixer.io reliable?
Is the MT5 API free?
Building a currency converter in Python?
What is the formula to calculate an exchange rate?
What is the GOOGLEFINANCE function?
Which is the best currency converter?
Best currency converter app?
Best rate when converting currency?

Q1.Is there a free API for currency conversion?

Yes -- several. The main free options in 2026:

Frankfurter -- 100% free, no API key, ECB daily reference rates for ~30 currencies, historical back to 1999.
fawazahmed0/currency-api -- free via jsDelivr CDN, 200+ currencies including crypto.
ExchangeRate-API -- 1,500 requests/month on the free tier (key required).
freecurrencyapi.com -- 5,000 requests/month.
AllRatesToday -- free API key for real-time rates, plus the official tables of 123 central banks with no key at all.

For deeper coverage of the trade-offs, see our guide to the best free currency exchange APIs.

Q2.What is a currency API?

A currency API is a REST web service that returns exchange rates between currencies, usually as JSON. A typical call:

GET https://allratestoday.com/api/v1/rates?source=USD&target=EUR
-> {"rate": 0.8628, "source": "USD", "target": "EUR", "time": "2026-11-09T12:00:00Z"}

Currency APIs power e-commerce checkout, finance dashboards, accounting tools, travel apps, international payroll, and any software that displays money in more than one currency. Full background in What is a currency API?.

Q3.What is a forex API?

A forex (FX) API is a currency API built for trading rather than display. Expect:

Tick-level bid/ask quotes with millisecond latency (not just a mid-market rate)
Historical OHLC (open/high/low/close) data for charting
Sometimes order execution endpoints -- place, modify, cancel

Examples: OANDA, MetaTrader (MT4/MT5), TraderMade, Polygon.io, FXCM. General-purpose currency APIs only return reference mid-market rates and are not suitable for trading.

Q4.What is an FX API?

"FX API" is another name for "forex API." Some enterprise providers -- banks, Stripe's FX product, Bloomberg, OCBC -- reserve "FX API" for streaming quotes and execution services covering 100+ pairs. In casual developer conversation, "currency API" and "FX API" are often used interchangeably.

Q5.What is an open exchange rate?

Two meanings:

Generic: an exchange rate openly accessible through a public API -- no private contract needed.
Specific: Open Exchange Rates is the name of a commercial provider publishing rates for 200+ currencies since 2011. Free tier: 1,000 requests/month, hourly updates, USD base only.

Q6.Is the Frankfurter API free?

Yes. Frankfurter is a free, open-source currency data API with no key, no signup, and no documented rate limit for normal use. It tracks ~30 currencies using European Central Bank daily reference rates and supports historical data back to 1999. Because it's ECB-based, rates update once per business day around 16:00 CET -- great for accounting and display, not for trading.

Q7.Is an exchange rate API free?

Depends on the provider:

Provider	Free tier	Key?
Frankfurter	Unlimited	No
fawazahmed0	Unlimited	No
AllRatesToday	Free API key; official central bank tables keyless	Market rates yes, official tables no
ExchangeRate-API	1,500/mo	Yes
freecurrencyapi.com	5,000/mo	Yes
Open Exchange Rates	1,000/mo	Yes
Fixer.io	100/mo	Yes
Xe / OANDA / Bloomberg	None	Yes

See Best free currency exchange API (2026) for a detailed comparison.

Q8.Is ExchangeRate-API free?

ExchangeRate-API has a free plan of 1,500 requests/month , no credit card required. Fine for hobby projects, prototypes, and small internal tools. The terms of service ask commercial users to upgrade. Also note that the rate is ExchangeRate-API's own proprietary blend of undisclosed sources: not a central bank rate, not a standardised fixing, so it cannot be reproduced or cited in a filing.

Q9.How much does ExchangeRate-API cost?

Paid plans as of 2026:

Pro -- $13.99/month, 30,000 requests/month, hourly updates
Business -- $29/month, 100,000 requests/month
Volume -- $49/month, 1.5M requests/month, minute-level updates
Enterprise -- custom

Prices change occasionally; check their pricing page for current numbers.

Q10.Does Xe have an API?

Yes. Xe Currency Data API provides real-time and historical exchange rates for 170+ currencies. It's used by Fortune 500 companies, banks, and fintechs, with optional SLAs and uptime guarantees. Full breakdown in Does Xe have an API?.

Q11.Is the Xe API free?

No. Xe has no public free tier. Pricing is enterprise-only and typically starts around $799/month depending on volume and features. For free access, Frankfurter, ExchangeRate-API's free tier, or an AllRatesToday free API key are the common alternatives.

Q12.Is the Google Currency Converter API free?

There is no official public Google Currency API (the old Google Finance API was retired in 2012). What exists:

The GOOGLEFINANCE function in Google Sheets -- free, ~20-minute delay, not a REST API.
Unofficial wrappers (e.g. currency-api.appspot.com) -- community-hosted, no SLA, can disappear without warning.

Don't depend on Google for production currency rates. Use a supported provider.

Q13.Is Fixer.io reliable?

Yes, within its bounds. Fixer.io is owned by apilayer and has been running since 2015. Paid plans have uptime guarantees and are generally reliable. Limitations on the free tier are heavy: 100 requests/month, HTTP only (no HTTPS), and EUR is the only allowed base currency. Most production users end up on Basic ($14.99/month) or Professional ($59.99/month). Side-by-side: AllRatesToday vs Fixer.

Q14.Is the MT5 API free?

No. MetaTrader 5 Manager and Gateway APIs require a licensed MT5 server and a paid integration agreement with MetaQuotes. Brokers may offer trial access to demo accounts. If you only need exchange rates (not trade execution), a plain currency API is dramatically simpler and cheaper.

Q15.How do you make a currency converter in Python with an API?

Minimal working example using Frankfurter (no key needed):

import requests

def convert(amount, src, dst):
    r = requests.get("https://api.frankfurter.dev/v1/latest",
                     params={"from": src, "to": dst})
    r.raise_for_status()
    rate = r.json()["rates"][dst]
    return amount * rate, rate

amount, rate = convert(100, "USD", "EUR")
print(f"100 USD = {amount:.2f} EUR  (rate {rate})")

Add error handling for timeouts and unknown currency codes, cache results for 30-60 minutes, and you have a production-ready converter. Deeper walk-through in How to get live exchange rates in Python.

Q16.What is the formula to calculate an exchange rate?

The exchange rate is the ratio of two currency amounts:

rate = target_amount / source_amount

If 100 USD buys 85 EUR, the USD->EUR rate is 85 / 100 = 0.85. To convert any amount, multiply by the rate:

250 USD × 0.85 = 212.50 EUR

The inverse (EUR->USD) is 1 / 0.85 ≈ 1.176. Real-world rates include a spread -- the "buy" and "sell" rates differ slightly, and that gap is the provider's margin. More: Mid-market vs retail exchange rates.

Q17.What is the GOOGLEFINANCE function for exchange rates?

In Google Sheets:

=GOOGLEFINANCE("CURRENCY:USDEUR")

Replace USDEUR with any two concatenated ISO 4217 codes (GBPJPY, AUDCAD, etc.). For historical rates, add a date:

=GOOGLEFINANCE("CURRENCY:USDEUR", "price", DATE(2024,1,1))

Rates are delayed ~20 minutes. Fine for spreadsheets; don't build production systems on it. For Excel, see How to get exchange rates in Excel.

Q18.Which is the best currency converter?

Depends on the use case:

Sending money abroad: Wise -- real mid-market rate, transparent fees.
Quick lookup on web/mobile: Google search or XE.com.
Embedding in software: AllRatesToday for real-time plus official rates, or Frankfurter for ECB only.
Enterprise / trading: Xe, OANDA, or Bloomberg.

For developers comparing providers head-to-head, see best exchange rate API comparison.

Q19.What is the best currency converter app to use?

Most-recommended consumer apps in 2026:

Wise -- best mid-market rate + actual money transfer.
XE Currency -- clean UI, offline mode for travel.
Revolut -- multi-currency account with in-app conversion.
Currency Converter Plus -- simple free converter (ad-supported).

Q20.Where should you convert currency for the best exchange rate?

You get closest to the mid-market rate with online-first providers: Wise , Revolut , Currencies Direct , or OFX. Traditional banks and airport kiosks mark up the rate by 2-5% on top of a fee. Travel-friendly credit cards (no foreign transaction fee) are good for purchases abroad; avoid "Dynamic Currency Conversion" at the point of sale -- always pay in the local currency.

Rule of thumb: check the mid-market rate first (Google, AllRatesToday, XE), then compare the rate you're offered. Any gap is the provider's margin.

Ready to integrate a reliable currency API? Get your free API key -- no credit card required. Official central bank tables need no key at all: https://allratestoday.com/api/open/central-bank/ecb.

Get started

npm install @allratestoday/sdk

10 Best Currency Exchange API Options for Developers (2026)

Exchange Rate API — Thu, 28 May 2026 08:45:50 +0000

If you are building a financial app, an e-commerce checkout, or an analytics dashboard, you need reliable exchange rate data. Hard-coding rates or scraping them from a website is slow, fragile, and a support nightmare. A currency exchange API solves this by delivering live, accurate FX data to your application on demand.

This guide explains what a currency conversion API is, how it works, which features actually matter, and compares the 10 best currency exchange APIs available to developers in 2026 -- starting with AllRatesToday, which is the only one in the list that serves both real-time market rates and the official daily tables of 123 central banks, with SDKs in five languages and a free API key that needs no credit card.

What Is a Currency Conversion API?

A currency conversion API is a web service that returns live or historical exchange rate data over HTTPS in a machine-readable format -- usually JSON. Your application sends a request (e.g. "USD to EUR"), and the API responds with the current mid-market rate pulled from its data feeds.

Instead of maintaining your own pipeline of bank feeds, FX aggregators, and crypto exchanges, you integrate one REST endpoint and let the provider handle the data plumbing.

Why Developers Need a Currency API

Localized pricing -- display product prices in the visitor's local currency to reduce cart abandonment.
Multi-currency billing -- invoice SaaS customers in their own currency while reporting in a single base.
Financial reporting -- convert foreign transactions to the reporting currency at historical rates.
Trading and analytics -- feed dashboards, screeners, and backtests with live FX and crypto data.
Cross-border payouts -- calculate accurate settlement amounts for marketplaces and payroll systems.

How a Currency API Works

Your application sends an HTTPS request with a source currency, target currencies, and an API key.
The provider's server looks up the latest rates from aggregated data sources (banks, interbank feeds, exchanges).
The server returns a JSON response with the requested rates and a timestamp.
Your application caches or uses the rate to convert amounts.

Common Endpoint Types

Latest Rates -- the most recent exchange rates for one or many currency pairs.
Historical Rates -- rates on a specific past date, useful for accounting and charting.
Time Series -- a range of daily rates between two dates for trend analysis.
Convert -- a convenience endpoint that does the math for you.
Fluctuation -- the change, percentage change, and high/low over a period.

What Makes a Great Currency API

Traceable data sources -- a market mid-rate you can reconcile, or an official central bank table you can cite. Avoid proprietary blends with undisclosed weighting.
Update frequency -- real-time tiers drop to 60 seconds or faster.
Coverage -- 150+ fiat currencies plus metals and crypto where relevant.
Transparent pricing -- a real free tier, no hidden fees, no credit-card walls.
Official SDKs -- so you don't write HTTP plumbing.
Clean JSON responses and strong documentation.
Security -- HTTPS, scoped API keys, reasonable rate limits.

The 10 Best Currency Exchange APIs in 2026

1. AllRatesToday -- The Best Currency Exchange API for Developers

AllRatesToday delivers real-time mid-market exchange rates for 160+ currencies, refreshed every 60 seconds, and alongside them the official daily tables of 123 central banks and 4 tax authorities (ECB, Fed, RBI, SBI, BoE, SNB, CBUAE, SAMA, IRS yearly averages and more). It is purpose-built for developers: a clean REST API, official SDKs for JavaScript, Python, PHP, Go and Java, an MCP server, drop-in compatible endpoints for Fixer and exchangeratesapi.io, and a free API key that does not ask for a credit card.

Highlights: 160+ currencies, 60-second updates, 123 official central bank tables (keyless), SDKs in 5 languages, JSON/CSV/XML/XLSX output, history and commercial use on every paid plan from €4.99/month.

# real-time market rate
curl "https://allratestoday.com/api/v1/rates?source=USD&target=EUR" \
  -H "Authorization: Bearer YOUR_API_KEY"

# official ECB table, no key needed
curl "https://allratestoday.com/api/open/central-bank/ecb"

Best for -- fintech apps, SaaS billing, e-commerce localization, accounting and tax tooling, and any developer who needs a rate that is fresh now and defensible later.

2. CurrencyFreaks

Covers 1,000+ symbols including fiats, metals, and hundreds of cryptocurrencies. Update frequency ranges from 24 hours on the free plan down to 60 seconds on the Professional tier. A solid all-rounder if breadth of crypto coverage matters more than depth of FX sourcing.

3. Fixer

Delivers FX rates through a clean JSON API, with historical data going back to 1999 and sourcing aligned with the European Central Bank. The free plan is capped at 100 calls/month with hourly updates -- suitable mainly for prototypes.

4. ExchangeRate-API

Simple API with 161 currencies and a 1,500 request/month free tier. Paid plans bring hourly and 5-minute updates. Note that its rate is a proprietary blend with undisclosed weighting: it is not a central bank rate or a standardised fixing, so it cannot be reproduced or cited.

5. Open Exchange Rates

A long-running provider with 200+ currencies and a large ecosystem of open-source client libraries. The free tier is hourly-updated and capped at 1,000 requests.

6. CurrencyLayer

Part of the APILayer network; 168 currencies and metals with a familiar endpoint structure. Free tier is limited to 100 calls/month.

7. XE

A well-known brand with 30+ years of FX history and 170+ currencies. Pricing is annual and geared toward enterprises rather than indie developers, with plans starting in the high hundreds per year.

8. CurrencyAPI

Straightforward REST API covering 170+ fiat currencies and cryptocurrencies, with sandbox access on paid tiers and 60-second updates at higher plans.

9. Alpha Vantage

Broader market-data API covering stocks, forex, crypto, ETFs, and commodities, plus 60+ technical indicators. Rate limits on the free tier are low but cross-asset coverage is unmatched in this list.

10. ExchangeRate.host

Simple, fast forex and crypto API with 19 years of historical data, 168+ symbols, and a free plan. Paid tiers unlock higher request limits and faster updates.

Comparison Table

API	Free Tier	Currencies	Update Frequency	Credit Card
AllRatesToday	Free API key + keyless official tables	160+	Real-time (60s)	No
CurrencyFreaks	1,000 req/month	1,000+	Daily (free)	No
Fixer	100 req/month	170+	Hourly	Yes
ExchangeRate-API	1,500 req/month	161	Daily	Yes (upgrades)
Open Exchange Rates	1,000 req/month	200+	Hourly	Yes
CurrencyLayer	100 req/month	168	Daily	Yes
XE	Free trial	170+	Up to 60s	Yes
CurrencyAPI	300 req/month	170+	Daily	Yes
Alpha Vantage	25 req/day	Multi-asset	Daily	No
ExchangeRate.host	Free plan	168+	Daily	No

How to Choose the Right API

Real-time trading or pricing -- pick a provider with 60-second updates (AllRatesToday, CurrencyFreaks Pro, XE).
Accounting and reporting -- historical endpoints and citable sources matter more than latency. AllRatesToday is the only entry here with official central bank tables.
Crypto-first apps -- CurrencyFreaks or CurrencyAPI for breadth; AllRatesToday if you need FX plus official rates.
Prototypes and hobby projects -- prefer free tiers without credit-card walls (AllRatesToday, ExchangeRate.host).
Multi-asset dashboards -- Alpha Vantage is the clear choice for equities + FX + crypto in one API.

Getting Started with AllRatesToday

Register at allratestoday.com/register -- no credit card required.
Copy your API key from the dashboard.
Install an SDK or use curl:

npm install @allratestoday/sdk

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday({ apiKey: process.env.ALLRATES_API_KEY });
const { rate } = await client.getRate('USD', 'EUR');
console.log(1 USD = ${rate} EUR);

That is it -- live FX data in your application, with the official central bank tables one keyless call away.

FAQs

How do I start with a free currency API?

Sign up for the provider's free plan, get an API key, and send a request to the latest-rates endpoint using curl or your language's HTTP client.

Which languages can I use?

Any language that can make an HTTPS request. AllRatesToday ships official SDKs for JavaScript/TypeScript, Python, PHP, Go and Java.

Can I get both real-time and historical rates?

Yes -- quality APIs expose both. Historical endpoints usually accept a YYYY-MM-DD date parameter.

Do free tiers support cryptocurrency?

Some do (CurrencyFreaks, CurrencyAPI). Always check the documentation for supported symbols before committing.

How often are rates updated?

Free tiers typically refresh daily or hourly. Paid tiers drop to 60 seconds or faster. AllRatesToday updates every 60 seconds; its official central bank tables update once per business day when each bank publishes.

DEV Community: Exchange Rate API

Exchange Rate API Unit Testing: Mocks, Fixtures and Contract Tests

Rule one: never assert on live values

Inject a rate provider

Fixtures with the real response shape

Mocking fetch with msw in Vitest or Jest

Python with responses and pytest

Freeze time as well as rates

A nightly contract test against the real API

What to assert, and what not to

FAQ

Should unit tests call the real exchange rate API?

What should a contract test assert if rates change every minute?

How do I test the rate limit path?

Does testing a bad key against the real API use up my quota?

Can I use msw with Jest as well as Vitest?

Exchange Rates API Data in a Database: Schema, Indexes and As-Of Queries

The table

Primary key and indexes

As-of lookups: the latest rate on or before a date

Why not store inverses

Triangulation through USD or EUR

Idempotent upserts with ON CONFLICT

Loading daily from the exchange rates API

Retention

MySQL and SQLite notes

FAQ

What data type should I use for exchange rates in SQL?

How do I get the exchange rate for a date with no rate?

Should I store both USD/EUR and EUR/USD?

How do I avoid duplicate rows when the loader runs twice?

Can I mix official and mid-market rates in one table?

Free Currency Converter API for iOS and Android: Swift and Kotlin

The architecture: app, proxy, API

The free currency converter API response you decode

Converting on the device

iOS: Swift with URLSession, async/await and Codable

Android: Kotlin with OkHttp and kotlinx.serialization

Offline behaviour

Refresh policy

Rates are mid-market

FAQ

Is there a free currency converter API for mobile apps?

Can I put the API key in my iOS or Android app?

Why does decoding fail with a type mismatch?

How should the app work offline?

How often should a mobile converter refresh rates?

Currency Exchange Rates API for Invoices: Which Rate to Use

The date: tax point or date of supply

Official rates named by law

Mid-market for display, official for the tax line

What to store on the invoice

Fetching an official rate for a date

A checklist for your invoicing code

FAQ

Which exchange rate should I use on a foreign-currency invoice?

Can I use a mid-market rate for VAT on an invoice?

What should I store with each invoice?

What if the date of supply is a weekend or a holiday?

Is this tax advice?

Related

Exchange Rate API Free for Commercial Use? What Free-Tier Terms Say

What free exchange rate API terms typically say

1. Non-commercial clauses: Fixer and currencylayer

2. Use allowed, fitness limited: ExchangeRate-API

3. Commercial use allowed: Frankfurter

4. Free for testing, paid for business: AllRatesToday

Attribution requirements

What "commercial" usually covers

How to check exchange rate API terms in ten minutes

Testing on a free key, shipping on a paid one

When free is the right answer

FAQ

Can I use a free exchange rate API in a commercial app?

Does an ad-supported website count as commercial use?

Is an internal business tool commercial use?

Do free exchange rate APIs require attribution?

Is this legal advice?

Related

Live FX Rates API: Polling vs WebSocket, and How to Poll Efficiently