DEV Community: viraj geeth

Loading Official Central Bank Exchange Rates into Odoo (res.currency.rate, the Right Direction)

viraj geeth — Fri, 16 Oct 2026 13:38:06 +0000

Odoo's Automatic Currency Rates setting (module currency_rate_live) pulls from a fixed list of providers: the ECB, the Swiss FTA, the Bank of Canada, Banxico and a few more. If the central bank your statutory accounts must follow is on that list, use it and stop reading.

If it is not, or you run subsidiaries under several central banks and want one feed, you write the rows yourself. The good news is that res.currency.rate is one of the most stable models in Odoo and the loader is short. The full version with notes is in the Odoo guide.

The rate Odoo stores

res.currency.rate.rate is units of the foreign currency per 1 unit of the company currency. For a EUR company and USD that is USD per EUR, which is the ECB's own direction, so nothing to invert.

For an INR company following the Reserve Bank of India, which publishes INR per USD, you need the inverse. Do not divide in your own code. Ask the API for the pair in Odoo's direction and let it invert, flagging what it did:

GET https://allratestoday.com/api/v1/central-bank/rbi/latest?source=INR&target=USD

{ "bank": "rbi", "rate_date": "2026-10-09", "source": "INR", "target": "USD",
  "rate": 0.01035, "derived": true, "method": "inverse" }

derived: true with method: "inverse" is the line you want in your audit file. When the bank publishes the pair directly you get derived: false, method: "published".

The loader

import xmlrpc.client, requests

URL, DB, USER, PWD = "https://erp.example.com", "prod", "bot@example.com", "api-key"
BANK = "ecb"
ART = {"Authorization": "Bearer art_live_your_key"}

common = xmlrpc.client.ServerProxy(f"{URL}/xmlrpc/2/common")
uid = common.authenticate(DB, USER, PWD, {})
models = xmlrpc.client.ServerProxy(f"{URL}/xmlrpc/2/object")
call = lambda model, method, *args, **kw: models.execute_kw(DB, uid, PWD, model, method, list(args), kw)

company = call("res.company", "read", [1], fields=["currency_id"])[0]
home = call("res.currency", "read", [company["currency_id"][0]], fields=["name"])[0]["name"]
active = {c["name"]: c["id"] for c in call("res.currency", "search_read", [["active", "=", True]], fields=["name"])}

for code, currency_id in active.items():
    if code == home:
        continue
    r = requests.get(f"https://allratestoday.com/api/v1/central-bank/{BANK}/latest",
                     params={"source": home, "target": code}, headers=ART, timeout=10)
    if r.status_code == 404:
        continue                                   # bank does not publish this currency
    body = r.json()
    vals = {"currency_id": currency_id, "name": body["rate_date"], "rate": body["rate"], "company_id": 1}
    existing = call("res.currency.rate", "search",
                    [["currency_id", "=", currency_id], ["name", "=", body["rate_date"]], ["company_id", "=", 1]])
    if existing:
        call("res.currency.rate", "write", existing, vals)
    else:
        call("res.currency.rate", "create", vals)
    print(code, body["rate_date"], body["rate"], body["method"])

Three details that bite people:

name is the effective date, not the run date. Always use the bank's rate_date. If you run the loader on a Monday for a bank that publishes on business days, you get Friday's table dated Friday, which is correct.
Multi-company: run the loop per company with that company's home currency, and per bank code if the subsidiaries sit under different central banks.
Month-end sources such as HMRC's monthly table or a monthly-average publisher load the same way on a monthly cron.

Run it inside Odoo

Put the loop in a small custom module and register an ir.cron that runs daily after the bank's publication time. Inside Odoo the same logic uses self.env['res.currency.rate'] and requests, with the API key in an ir.config_parameter rather than in the code. An inverse_company_rate field also exists from Odoo 14; writing either field is fine, but be consistent so reruns update rather than fight.

Try it without a key

https://allratestoday.com/api/open/central-bank/ecb returns the latest ECB table keyless, so you can prototype the loader before signing up.

Official Central Bank Exchange Rates in Dynamics 365 Business Central (No Extension Needed)

viraj geeth — Tue, 13 Oct 2026 16:35:35 +0000

If your finance team has to book foreign-currency transactions at the rate a specific central bank publishes, Business Central can do it without a single line of AL. The product has shipped a URL-driven importer since NAV 2015, the Currency Exchange Rate Service, and all it needs is an XML feed it can parse and a field mapping.

This post walks through pointing that importer at an official central-bank table. The full procedure with every field is in the Business Central guide on AllRatesToday.

The two limits of the built-in importer

The Currency Exchange Rate Service has two constraints that rule out most rate APIs:

It reads XML, not JSON.
It cannot send request headers, so an API key has to travel on the URL.

Both are covered by two query parameters on the AllRatesToday central-bank endpoint:

https://allratestoday.com/api/v1/central-bank/ecb/latest?format=xml&api_key=art_live_your_key

Swap ecb for any of the 121 bank codes on the coverage map: rbi for the Reserve Bank of India, boe for the Bank of England, cbuae for the UAE, bsp for the Philippines, and so on.

The response is the bank's complete latest table:

<?xml version="1.0" encoding="UTF-8"?>
<response>
  <bank>ecb</bank>
  <name>European Central Bank</name>
  <rate_date>2026-10-09</rate_date>
  <rates>
    <rate><base>EUR</base><quote>USD</quote><type>reference</type><value>1.1206</value></rate>
    <rate><base>EUR</base><quote>GBP</quote><type>reference</type><value>0.84763</value></rate>
    ...
  </rates>
</response>

Want to try before you sign up? The keyless copy at https://allratestoday.com/api/open/central-bank/ecb returns the same table as JSON.

Create the service

Search for Currency Exchange Rate Services, choose New.
Code it ECB-OFFICIAL, paste the URL into Service URL, click Preview. Business Central fetches the feed and shows the XML tree.
On Field Mapping, set the Parent Node to the repeating rate element and map the fields below.
Enable the service and give the Job Queue entry a run time after the bank's publication time. The ECB publishes around 16:00 CET; every bank's cadence is on its page.

The field mapping, and why direction matters

Business Central stores each rate as Exchange Rate Amount (foreign) against Relational Exch. Rate Amount (local). Which of the feed's two sides goes where depends on how the bank quotes.

Business Central field	Bank quotes foreign per 1 home (ECB, BoE, RBA)	Bank quotes home per 1 foreign (RBI, CBN, BSP)
Currency Code	`quote`	`base`
Starting Date	`rate_date`	`rate_date`
Exchange Rate Amount	`value`	`1`
Relational Exch. Rate Amount	`1`	`value`

The ECB says "1 EUR = 1.1206 USD", so USD is the quote and the value is the foreign amount. The RBI says "1 USD = 96.6149 INR", so USD is the base and the value is the local amount. Map it once per bank and the importer handles every currency in the table the same way.

If you would rather not think about direction at all, the endpoint can resolve a single pair for you: ?source=USD&target=EUR returns one rate in exactly that direction, with derived and method fields that say whether it was published as-is, inverted, or crossed through the home currency. That is the audit trail an external auditor asks for.

When you do want an extension

The built-in service imports a whole table on a schedule. If you need per-company bank codes, a "run now" action, or a log of currencies skipped because they are not set up in the Currency table, an AL codeunit using HttpClient against the JSON endpoint is about 150 lines. The rate_date, stale and age_days fields in the JSON tell the codeunit whether the bank has published a new table yet, so you never post a stale rate as today's.

@allratestoday/sdk: The Official JavaScript SDK for Real-Time Exchange Rates

viraj geeth — Sun, 27 Sep 2026 13:38:34 +0000

Wiring a currency API into a Node or browser app shouldn't take more than a few minutes. With the @allratestoday/sdk package, it doesn't.

It's the official JavaScript SDK for the AllRatesToday API — a real-time FX service serving mid-market rates for 160+ currencies — and it covers everything the raw API does, with TypeScript types, zero runtime dependencies, and an ergonomic surface.

Why this SDK

⚡ Zero runtime dependencies — pure TypeScript, uses native fetch
📡 Real-time data — rates refreshed every 60 seconds
💹 Mid-market rates — no retail spread baked in
🌍 160+ currencies — major, minor, and exotic pairs (plus precious metals)
🔷 Type-safe — full TypeScript, intelligent autocomplete, strongly typed responses
🌐 Universal — works in Node.js 18+ and modern browsers

Install

npm install @allratestoday/sdk

Grab a free API key at allratestoday.com/register — no credit card required.

Quick start

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday({ apiKey: 'YOUR_API_KEY' });

const { rates } = await client.latest({
  base: 'USD',
  symbols: ['EUR', 'GBP', 'JPY'],
});

console.log(rates);
// { EUR: 0.92, GBP: 0.78, JPY: 149.5 }

Latest rates

Get all rates against a base, or filter to the pairs you actually need:

// All rates from USD
const all = await client.latest();

// Just the ones you care about — cheaper payload, same response shape
const subset = await client.latest({
  base: 'USD',
  symbols: ['CHF', 'GBP', 'JPY'],
});

Historical rates

Look up rates for a specific date — ideal for reporting, invoice re-calculation, or compliance workflows:

const historical = await client.historical({
  date: '2025-12-31',
  base: 'USD',
  symbols: ['EUR', 'GBP'],
});

Currency conversion

Skip the math and ask for an amount:

const converted = await client.convert({
  from: 'USD',
  to: 'EUR',
  amount: 100,
});

console.log(converted);
// { from: "USD", to: "EUR", amount: 100, converted: 92.34, rate: 0.9234 }

Time-series data

For charts and trend analysis, request a range:

const series = await client.timeseries({
  base: 'USD',
  symbols: ['EUR'],
  startDate: '2026-01-01',
  endDate: '2026-04-01',
});

Chart that straight into Recharts / Chart.js / your tool of choice.

Preset period lookups

Sometimes you want "last 7 days" without calculating dates yourself:

const lastWeek = await client.historicalByPeriod({
  base: 'USD',
  symbols: ['EUR'],
  period: '7d', // '1d' | '7d' | '30d' | '1y'
});

Node or browser — it doesn't care

The SDK uses native fetch, so it runs the same in:

Node.js 18+
Modern browsers
Cloudflare Workers, Vercel Edge, Deno, Bun

No polyfills, no adapter packages, no version-specific builds.

When to pick @allratestoday/sdk vs the smaller packages

The AllRatesToday ecosystem has a few Node packages, each with a different scope:

Package	Scope
`@allratestoday/sdk`	Full API surface — latest, historical, time-series, conversion
`fx-rates`	Minimal `rate()` / `convert()` + a CLI
`moneyify`	cashify-compatible conversion with optional auto-fetch
`live-currency-rates`	Multi-provider wrapper (Frankfurter, fawaz, AllRatesToday)

If you need the full API (especially historical and time-series), use @allratestoday/sdk. If you just want to convert two currencies, start with fx-rates.

Next steps

npm: @allratestoday/sdk
Free API key: allratestoday.com/register
Full API reference: allratestoday.com

Happy converting.

Written by the team behind AllRatesToday — an exchange rate API with real-time mid-market rates for 150+ currencies and the official published rates of 116 central banks and tax authorities, with keyless open endpoints for the central-bank data. Browse the API docs or grab a free key to start building.

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus an MCP server (@allratestoday/mcp-server) for AI agents.

Follow along: GitHub

Free currency API in 2026: what the free tiers actually give you

viraj geeth — Sun, 27 Sep 2026 13:38:06 +0000

Most "free currency API" searches end the same way. You pick the first provider with a free plan, ship the integration, and a month later the app breaks because you hit a 100-request cap, or the rates turn out to be yesterday's ECB fixing, or the "free" plan needed a card and it just charged you.

I maintain one of these APIs (AllRatesToday), so treat the ranking with that in mind. But the comparison table below is the thing I wish I had found first, and the numbers in it are the ones on each provider's pricing page at the time of writing.

The four questions that matter

Before the table, the questions a free tier has to answer:

How many requests, and per what? Per month, per day, or lifetime. Lifetime caps are fine for a prototype and a trap for anything scheduled.
How fresh is the data? Many free tiers serve one daily fixing, usually the ECB's 16:00 CET table of about 30 currencies. That is fine for an invoice and useless for a price display.
Is there a credit-card wall? Some providers put a card on the free plan so the upgrade is one click. Read the fine print about what happens at the cap.
Where do the rates come from? Mid-market rates, a central bank's reference table, or a retail rate with a spread baked in. These differ by up to a few percent and you need to know which one you are showing.

Comparison table

API	Free tier	Currencies	Update frequency on free	Card required
AllRatesToday	Free key, no card. Keyless open endpoint for official central-bank tables	160+	Real-time (60 s) with key	No
CurrencyFreaks	1,000 req/month	1,000+ incl. crypto	Daily	No
ExchangeRate-API	1,500 req/month	161	Daily	For upgrades
Open Exchange Rates	1,000 req/month	200+	Hourly	Yes
CurrencyLayer	100 req/month	168	Daily	Yes
Fixer	100 req/month	170+	Daily	Yes
CurrencyAPI	300 req/month	170+	Daily	Yes
XE	Trial only	170+	Up to 60 s	Yes
Alpha Vantage	25 req/day	Multi-asset	Daily	No
ExchangeRate.host	Free plan	168+	Daily	No
Frankfurter	Unlimited, keyless	~30 (ECB)	Daily (ECB)	No
fawazahmed0/currency-api	Unlimited, static JSON on a CDN	340	Daily	No

Two of those rows are not companies at all. Frankfurter is an open-source wrapper around the ECB table, and fawazahmed0's currency-api is a GitHub repo that republishes daily JSON files through jsDelivr. If daily ECB-style data is enough for you, start with one of those and skip the signup entirely. I benchmarked both every hour for a week alongside the commercial open endpoints; the static CDN file was the fastest thing in the test.

When a daily fixing is enough, and when it is not

Daily is enough for accounting, invoicing, customs and tax work. In fact for those you usually want a specific daily table, the one your tax authority or central bank publishes, not a market rate. That is a different product category, and it is why I keep the official tables on a separate keyless endpoint:

# ECB reference rate, no key, attribution required
curl "https://allratestoday.com/api/open/central-bank/ecb?source=EUR&target=USD"

{
  "bank": "ecb",
  "rate_date": "2026-09-25",
  "source": "EUR",
  "target": "USD",
  "rate": 1.1403,
  "rate_type": "reference",
  "cadence": "daily",
  "attribution": {
    "source": "Official rates published by ECB, served by AllRatesToday",
    "terms": "Free to use with visible attribution linking to allratestoday.com"
  }
}

The same endpoint pattern works for the other central banks in the set: swap ecb for cbuae, boe, rbi, sbv and so on. GET /api/open/central-banks lists them.

Daily is not enough for a checkout, a pricing page in the visitor's currency, a trading dashboard or anything where the user compares your number with Google's. For that you want mid-market rates refreshed at least every minute, and every provider in the table charges for that except the ones that grant it on the free key.

Real-time on the free tier

With AllRatesToday the free key gets the same 60-second mid-market feed as the paid plans. Be aware that the free allowance is a fixed block of requests, not a monthly reset: it is there to build and test against real data, and a production price display that polls on a schedule belongs on a paid plan. Either way, one fetch per minute per base currency, cached server-side, is all a price display needs.

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

// Node 18+ / browser
const r = await fetch(
  'https://allratestoday.com/api/v1/rates?source=USD&target=EUR',
  { headers: { Authorization: `Bearer ${process.env.ALLRATES_KEY}` } }
).then(res => res.json());
console.log(r.rate); // 0.8778

Historical dates, time series and CSV/XLSX output are on the same endpoints with date= and format= parameters. There are official SDKs for JavaScript, Python, PHP, Go and Rust if you prefer typed clients.

How to pick

Prototype or side project: a keyless source. Frankfurter, the currency-api CDN files, or the open central-bank endpoint above. No account, nothing to expire.
Price display, checkout, SaaS billing: a real-time mid-market feed with a free key and no card. Cache for 60 seconds.
Accounting, tax, customs: the official table from the institution your rule names, not a market rate. Use the central-bank endpoints.
Crypto plus fiat: CurrencyFreaks or CurrencyAPI cover the most symbols.
Stocks and forex together: Alpha Vantage, with a very low free cap.

One thing every free tier has in common

None of them are meant to be called on every page view. Whatever you pick, put the rate behind a cache with a short TTL and fall back to the last good value when a fetch fails. That single habit turns a 100-request free plan into something you can actually ship on, and it is the difference between a demo and a product.

The full ranking with per-provider notes and an FAQ lives here: The best free currency exchange API in 2026.

I benchmarked 6 free exchange rate APIs every hour for a week. Here are the numbers.

viraj geeth — Fri, 25 Sep 2026 12:34:21 +0000

Every "best exchange rate API" list I have read ranks providers by their pricing page. Nobody measures them. So I set up a GitHub Action that hits six free, keyless exchange rate endpoints every hour, records latency, HTTP status and the publication date in the body, and publishes the results as JSON and CSV.

Disclosure up front: I build AllRatesToday, which is one of the six. The harness is public, the raw data is public, and the numbers below are copied from it without editing. If you think the method is unfair to anyone, the workflow file is the place to argue.

Method

Vantage: GitHub Actions hosted runner, ubuntu-latest, US East.
Cadence: hourly, since 2026-09-19. The table below covers the first 7 days (31 runs at the time of writing).
Per run: 3 sequential GETs per provider with a cache-busting query string and a 15 s timeout. The median of the three is recorded.
Uptime: share of runs that returned HTTP 2xx with a parseable body.
Freshness: the publication date inside the response compared with the run date (UTC).

Source: benchmark.mjs and benchmark.yml. Output: latest.json and history.csv.

Results, first 7 days

Endpoint	Type	Median	p90	Uptime	Currencies	Data age
fawazahmed0/currency-api (jsDelivr)	market, static file	11 ms	23 ms	100%	340	1 day
AllRatesToday open central-bank endpoint	official (ECB table)	31 ms	68 ms	100%	29	1 day
ExchangeRate-API open endpoint	market	112 ms	131 ms	100%	166	0 days
FloatRates	market	316 ms	379 ms	100%	146	1 day
Frankfurter	official (ECB)	373 ms	580 ms	96.8%	29	1 day
ECB eurofxref-daily.xml	official, primary source	401 ms	558 ms	100%	29	1 day

"Data age" is the gap between the publication date in the response and the run date. A 1-day age on an ECB-derived feed is normal: the ECB publishes around 16:00 CET and the date rolls the next day.

What the numbers actually say

Static beats dynamic. The fastest endpoint is not an API at all. fawazahmed0's project publishes JSON files to a CDN once a day. If daily market rates are enough and you can live without an SLA, a CDN file will always win on latency.

Edge-cached official tables are the next tier. The AllRatesToday open endpoint serves the ECB table from Cloudflare's edge, which is why it lands at 31 ms from a US runner. It carries the ECB's own publication date, so it is usable for invoices and month-end where the auditor asks which rate you used.

The classic "free API" options are 100 to 400 ms. ExchangeRate-API's open endpoint was the most consistent of the dynamic services: 100% uptime and a tight p90. FloatRates and Frankfurter are fine but slower, and Frankfurter dropped one run in the week. One failed run in 31 is not a verdict on Frankfurter, and the 30-day column on the live page will be fairer.

Going straight to the ECB is the slowest option. The primary source XML is 400 ms and still one day old. There is no freshness advantage to fetching it yourself. Cache it or use a mirror.

Which one should you use

Side project, daily rates, no budget: fawazahmed0's CDN files or ExchangeRate-API's open endpoint.
Anything an accountant will read: an official-rate endpoint that returns the publisher and date. AllRatesToday's open endpoint does that for the ECB with no key, and the keyed API covers 116 central banks plus HMRC, US Treasury and Swiss customs tables.
Real-time market rates in a checkout: none of the free endpoints above. Every one is daily. You need a paid tier from any provider that quotes sub-minute updates.

Try the two fastest yourself

# static CDN file, daily
curl -s https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/eur.min.json | head -c 200

# official ECB table with publication date, no key
curl -s "https://allratestoday.com/api/open/central-bank/ecb?source=USD&target=EUR"

The live page at allratestoday.com/benchmarks/exchange-rate-api updates hourly and adds a rolling 30-day column once there is enough history. If you want another free endpoint added to the harness, open an issue on the data repo and include a keyless URL.

A currency API with no API key: AllRatesToday is now in the public-apis directory

viraj geeth — Tue, 22 Sep 2026 18:06:45 +0000

AllRatesToday is now listed in the
public-apis directory under Currency
Exchange. Rather than write a post that just says that, here is the part of the API that earns a
place in a list of public APIs: a set of endpoints that need no key at all.

The keyless part

Central banks and tax authorities publish an official exchange rate table, usually once per business
day. That number is not a market rate — it is the figure a VAT return, a customs declaration or a set
of statutory accounts has to use, because the regulation names the institution that published it.

We collect those tables from 116 central banks and 3 tax authorities and serve the latest one for any
source with no key, no signup and CORS wide open:

curl "https://allratestoday.com/api/open/central-bank/ecb"

{
  "bank": "ecb",
  "rate_date": "2026-09-22",
  "age_days": 0,
  "stale": false,
  "cadence": "daily",
  "rates": [
    { "base": "EUR", "quote": "USD", "type": "reference", "value": 1.1463 },
    { "base": "EUR", "quote": "GBP", "type": "reference", "value": 0.8578 }
  ]
}

Ask for a single pair and you get the pair, plus whether it was published directly or derived:

curl "https://allratestoday.com/api/open/central-bank/cbuae?source=AED&target=USD"

Swap ecb for fed, boe, rbi, pboc, snb, hmrc, ustreasury, bazg or any of the other
codes. The catalogue is keyless too, and tells you how fresh each source is:

curl "https://allratestoday.com/api/open/central-banks"

Every response carries the publication date, the age in days and a stale flag, which matters more
than it sounds: a table that is one day old on a Saturday is correct behaviour, and a table that is
nine days old is a problem. You should be able to tell those apart without guessing.

The condition is attribution — a visible credit linking back — which is the same deal the data
repository carries under CC BY 4.0.

In JavaScript, with no setup

const r = await fetch('https://allratestoday.com/api/open/central-bank/ecb?source=EUR&target=USD');
const { rate, rate_date } = await r.json();
console.log(`ECB reference rate on ${rate_date}: 1 EUR = ${rate} USD`);

CORS is open, so this works from the browser. No proxy, no key in your bundle.

What does need a key

The free key takes a minute and no card, and unlocks the parts that are a database query rather than
one cached object:

Real-time mid-market rates for 160+ currencies, refreshed every 60 seconds
A rate on any past date, with the publishing institution's own weekend and holiday rule applied and stated in the response
Full history and time series, and CSV, XML or XLSX instead of JSON
Cross rates computed between two currencies neither of which is the bank's home currency

Same data, no API at all

If you would rather not call an API, the whole central-bank archive is a git repository, mirrored to
jsDelivr, Hugging Face and Kaggle and refreshed daily:

https://cdn.jsdelivr.net/gh/AllRates-Today/central-bank-exchange-rates@main/data/ecb/latest.json

There is also an MCP server, so an AI agent can look up a rate and cite the institution and date
instead of inventing one from training data.

One correction to the listing

The directory's generated description says our rates come from Reuters and Refinitiv. They do not,
and we do not license either. The real-time feed is aggregated institutional interbank market data;
the official tables come from each institution's own publication. We had a sentence on our blog that
placed the word "Reuters" next to our own sourcing, which is almost certainly what a crawler merged.
That sentence is now fixed, and I have asked the directory to update the entry. If you are picking a
data provider, "sourced from Reuters" is a claim worth making a vendor prove.

Docs: allratestoday.com/docs ·
OpenAPI ·
llms.txt for agents ·
free key

Auto-localize prices in React with react-currency-localizer-realtime

viraj geeth — Sat, 19 Sep 2026 19:50:47 +0000

If you sell to international customers, showing prices in the visitor's local currency isn't a nice-to-have — it's a conversion-rate lever. But wiring it up usually turns into a small project: IP geolocation, exchange-rate fetching, caching, fallbacks, race conditions when the rate call is slower than render.

react-currency-localizer-realtime compresses all of that into a React hook and a component. Drop it in, pass a price, done.

Under the hood it uses real-time mid-market rates from the AllRatesToday API — 160+ currencies, updated every 60 seconds, sourced from institutional interbank market data.

What you get

⚡ Real-time mid-market rates — no retail markup, no hidden spread
🌍 Auto-detect the user's currency via IP geolocation (no API key needed for geolocation)
💱 160+ currencies — major, minor, exotic, and precious metals
🧠 Smart caching — 24h localStorage for geolocation, 1h memory cache for rates
🔀 Three usage patterns — hook, component, or batch
🎯 Manual override — skip geolocation with an explicit currency
🔷 TypeScript-first — full type definitions
📦 Zero runtime deps besides React itself
🪶 ~4KB gzipped
🛡️ Graceful fallbacks — shows the original price if anything fails

Install

npm install react-currency-localizer-realtime

React 17+ is the only peer dependency.

Get a free API key at allratestoday.com/register.

1. The component — the simplest way

import { LocalizedPrice } from 'react-currency-localizer-realtime';

function ProductCard() {
  return (
    <div>
      <h3>Premium Plan</h3>
      <LocalizedPrice
        basePrice={99.99}
        baseCurrency="USD"
        apiKey="YOUR_API_KEY"
      />
    </div>
  );
}

A visitor from Germany sees 92.34 €. A visitor from India sees ₹8,321. A visitor from the US just sees $99.99. No per-country routing, no SSR detection, no currency-switcher UI to build.

2. The hook — full control

Use useCurrencyConverter when you need loading/error states or custom formatting:

import { useCurrencyConverter } from 'react-currency-localizer-realtime';

function ProductPrice({ price }: { price: number }) {
  const { convertedPrice, localCurrency, isLoading, error } = useCurrencyConverter({
    basePrice: price,
    baseCurrency: 'USD',
    apiKey: 'YOUR_API_KEY',
  });

  if (isLoading) return <span>Loading price...</span>;
  if (error) return <span>${price}</span>; // graceful fallback

  return <span>{convertedPrice} {localCurrency}</span>;
}

3. Manual override

Want to honor a user-picked currency? Pass it explicitly:

<LocalizedPrice
  basePrice={99.99}
  baseCurrency="USD"
  currency="JPY"           // override geolocation
  apiKey="YOUR_API_KEY"
/>

Useful when you have a currency switcher in the header.

Why not just use `Intl.NumberFormat`?

Intl.NumberFormat handles formatting, not conversion. If you pass it 99.99 and tell it to format as JPY, it'll print ¥100 — wrong. You still need an actual exchange rate.

react-currency-localizer-realtime handles both: detect the currency, fetch the rate, apply it, format the output.

Performance notes

Two things usually hurt currency localizers on page load:

Geolocation calls on every render. Fixed here with a 24h localStorage cache.
Rate fetches on every price. Fixed here with a 1h in-memory cache shared across component instances.

Net effect: first visit triggers two network calls; every subsequent price on the page (and every return visit within 24h) is instant.

If a request fails, the component falls back to showing the original price rather than blanking — your customers never see a broken UI.

Real-world use case

This is the package I reach for whenever a WooCommerce/Shopify/custom storefront needs per-visitor pricing without forking the catalog by region. It's the missing middle between "one-currency site" and "separate regional installs."

Combine it with LocalizedPrice on product cards and a currency switcher in the header, and you've covered 95% of international-storefront UX in an afternoon.

Next steps

npm: react-currency-localizer-realtime
Free API key: allratestoday.com/register
Docs: allratestoday.com

If you ship it on a live store, I'd love to see the before/after conversion numbers — drop them in the comments.

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus an MCP server (@allratestoday/mcp-server) for AI agents.

Follow along: GitHub

Where Does Exchange Rate Data Come From? Sources, Accuracy, and Compliance

viraj geeth — Sat, 19 Sep 2026 19:50:43 +0000

When a developer asks "where does the data come from?", they are usually not asking out of curiosity. They are asking because an auditor, compliance officer, or product manager wants to know if the rates in their application are legally defensible. The data source determines everything: accuracy, update frequency, auditability, and whether you can use it in regulated financial applications.

The Four Tiers of Exchange Rate Data

Tier 1: Central Banks (Most Authoritative)

The ECB, Federal Reserve, Bank of England, and other central banks publish official reference rates. These are the gold standard for regulatory and tax reporting.

ECB: ~30 currencies, updated daily at 16:00 CET
Federal Reserve: ~25 currencies, updated daily at 12:00 ET
Limitations: Very few currencies, once-daily updates, published with delays
Best for: Accounting, tax filings, regulatory compliance

Tier 2: Licensed Financial Data Providers (Production-Grade)

Refinitiv, Bloomberg, and ICE provide real-time interbank rates sourced directly from Tier 1 banks and market makers. These feeds cost thousands per month when accessed directly.

Coverage: 150–200+ currencies
Update frequency: Seconds to minutes
Data type: Mid-market (interbank) rates
Best for: Trading, payments, e-commerce, any production app

Tier 3: Aggregated / Derived Data (Varies Widely)

Some APIs aggregate rates from multiple unnamed sources, apply their own averaging, or derive rates from commercial services. Quality varies dramatically.

Transparency: Often unclear which sources are used
Risk: May include retail spreads or outdated data
Best for: Non-critical displays, hobby projects

Tier 4: Scraped / Unverified Data (Not Recommended)

Some free APIs scrape exchange rates from public websites or other APIs. No provenance, no audit trail, may violate terms of service.

Reliability: Can break without notice
Legal risk: May violate ToS of scraped sources
Best for: Personal projects only

What Major APIs Actually Use

API	Primary Source	Tier	Disclosed?
AllRatesToday	institutional interbank market data / Interbank feeds	Tier 2	Yes
Frankfurter	European Central Bank (ECB)	Tier 1	Yes
Open Exchange Rates	"Multiple commercial sources"	Tier 2–3	Partially
ExchangeRate-API	"Central Banks and financial institutions"	Tier 1–3	Partially
Fixer.io	"ECB and commercial feeds"	Tier 1–3	Partially
CurrencyAPI	Not specified	Unknown	No

Key insight: Many APIs use vague language like "multiple commercial sources" without naming them. If you need data that will withstand an audit, look for APIs that explicitly name their sources.

Why Data Source Matters for Compliance

Financial Reporting (IFRS / GAAP)

IFRS and GAAP require that exchange rates used in financial statements be traceable to a recognized source. Central Bank rates (Tier 1) are always accepted. Rates from a named provider like Reuters (Tier 2) are typically accepted. Rates from unnamed sources may be challenged by auditors.

Payment Services (PSD2)

In the EU, PSD2 requires transparency in currency conversion. If you process cross-border payments, you must disclose the exchange rate and its source. Using an API that doesn't disclose its source makes this impossible.

Tax Reporting

Tax authorities accept Central Bank rates or recognized market rates. Using rates from an undisclosed source could result in rejected filings.

How AllRatesToday Sources Its Data

AllRatesToday publishes two kinds of rates. Real-time mid-market rates are aggregated from institutional interbank market data; official rates are collected from the publication of each of 116 central banks and tax authorities (Tier 1). For the real-time feed:

Source: Tier 2 — aggregated institutional interbank market data
Rate type: Mid-market (interbank) — no spread or markup
Coverage: 160+ currencies
Update frequency: Every 60 seconds
Comparable to: the mid-market rate shown by Google Finance and XE

The API response includes timestamps for every rate, giving you a verifiable audit trail:

{
  "source": "USD",
  "target": "EUR",
  "rate": 0.9234,
  "time": "2026-04-09T14:30:00Z"
}

For audit trails: Store the rate, timestamp, and source currency pair for every conversion your application performs.

Choosing the Right Source for Your Use Case

Use Case	Recommended Source	Why
Financial statements	Central Bank (Tier 1)	Required by IFRS/GAAP
Tax reporting	Central Bank (Tier 1)	Accepted by all tax authorities
Payment processing	Reuters/Refinitiv (Tier 2)	Real-time accuracy, named source for PSD2
E-commerce pricing	Reuters/Refinitiv (Tier 2)	Live rates prevent margin erosion
Dashboard / display	Tier 1 or Tier 2	Either works

Questions to Ask Your API Provider

What is the primary data source? Accept named sources (ECB, Reuters, Bloomberg). Be wary of "multiple sources" without specifics.
Are the rates mid-market or retail? Mid-market = no spread. Retail = hidden markup.
How often is the data refreshed from the source? Not how fast the API responds — how fresh the underlying data is.
Can I get a data provenance statement? For regulated industries, you may need written confirmation.
What happens if the source goes down? Stale data, errors, or failover?

AllRatesToday sources mid-market rates from institutional interbank market data. Named source, timestamped responses, audit-ready data. Free tier available.

Get your free API key | Documentation | GitHub

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus an MCP server (@allratestoday/mcp-server) for AI agents.

Follow along: GitHub

Mid-Market vs Retail Exchange Rates: What Developers Need to Know

viraj geeth — Sat, 19 Sep 2026 19:50:40 +0000

When you integrate an exchange rate API into your application, one of the most important questions to ask is: "Is this the mid-market rate or a retail rate?" The difference can mean a 1–5% hidden markup on every conversion your users see — and most API documentation doesn't make this clear.

What Is the Mid-Market Rate?

The mid-market rate (also called the interbank rate) is the midpoint between the buy price and the sell price of a currency pair on the global foreign exchange market. It is the "true" exchange rate — the rate at which banks trade with each other in large volumes.

When you see an exchange rate on Google, XE, or Bloomberg, you are seeing the mid-market rate.

Example: If banks are buying EUR at 1.0820 USD and selling EUR at 1.0830 USD, the mid-market rate is 1.0825 — the midpoint between the two.

What Is a Retail Rate?

A retail rate is the mid-market rate plus a spread (markup). This spread is how banks, exchange services, and money transfer companies make money.

Provider Type	Typical Spread	Impact on $10,000
Mid-market (interbank)	0%	$0
Online transfer (e.g. Wise)	0.3–0.7%	$30–$70
Bank wire transfer	1–3%	$100–$300
Credit card foreign transaction	1–3%	$100–$300
Airport currency exchange	3–8%	$300–$800

Why This Matters for Your Application

If your API returns retail rates instead of mid-market rates, you have a transparency problem. Your users might think they are getting the "real" exchange rate, but there is already a hidden markup baked into the data.

E-Commerce Price Display

If your online store shows "1 USD = 0.92 EUR" but the real mid-market rate is 0.9350, your international customers are seeing prices that are 1.6% higher than they should be. On a $500 purchase, that is $8 in invisible overcharge.

Multi-Currency SaaS Billing

If you bill customers in their local currency using retail rates, you are effectively applying a markup your customers didn't agree to.

Financial Reporting

Auditors and compliance teams expect rates traceable to a recognized source. Mid-market rates from Reuters, Bloomberg, or Central Banks are accepted. Retail rates from unnamed sources are not.

How to Tell What Your API Returns

Compare against Google: Search "1 USD to EUR" on Google (mid-market rate). If your API's rate differs by more than 0.05%, it may include a spread.
Check the documentation: Look for "interbank," "mid-market," or "wholesale." If the docs say "indicative rates" or don't specify, be cautious.
Ask about the source: Reuters, Refinitiv, or Bloomberg = mid-market. Unnamed "multiple sources" = potentially includes retail spreads.

Red flag: If an exchange rate API is completely free with unlimited requests and doesn't disclose its data source, the data may be low-quality or include a hidden spread.

Adding Your Own Transparent Markup

If your business model requires a spread, start with the mid-market rate and apply your own transparent margin:

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');
const MARKUP = 0.005; // 0.5% spread

async function getCustomerRate(from, to) {
  const midMarketRate = await client.getRate(from, to);
  const customerRate = midMarketRate * (1 - MARKUP);
  return {
    midMarket: midMarketRate,
    customerRate: customerRate,
    spread: MARKUP
  };
}

const rate = await getCustomerRate('USD', 'EUR');
console.log(`Mid-market: ${rate.midMarket}`);
console.log(`Customer rate: ${rate.customerRate} (includes ${rate.spread * 100}% fee)`);

This approach gives you full control over your pricing while being transparent with your users about the markup.

Quick Reference

Aspect	Mid-Market Rate	Retail Rate
Definition	Midpoint between buy/sell	Mid-market + provider's spread
Markup	None	0.3% to 8%
Used by	Google, XE, Bloomberg	Banks, exchange bureaus
Best for apps	Price display, invoicing, comparison	Simulating actual transfer cost
Audit-friendly	Yes (traceable source)	Depends on provider

AllRatesToday provides mid-market rates from institutional interbank market data for 160+ currencies. No hidden spreads, no markup. Free tier available.

Get your free API key | Documentation | GitHub

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus an MCP server (@allratestoday/mcp-server) for AI agents.

Follow along: GitHub

Is Oanda API Free? (And What to Use Instead in 2026)

viraj geeth — Mon, 14 Sep 2026 11:15:16 +0000

Short answer: no. Oanda does not offer a free, general-purpose currency API for developers. The widely-cited v20 REST API requires a registered Oanda fxTrade brokerage account, and the separate Exchange Rates Data API is paid-only with no permanent free tier.

If you landed here because you searched "free Oanda API," you almost certainly don't want what Oanda actually sells. This guide explains what each Oanda API really is, who it's for, why most developers end up looking elsewhere, and which alternatives give you real-time FX data without the brokerage account or enterprise contract.

The Two Oanda APIs (They're Not the Same Product)

The first thing to understand is that "the Oanda API" is two completely different products with different audiences and access models.

1. The Oanda v20 REST API (for traders)

The v20 API is the programmatic interface to Oanda's fxTrade brokerage platform. It exposes:

Live bid/ask prices on the instruments your account is permitted to trade
Order placement, modification, and cancellation
Position and trade management
Account history and transaction logs
Streaming price and event endpoints over HTTP

To call it, you need an fxTrade account ID and a personal access token, both issued by Oanda after you register. There are two flavors of token:

Practice (demo) tokens — work against api-fxpractice.oanda.com with simulated funds.
Live tokens — work against api-fxtrade.oanda.com with real funds in your funded account.

The v20 API itself doesn't have a per-call price tag, but you cannot use it without an Oanda account, and the live environment requires the same KYC, residency checks, and (in many regions) minimum deposits as opening any brokerage account. It is not a developer-tier currency data API in the way that ExchangeRate-API or AllRatesToday are.

2. The Oanda Exchange Rates API (for businesses)

The Exchange Rates Data API is Oanda's standalone commercial data product, sold separately from fxTrade. It targets enterprises that need:

Audit-grade historical FX rates (back to 1990 for some pairs)
Daily, hourly, or minute-level snapshots
Specific quote types (bid, ask, mid, highlow)
Multi-currency reporting for ERP systems and tax compliance

This product has no free tier and no public pricing. Access is through an annual sales contract negotiated based on coverage, frequency, and call volume. Public reports and customer disclosures place entry pricing in the hundreds of dollars per month and up — comparable to XE Currency Data API or Refinitiv's lower-tier feeds.

Why Most Developers Can't (or Shouldn't) Use Oanda

If you just want to convert USD to EUR in your app, or display live rates on a SaaS dashboard, Oanda is almost always the wrong tool. Here's why developers keep walking away:

You need a brokerage account for the v20 API

To get a v20 access token, you have to register an Oanda fxTrade account, complete KYC, and in some regions deposit funds. Even the demo path requires identity verification. You can't get a token in five minutes the way you can with most public REST APIs.

The v20 API isn't designed for general-purpose conversion

The v20 endpoints are built around the concept of your account: prices for instruments you're allowed to trade, in the account currency you opened with. There is no clean "give me USD/EUR mid-market right now" call without first assembling instrument lists and parsing tradeable prices. It works, but it's overkill for a converter widget.

Geofencing and regional restrictions

Oanda is regulated in multiple jurisdictions and not every account type is available everywhere. Developers in some countries can't open a live fxTrade account at all, which means no live token, which means no production v20 access. Demo access is broader but still subject to regional availability.

2026 free-tier restrictions

Over the past 12–18 months, Oanda has tightened access on multiple surfaces — including stricter KYC for new fxTrade accounts, region-specific fee schedules, and a rebrand of the data API away from the older "fxTrade Data" naming. The pattern is the same one we've seen at XE, CurrencyLayer, and others: legacy free or low-tier endpoints are quietly retired in favor of paid plans.

The Exchange Rates API is sold to procurement, not developers

If you have to email sales, sign an NDA, and wait two weeks for a quote, you're not in the developer-API market — you're in the enterprise data market. That's fine if you're a bank. It's the wrong shape for a startup, side project, or open-source library.

What "Free Oanda API" Searches Actually Want

When developers Google "is Oanda API free," what they almost always mean is one of three things:

"Can I get live FX rates without paying?" — Yes, with a permanent free tier from a developer-first API. Oanda is the wrong starting point.
"Can I build a currency converter / SaaS pricing localizer / accounting app for free?" — Yes, with sub-second to 60-second mid-market rates, full historical data, and no credit card required.
"Can I do paper trading / strategy backtests for free?" — Use the Oanda v20 API in demo mode. That's its actual free use case, but you'll still need to register a practice account.

If you're in the first two camps, you don't need Oanda. You need a developer-first FX data API.

Oanda Alternatives for Developers

Provider	Permanent Free Tier	Real-Time Updates	Trading?	Account Required
AllRatesToday	Yes	60-second mid-market	No	Email signup, no card
Oanda v20	Demo only	Tick-level on tradeable pairs	Yes	fxTrade account + KYC
Oanda Exchange Rates	No	Configurable, paid	No	Annual sales contract
ExchangeRate-API	Yes (limited)	Daily on free, hourly on paid	No	API key
CurrencyLayer	100 req/mo, USD only	Hourly free, 60s on paid	No	API key
Fixer.io	100 req/mo, EUR only	Hourly free, 60s on paid	No	API key

For pure currency data — conversions, historical rates, SaaS pricing localization, accounting integrations, dashboards — AllRatesToday is the practical replacement. Same institutional-grade data feed Oanda's data product is built on, exposed as a clean REST API with a permanent free tier, official SDKs for JavaScript / Python / PHP, and an MCP server for AI agents.

When Oanda Is the Right Choice

You're building an automated trading bot or systematic strategy and need order execution, not just prices.
You need tick-level streaming on a specific set of forex / CFD instruments tied to a real funded account.
You're an enterprise with a procurement budget and need audit-grade historical data that names Oanda as the source.
You already have an Oanda relationship for retail FX and want a single vendor.

When to Skip Oanda

You only need currency conversions in an app, dashboard, invoice, or report.
You want fast onboarding — minutes, not weeks.
You don't want to open a brokerage account to call an API.
You need a free tier for prototyping, hobby projects, or open-source.
You want predictable monthly pricing, not annual enterprise contracts.
You need CORS for browser-side calls (the v20 API is server-side only).

Drop-in Replacement Example

Here's the same "USD to EUR conversion" call against AllRatesToday — no brokerage account, no contract, no KYC:

curl "https://api.allratestoday.com/v1/convert?from=USD&to=EUR&amount=100" \
  -H "x-api-key: YOUR_API_KEY"

Returns:

{
  "from": "USD",
  "to": "EUR",
  "amount": 100,
  "rate": 0.9234,
  "result": 92.34,
  "timestamp": "2026-04-30T18:22:11Z"
}

Replacing the v20 instrument-pricing flow takes about ten minutes. Replacing the Exchange Rates Data API for historical lookups takes the same. The free tier covers most prototypes outright; paid plans start far below Oanda's enterprise floor.

FAQ

Is the Oanda API free?

No. The v20 REST API requires a registered fxTrade brokerage account (live or demo), and the Exchange Rates Data API is a paid product with no permanent free tier. There is no general-purpose free developer plan.

Can I use the Oanda API without a trading account?

Not the v20 API. It's tied to your fxTrade account credentials and is intended for executing trades or pulling data tied to that account. The Exchange Rates Data API is separate and does not require a trading account, but it is paid-only.

Is the Oanda demo account API free?

Yes — demo (practice) accounts can access the v20 API at no cost, but they're meant for testing trading strategies. They have rate limits, are subject to availability, and the rates may differ slightly from production. Demo access is not a substitute for a production data feed.

What does the Oanda Exchange Rates API cost?

Oanda does not publish list pricing publicly. The product is sold per-quote with annual contracts, and pricing is negotiated based on volume, currency coverage, and update frequency. Public reports place entry pricing in the hundreds of dollars per month and up.

Is there a free alternative to the Oanda API?

Yes. AllRatesToday offers a permanent free tier with real-time mid-market rates, 160+ currencies, historical data, and no credit card required. It's the closest free equivalent for developers who don't need Oanda's trade execution capabilities.

Can I use Oanda data in a commercial product?

Yes, on paid plans of either the v20 or Exchange Rates products, subject to Oanda's licensing terms. The demo / practice environment is generally not licensed for commercial redistribution — read the terms before shipping.

If you searched for a free Oanda API, you don't actually need Oanda — you need real-time mid-market FX rates with a developer-friendly free tier. AllRatesToday ships exactly that, with official SDKs and an MCP server for AI agents. No brokerage account required.

Written by the team behind AllRatesToday — an exchange rate API
with real-time mid-market rates for 160+ currencies and the official published tables of
116 central banks and tax authorities. The official-rate endpoint needs no key. Browse the
API docs or grab a free key
to start building.

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus MCP servers and a hosted MCP endpoint at https://allratestoday.com/api/mcp for AI agents.

How Often Are Exchange Rates Updated? Real-Time vs Daily Explained

viraj geeth — Mon, 14 Sep 2026 11:15:15 +0000

"How often are the rates updated?" is the single most asked question about exchange rate APIs. It shows up in every API's FAQ, every developer forum thread, and every Stack Overflow comparison. And for good reason — the answer determines whether an API is suitable for your project or a liability waiting to happen.

The Three Layers of "Update Frequency"

When an API says "rates updated every X," that statement hides three separate concerns.

1. Real-Time vs Delayed Data

The forex market trades 24 hours a day, 5 days a week. Currency prices change every second. An API's update frequency tells you how closely it tracks those changes:

Real-time (seconds to minutes): Pulls from live interbank market feeds. Essential for trading, payments, and any app where a 1% swing matters.
Hourly: A middle ground. Acceptable for dashboards and reporting, but misses intraday volatility.
Daily: A single snapshot, usually from the ECB at 16:00 CET. Fine for accounting and invoicing.

Example: On March 11, 2026, GBP/USD moved from 1.2910 to 1.2745 within 6 hours after an unexpected Bank of England announcement. An app using daily rates would have shown a price that was off by 1.3% for the entire day — a $13 discrepancy on every $1,000 transaction.

2. The "Free Tier" Trap

Most exchange rate APIs advertise real-time capabilities but lock them behind paid plans. Here is what free tiers actually deliver:

API	Free Tier Update	Paid Tier Update
AllRatesToday	Every 60 seconds	Every 60 seconds
Open Exchange Rates	Hourly	Every 5 minutes
Fixer.io	Daily	Every 60 seconds
ExchangeRate-API	Daily	Daily
CurrencyAPI	Daily	Hourly
Frankfurter	Daily (ECB)	N/A (free only)

Notice the pattern: most free tiers give you daily rates only. You build your app, test it, ship it — and then discover during market volatility that your "exchange rate feature" is showing yesterday's price.

AllRatesToday is different: The free tier gets the same 60-second update frequency as paid plans. The only limit is request volume, not data freshness.

3. Accuracy vs Latency: What Does "Real-Time" Actually Mean?

This is the subtlety most developers miss. "Real-time" can mean two very different things:

Real-time source: The underlying data comes from live institutional interbank feeds. The rate itself is current.
Real-time delivery: The API responds quickly, but the data might be a cached snapshot from hours ago. Fast delivery, stale data.

Always ask: "Is the data real-time, or just the API response?"

AllRatesToday sources data from institutional interbank market data and interbank market feeds — the same sources used by Google Finance, XE, and Bloomberg.

Which Update Frequency Do You Actually Need?

Use Case	Minimum Update	Why
Trading / Forex	Real-time (seconds)	Price slippage directly costs money
Payment processing	Real-time (minutes)	Conversion at checkout must reflect current market
E-commerce price display	Hourly to real-time	Stale rates erode margins or overcharge customers
SaaS multi-currency billing	Daily to hourly	Invoices are usually generated at intervals
Accounting / Tax reporting	Daily	Regulatory bodies accept end-of-day rates

How to Verify an API's Update Frequency

Don't take marketing claims at face value. Here is a simple test:

# Fetch the rate, wait 2 minutes, fetch again
# Compare the timestamps and values

curl -s "https://allratestoday.com/api/v1/rates?source=USD&target=EUR" \
  -H "Authorization: Bearer YOUR_API_KEY" | jq '.time, .rate'

sleep 120

curl -s "https://allratestoday.com/api/v1/rates?source=USD&target=EUR" \
  -H "Authorization: Bearer YOUR_API_KEY" | jq '.time, .rate'

If the timestamps are different and the rate has changed (even slightly), the API is genuinely updating. If both calls return the exact same timestamp, you are getting cached daily data.

The Bottom Line

Daily rates are fine for accounting and reporting.
Hourly rates work for dashboards and non-transactional displays.
Real-time rates are essential for payments, e-commerce, and anything where money changes hands.
Most free APIs give you daily data. Check the fine print before building on top of it.

AllRatesToday updates every 60 seconds from institutional interbank market data — even on the free plan. 160+ currencies.

Get your free API key | Documentation | GitHub

Open source: official SDKs for JavaScript, Python, PHP, Go and Rust,
plus MCP servers and a hosted MCP endpoint at https://allratestoday.com/api/mcp for AI agents.

15.6 million official exchange rates from 121 central banks and 3 tax authorities, now on Hugging Face

viraj geeth — Mon, 14 Sep 2026 11:14:41 +0000

If you have ever needed "the ECB rate on the invoice date" for a tax return, a customs form, a transfer-pricing file or an audit, you know the problem. The number exists. It is public. And it is scattered across a hundred central-bank websites, each with its own PDF, XML feed, Excel download or HTML table, each with its own idea of which way round a rate should be quoted.

We spent most of this year collecting those tables into one pipeline. As of this week the full history is a public dataset on Hugging Face:

https://huggingface.co/datasets/AllRates/central-bank-exchange-rates


Rows	15,653,091
Institutions	121 central banks + 3 tax authorities
Earliest date	1914 (Swiss National Bank)
Currencies	215 base, 202 quote
Refresh	daily, from the GitHub source repo
License	CC BY-NC 4.0 (non-commercial, attribution)
Size	515 MB CSV, auto-converted to Parquet

Why "official" rates and not market rates

Most exchange-rate datasets are market data: a mid-market snapshot from some aggregator at some time of day. That is the right thing for a price display. It is the wrong thing for anything a regulator will look at.

Tax offices, customs agencies and accounting standards usually name a publisher. HMRC publishes monthly rates for UK VAT and customs. The ECB reference rate is the default for euro-area statutory reporting. The Reserve Bank of India reference rate is the benchmark for statutory rupee conversions. The Reserve Bank of Australia, Bank of Canada, Banco Central do Brasil and dozens of others publish a daily fixing that is the rate for that jurisdiction, regardless of what the interbank market did five minutes later.

Those numbers are not derivable from market data. They have to be collected from the source, on the source's schedule, in the source's convention. That is what this dataset is.

What is in it

One CSV per institution under rates/, five columns, identical everywhere:

Column	Type	Meaning
`date`	string	ISO 8601 publication date. Weekends and the publisher's holidays are simply absent.
`base`	string	The currency being priced (ISO 4217).
`quote`	string	The currency it is priced in.
`type`	string	The publisher's own label: `reference`, `middle`, `buy`, `sell`, `spot`, `indicative`, `monthly`, `monthly_average`, `quarterly`, `close`, and a few more.
`value`	float	How many `quote` one `base` buys.

A few rows from rates/ecb.csv:

date,base,quote,type,value
2025-01-02,EUR,AUD,reference,1.6618
2025-01-02,EUR,BGN,reference,1.9558
2025-01-02,EUR,BRL,reference,6.42

Alongside the history there is latest/<code>.json with each institution's most recent table, and sources.json with the institution's name, country, home currency, kind (central bank or tax authority) and the URL of the page we collect from.

Coverage by depth, to give you a sense of what "back to 1914" actually means:

Institution	Code	First year in dataset
Swiss National Bank	`snb`	1914
Bank of Korea	`bok`	1964
Bank of Israel	`boi`	1975
Hong Kong Monetary Authority	`hkma`	1981
Bank of Japan	`boj`	1998
European Central Bank	`ecb`	1999
Reserve Bank of India	`rbi`	2003
People's Bank of China	`pboc`	2006

Most institutions only publish a few years of history on their own sites. Where a bank offered more, we took all of it.

Loading it

With the datasets library, the whole thing as one table:

from datasets import load_dataset

ds = load_dataset("AllRates/central-bank-exchange-rates", "rates")

With pandas, one institution at a time. This is usually what you want, because 15.6 million rows is a lot of memory for a question about one bank:

import pandas as pd

ecb = pd.read_csv(
    "hf://datasets/AllRates/central-bank-exchange-rates/rates/ecb.csv",
    parse_dates=["date"],
)
usd = ecb[(ecb.base == "EUR") & (ecb.quote == "USD")].set_index("date")["value"]
print(usd.resample("YE").mean().tail())

With Polars, lazily, if you want to scan several banks without loading all of them:

import polars as pl

df = (
    pl.scan_csv("hf://datasets/AllRates/central-bank-exchange-rates/rates/*.csv")
      .filter((pl.col("base") == "USD") & (pl.col("quote") == "INR"))
      .collect()
)

With DuckDB, straight off the Hub, no download step:

INSTALL httpfs; LOAD httpfs;

SELECT date, value
FROM 'hf://datasets/AllRates/central-bank-exchange-rates/rates/rbi.csv'
WHERE base = 'USD' AND quote = 'INR' AND type = 'reference'
ORDER BY date DESC
LIMIT 5;

Three things you can do with it that you could not do before

Compare what different central banks say the same pair is worth. The ECB publishes EUR→USD. The Fed publishes USD→EUR. The Bank of Canada publishes both against CAD. On any given day these disagree by a few basis points because they fix at different times. That spread is itself interesting, and until now you had to scrape three sites to see it.

Reconstruct a filing exactly. Pick the publisher your jurisdiction names, filter to type == "reference" (or whatever that publisher calls its headline rate), take the row for the invoice date. If the date is missing, the publisher did not publish that day, and your local rule will say whether to use the previous or next business day.

Train on a century of official fixings. The SNB series runs from 1914. The Bank of Korea from 1964. If you are building anything that needs long, clean, non-market FX series, this is a larger and more consistent corpus than we could find anywhere else in the open.

Conventions and caveats

We made a few decisions that you should know about before relying on the data.

Direction follows the publisher. If the ECB says 1 EUR = 1.0850 USD, that is the row: EUR,USD,reference,1.0850. We do not flip rates, and we do not compute crosses. If a bank does not publish GBP against JPY, there is no GBP/JPY row for that bank.
type is the publisher's label, normalised only in spelling. A buy rate from one bank and a buy rate from another are not guaranteed to mean the same thing. Read the source page linked in sources.json if it matters.
Gaps are real. A missing date means the institution did not publish, or published something our collector could not parse and our validation rejected. We would rather have a hole than a wrong number.
Every row went through a cross-source plausibility check before it was committed. Values that disagree with the rest of the world by more than a threshold are quarantined and reviewed by hand. That caught a handful of unit errors during the backfill, which is why we trust the rest.
Verify before you file. The figures are public information republished under CC BY-NC 4.0. For anything legal or tax-related, the original publisher's page is the authority, and it is linked from sources.json for every institution.

How it stays current

The dataset is a mirror of a GitHub repository, AllRates-Today/central-bank-exchange-rates, which is itself fed by the collection pipeline behind AllRatesToday. A scheduled Action runs four times a day, pulls each institution's latest table from a keyless open endpoint, commits only when something changed, and then pushes the consolidated per-institution CSVs to Hugging Face. So the Hub copy is never more than a few hours behind the source sites.

If you want the same data as small JSON files on a CDN instead of a 500 MB dataset, the GitHub repo serves data/latest.json and per-bank latest.json over jsDelivr with no key. If you want it as an API with a query language, the same rates are behind https://allratestoday.com/api/open/central-bank/<code>, also keyless.

License

CC BY-NC 4.0. Use it for research, teaching, personal projects and journalism, redistribute it, train on it, with visible credit to AllRatesToday linking to https://allratestoday.com. Commercial use is not covered by the licence; the Official Rates plan at https://allratestoday.com/pricing#official is the commercial route, or write to support@allratestoday.com.

If you build something with it, open an issue on the GitHub repo or leave a note in the dataset's Community tab. Missing an institution you need? The repo README lists how new sources get added, and we are actively expanding coverage.

DEV Community: viraj geeth

Loading Official Central Bank Exchange Rates into Odoo (res.currency.rate, the Right Direction)

The rate Odoo stores

The loader

Run it inside Odoo

Try it without a key

Links

Official Central Bank Exchange Rates in Dynamics 365 Business Central (No Extension Needed)

The two limits of the built-in importer

Create the service

The field mapping, and why direction matters

When you do want an extension

Links

@allratestoday/sdk: The Official JavaScript SDK for Real-Time Exchange Rates

Why this SDK

Install

Quick start

Latest rates

Historical rates

Currency conversion

Time-series data

Preset period lookups

Node or browser — it doesn't care

When to pick @allratestoday/sdk vs the smaller packages

Next steps

Free currency API in 2026: what the free tiers actually give you

The four questions that matter

Comparison table

When a daily fixing is enough, and when it is not

Real-time on the free tier

How to pick

One thing every free tier has in common

I benchmarked 6 free exchange rate APIs every hour for a week. Here are the numbers.

Method

Results, first 7 days

What the numbers actually say

Which one should you use

Try the two fastest yourself

A currency API with no API key: AllRatesToday is now in the public-apis directory

The keyless part

In JavaScript, with no setup

What does need a key

Same data, no API at all

One correction to the listing

Auto-localize prices in React with react-currency-localizer-realtime

What you get

Install

1. The component — the simplest way

2. The hook — full control

3. Manual override

Why not just use Intl.NumberFormat?

Performance notes

Real-world use case

Next steps

Where Does Exchange Rate Data Come From? Sources, Accuracy, and Compliance

The Four Tiers of Exchange Rate Data

Tier 1: Central Banks (Most Authoritative)

Tier 2: Licensed Financial Data Providers (Production-Grade)

Tier 3: Aggregated / Derived Data (Varies Widely)

Tier 4: Scraped / Unverified Data (Not Recommended)

What Major APIs Actually Use

Why Data Source Matters for Compliance

Financial Reporting (IFRS / GAAP)

Payment Services (PSD2)

Tax Reporting

How AllRatesToday Sources Its Data

Choosing the Right Source for Your Use Case

Questions to Ask Your API Provider

Mid-Market vs Retail Exchange Rates: What Developers Need to Know

What Is the Mid-Market Rate?

What Is a Retail Rate?

Why This Matters for Your Application

E-Commerce Price Display

Multi-Currency SaaS Billing

Financial Reporting

How to Tell What Your API Returns

Adding Your Own Transparent Markup

Quick Reference

Is Oanda API Free? (And What to Use Instead in 2026)

The Two Oanda APIs (They're Not the Same Product)

Why not just use `Intl.NumberFormat`?