DEV Community: viraj geeth

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.

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

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.

14.6 million official exchange rates from 107 central banks and 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	14,612,276
Institutions	103 central banks + 4 tax authorities
Earliest date	1914 (Swiss National Bank)
Currencies	215 base, 202 quote
Refresh	daily, from the GitHub source repo
License	CC BY 4.0
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 14.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 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 4.0. Use it commercially, redistribute it, train on it. The one condition is visible credit to AllRatesToday with a link to https://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.

Your coding agent is quoting exchange rates from its training data

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

Try this in any AI coding tool:

Write a function that converts USD to EUR.

There is a good chance you get something like this back:

const USD_TO_EUR = 0.92;

export function usdToEur(amount: number) {
  return amount * USD_TO_EUR;
}

It compiles. It passes review. It is wrong, and it will stay wrong, silently, for as long as the code lives.

Why this is worse than a normal hallucination

Most model mistakes are visibly wrong. You run the code, it throws, you fix it. A stale exchange rate is different in three ways:

It looks right. 0.92 is a plausible USD/EUR rate. It was probably even correct at some point during pretraining. Nothing in the diff says "this number has an expiry date."
It has no failure mode. The function returns a number forever. There is no exception to catch, no log line, no alert.
It is money. If that function prices a checkout, every transaction is off by whatever the market has done since the training cutoff. A percent or two, compounding across every order, in the direction you didn't choose.

And the same reflex shows up in the conversational case. Ask an agent "what's the USD to EUR rate?" and it will often just answer — no fetch, no date, no caveat — because producing a fluent number is what it does.

The fix isn't a better prompt

You can tell the model "always fetch live rates" in your CLAUDE.md and it will comply, in that repo, until the instruction falls out of context. What actually fixes it is making the correct behaviour the path of least resistance: give the agent a tool that returns a real rate, and a skill that fires on the intent rather than waiting to be asked.

That is what this plugin is:

/plugin marketplace add AllRates-Today/claude-code-plugin
/plugin install allratestoday@allratestoday

No API key needed. That part matters more than it sounds — read on.

What it installs

Two skills. Skills load themselves when a task matches their description, which is the difference between a tool you have to remember and one that shows up on its own:

exchange-rates — fires on currency conversion, FX, localized pricing, historical series. Leads with "never quote a rate from memory", then covers which rate the task needs, caching by pair, money in minor units, and what happens when the fetch fails.
official-rates — fires on invoices, VAT, customs, statutory accounting. More on why that is a separate skill below.

Someone typing "show prices in the visitor's currency" gets the first one loaded without ever having heard of us. That is the whole point.

Five slash commands: /rate USD EUR, /convert 1500 USD to EUR, /official-rate ecb USD EUR 2026-01-15, /fx-history USD EUR 30d, and /add-currency-support, which reads your project — its language, HTTP conventions, secrets pattern, existing cache layer — and wires rates in the way that project already does things. It also greps for hardcoded rates while it's in there.

Two MCP servers, so the model can fetch rates directly rather than shelling out:

@allratestoday/mcp-server — live mid-market rates, 160+ currencies
@allratestoday/central-bank-mcp — official published tables from 100+ central banks and tax authorities

The mistake that costs more than a stale rate

There are two different numbers people call "the exchange rate", and using the wrong one is the expensive bug.

A mid-market rate is the live interbank midpoint. It moves continuously. It is the right number for a checkout, a price display, a converter.

An official rate is what a named institution published — the ECB reference rate for a given day, the HMRC monthly rate, the Bank of Japan rate in force. It is fixed once published, carries the publisher's own date, and is what an auditor checks against.

Compliance rules essentially never say "use the current market rate". They name a publisher and a date. And the two routinely differ by a percent or more, so a VAT return computed from a market rate produces numbers nobody can reconcile.

An LLM will not make this distinction unprompted — both are "the exchange rate" as far as the language goes. So it's built into the plugin: the official-rates skill fires on tax and invoicing intent, and /convert stops and redirects you if you mention an invoice.

Why keyless mattered more than we expected

The first version of both MCP servers did the responsible-looking thing: no API key, refuse to start, print instructions.

Then I installed the plugin as a new user would, and ran claude mcp list:

plugin:allratestoday:allratestoday: ✘ Failed to connect — CONNECTION_CLOSED
plugin:allratestoday:allratestoday-central-bank: ✘ Failed to connect — CONNECTION_CLOSED

An MCP server that exits doesn't degrade — it takes the host client's whole config down with it, at exactly the moment someone is deciding whether this is worth the trouble. "Fail fast with a clear message" is good advice for a CLI and terrible advice for a subprocess whose stderr nobody reads.

Both servers now degrade instead. With no key:

get_exchange_rate answers from the official ECB daily reference table — about 30 major currencies, labelled with its publication date so the model never passes a daily fixing off as a live quote
list_currencies returns all 160+ codes
get_official_rates returns the latest published table for any of the 100+ sources
the metered tools return one sentence explaining the free tier, instead of a dead process

That path reads endpoints that are already open and edge-cached, so it costs nothing to give away:

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

{
  "bank": "ecb",
  "rate_date": "2026-08-28",
  "source": "USD",
  "target": "EUR",
  "rate": 0.8588851671,
  "rate_type": "reference",
  "derived": true,
  "method": "inverse"
}

A free API key adds real-time mid-market rates across 160+ currencies, historical series, rates on past dates, and publication calendars. But nothing is gated behind a signup form before you can tell whether the thing works.

If you'd rather not install anything

The general lesson stands on its own: an agent should never produce a rate it did not fetch. Put this in your CLAUDE.md and you get most of the value:

Never state or hardcode an exchange rate from memory — fetch it.
For tax, invoices or customs, use the rate the relevant authority
published on the relevant date, not the current market rate.

And if you want the endpoint without any of the rest, that curl above needs no key and no account.

Plugin source: github.com/AllRates-Today/claude-code-plugin · API docs: allratestoday.com/docs · for agents: llms.txt

Building a Simple Exchange Rate MCP Server using FastMCP and AllRatesToday

viraj geeth — Sun, 26 Apr 2026 09:38:19 +0000

MCP, or Model Context Protocol, is a protocol created by Anthropic (the creators of Claude) to streamline and standardise LLM (large language model) access to external tools and resources.

FastMCP is a Python framework that allows you to implement MCP in your Python applications.

In this article, I'll walk you through creating an Exchange Rate MCP server that you can use in your coding agent, Claude Desktop, or any other MCP-compatible environment to get current exchange rates.

What really is the point of MCP?

LLMs, such as ChatGPT, Gemini, and Claude models, are trained on vast datasets up to a specific date, known as the knowledge cut-off date.

This is fine when you ask them about anything historical, but the moment you ask for something current — "what's the USD to EUR rate right now?" — they'll either guess based on stale training data or, worse, hallucinate a number that looks plausible but is completely wrong. For an LLM, "0.92" and "1.07" are equally valid-looking strings; the model has no built-in mechanism to know which one is true today.

Also, by default, LLMs cannot inherently take action in the real world. They are just next-token predictors and cannot perform tasks such as searching, fetching live data, or making API calls on the internet independently.

MCP solves these problems by enabling access to up-to-date information while allowing them to carry out external tasks that they would otherwise be unable to.

So let's build one and serve our agents some sweet, real-time exchange rates.

Let's build our Exchange Rate MCP Server!

To get current exchange rates, we'll be using the AllRatesToday API. At the time of writing, AllRatesToday supports more than 150 currencies, gives you live mid-market rates, and has a generous free tier (300 requests per month) that's more than enough for development.

The plan: create an AllRatesToday account for an API key, set up a Python virtual environment, write the MCP server code, and run it on Claude Desktop.

Step 1 — Get your API key

Head over to allratestoday.com/register, sign up (it takes about thirty seconds), and copy the API key from your dashboard. Keep it somewhere safe — we'll add it to a .env file in a moment.

Step 2 — Create the project folder and virtual environment

We'll use uv — it's faster than pip and handles environments cleanly.

mkdir /path/to/your/allrates-mcp
cd allrates-mcp

uv init
# This command creates the following:
# ├── .git/
# ├── .gitignore
# ├── .python-version
# ├── README.md
# ├── main.py
# └── pyproject.toml

uv venv  # This creates the virtual environment

# To activate the virtual environment in UNIX-based OSes:
source .venv/bin/activate

# For Windows:
.\.venv\Scripts\activate.bat

code .  # This opens our project folder in VSCode

# If you use Cursor:
cursor .

# For those of you who live on the edge:
vim .

uv add fastmcp dotenv httpx

That's fastmcp for the MCP framework, dotenv for reading the API key from a .env file, and httpx for the async HTTP client.

Step 3 — Write the MCP server

Open main.py and paste the following:

import httpx
import os
from dotenv import load_dotenv
from fastmcp import FastMCP

load_dotenv()

mcp = FastMCP(name="AllRatesToday Exchange Rate MCP Server")

ALLRATES_API_KEY = os.getenv("ALLRATES_API_KEY")
if not ALLRATES_API_KEY:
    raise EnvironmentError("ALLRATES_API_KEY is not set in environment variables.")

API_BASE = "https://allratestoday.com/api"


@mcp.tool
async def convert_currency(amount: float, base_curr: str, target_curr: str) -> str:
    """Convert an amount from one currency to another using current exchange rates."""

    try:
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"{API_BASE}/rate",
                params={
                    "source": base_curr.upper(),
                    "target": target_curr.upper(),
                },
                headers={"Authorization": f"Bearer {ALLRATES_API_KEY}"},
            )
            response.raise_for_status()
            data = response.json()

            if "rate" not in data:
                raise Exception(f"Unexpected response from AllRatesToday: {data}")

            rate = data["rate"]
            converted = round(amount * rate, 2)

            return (
                f"{amount} {base_curr.upper()} = {converted} {target_curr.upper()} "
                f"(Rate: {rate})"
            )

    except httpx.HTTPStatusError as e:
        if e.response.status_code == 401:
            raise Exception("Invalid AllRatesToday API key")
        elif e.response.status_code == 429:
            raise Exception("AllRatesToday API quota exceeded")
        elif e.response.status_code == 400:
            raise Exception(
                f"Bad request — possibly an unknown currency code: "
                f"{base_curr} or {target_curr}"
            )
        else:
            raise Exception(
                f"HTTP error occurred: {e.response.status_code} - {e.response.text}"
            )
    except httpx.RequestError as e:
        raise Exception(f"Request error occurred: {str(e)}")
    except Exception as e:
        raise Exception(f"Unexpected error occurred: {str(e)}")


if __name__ == "__main__":
    mcp.run()

A quick walkthrough of what the code does:

We load the API key from .env at startup. If it's missing, we crash early — better than failing silently in the middle of a tool call.

The @mcp.tool decorator turns convert_currency into a tool that the LLM can invoke. FastMCP introspects the type hints (float, str, str) and the docstring to build the tool schema automatically — that's what the LLM uses to decide when to call this function.

The function calls the AllRatesToday /api/rate endpoint with the base and target currencies as query parameters, and the API key as a Bearer token in the Authorization header. AllRatesToday returns a JSON object containing a rate field. We multiply that rate by the amount, round to two decimal places, and return a clean human-readable string.

Error handling is the part most tutorials skip and you shouldn't. We map the common failure modes — invalid key (401), quota exceeded (429), unknown currency code (400) — to readable messages so Claude can surface them sensibly when something goes wrong.

Step 4 — Set up your environment variable

Create a .env file in your project folder with your API key:

echo "ALLRATES_API_KEY=your_api_key" > /path/to/your/allrates-mcp/.env
# Make sure to replace 'your_api_key' with your actual key from allratestoday.com

The dotenv package picks this up automatically when the server starts. Don't commit this file to git — uv init already added it to .gitignore, but it's worth double-checking before your first push.

Step 5 — Wire it into Claude Desktop

Open the Claude Desktop config file:

# On MacOS:
code ~/Library/Application\ Support/Claude/claude_desktop_config.json

# On Windows:
code %APPDATA%\Claude\claude_desktop_config.json

Add the server under mcpServers:

{
  "mcpServers": {
    "allrates-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/your/allrates-mcp/",
        "run",
        "main.py"
      ]
    }
  }
}

Replace /path/to/your/allrates-mcp/ with the absolute path to your project folder. Relative paths look like they should work but don't, because Claude Desktop launches the subprocess from a different working directory than your shell.

Save the file, then fully quit and reopen Claude Desktop (Cmd+Q on Mac, not just close the window — closing the window leaves it running in the background and the new config won't load).

Step 6 — Try it out

Open a new conversation in Claude Desktop and ask something like:

"What's 250 USD in JPY today?"

Claude will recognise that convert_currency is the right tool, fill in the arguments, and call your MCP server. The tool call appears inline in the conversation, and the answer comes back grounded in real-time data — no hallucinated numbers.

Try a more open-ended one:

"If I had 1000 EUR and converted half to GBP and half to JPY, what would I have in total in USD?"

Claude will chain the tool calls itself — no orchestration logic on your side. That's the magic of MCP. You wrote one function; the agent figured out how to compose it.

Conclusion

You now have a working Exchange Rate MCP server in roughly sixty lines of Python. The same pattern — @mcp.tool plus type hints plus a docstring plus an HTTP call — generalises to any API in the world. Replace the AllRatesToday URL with a weather API and you have a weather server. Replace it with your internal CRM and your AI agent suddenly knows about your customers.

The bigger point is this: not very long ago, hooking an LLM up to a live data source was a research-grade undertaking with custom plumbing on every side. With FastMCP it's a thirty-minute coding session. The friction is gone, and that changes what's worth building.

If you want to extend this further, here are some natural next steps:

Add a get_historical_rate(base, target, date) tool using the AllRatesToday /v1/rates?time= endpoint
Add a get_rates_multi(base, [targets]) tool that fetches several rates in one call
Cache responses in memory to avoid burning your free-tier quota when the agent re-checks the same rate twice in a conversation
Wrap it with a FastAPI layer and deploy it as an HTTP MCP server so multiple agents can share one instance

The full AllRatesToday API documentation is at allratestoday.com/docs.

If this was useful, leave some claps 👏 — it helps the article reach more developers building agent applications.

Connect with me on LinkedIn or X, and let me know what you build with it.

Until next time, happy hacking. 🚀

Tags: MCP Server, FastMCP, Python, AI, LLM, Claude, Currency API, Forex

What Is the Best Website for Exchange Rates? (2026 Guide)

viraj geeth — Tue, 14 Apr 2026 17:23:09 +0000

If you search "best website for exchange rates," you get a dozen contradictory answers — Google Finance, XE, Wise, Reuters, your bank's app. They all show a number next to a currency pair, and they're all a little different. Which one is right?

The honest answer: "best" depends on what you're doing. A tourist checking a holiday budget has different needs from a developer building a checkout flow, an accountant reconciling invoices, or a trader sizing a position.

This guide ranks the best exchange rate websites of 2026 by use case, explains why the numbers differ between them, and helps you pick the right source for your specific situation.

TL;DR — Best Exchange Rate Website by Use Case

Use Case	Best Website	Why
Developers / APIs	AllRatesToday	Real-time, Reuters-sourced, free historical, REST API
Quick tourist lookup	Google Finance	Already in search results, good enough
Sending money abroad	Wise	Shows the rate you'll actually get after fees
Accounting / reporting	ECB reference rates	Regulator-accepted daily snapshot
Forex trading	Reuters / Bloomberg / XE	Live interbank, deep history, charts
Multi-currency dashboard	AllRatesToday	API + SDKs + 160+ currencies

Why Exchange Rates Differ Between Websites

Before picking a "best" site, it helps to understand why every site shows a slightly different number for the same pair.

1. Mid-market vs Retail Rate

The mid-market rate is the midpoint between what banks buy and sell a currency for on the interbank market. It's the "true" rate — and it's not the rate you actually get when you exchange money.

Most websites (Google, XE, Reuters) display the mid-market rate. Your bank, airport kiosk, or card issuer adds a margin on top — often 2–5% — and that's the rate applied to your transaction.

2. Data Source

Interbank feeds (Reuters/Refinitiv, Bloomberg) — live, tight, what banks actually quote.
Central banks (ECB, Fed) — one snapshot per day, published in the afternoon.
Aggregators — blend multiple sources into a composite rate.
Crypto exchanges — their own order books, which can drift from broader markets.

Two sites using different sources will always show slightly different numbers.

3. Update Frequency

FX markets move every second during trading hours. A site updating once a day will lag a site updating every 60 seconds by however much the market has moved since the snapshot.

The Best Exchange Rate Websites in 2026

1. AllRatesToday — Best for Developers and Apps

AllRatesToday is the best choice when you need exchange rates inside an application rather than just on a screen. It's an API-first service that delivers real-time mid-market rates from Reuters/Refinitiv and interbank feeds, with a clean REST endpoint and official SDKs.

160+ currencies plus precious metals
60-second updates on paid tiers
Free historical rates — rare among API providers
Any base currency, HTTPS, CORS
Official SDKs for JavaScript, Python, PHP
Free tier with no credit card

Best for: developers, SaaS apps, e-commerce checkouts, multi-currency billing, dashboards, and analytics tools.

2. Google Finance — Best for Quick Lookups

Google Finance (accessible via a simple USD to EUR search) is the fastest way to check a rate when you just need a number. It pulls mid-market data, updates frequently during market hours, and is already in your search bar.

Zero friction — no tab switch needed
Mid-market rates
Includes mini chart and day's high/low

Best for: casual lookups, travel budgeting, settling arguments about where the pound is today.

Limitation: no API, no history beyond what the chart shows, no programmatic access.

3. XE.com — Best Consumer Brand

XE has been synonymous with currency conversion since the 1990s. The website's "Currency Converter" is a go-to for travelers and occasional users, and XE publishes mid-market rates updated through the trading day.

170+ currencies and metals
Clean currency converter UI
Money transfer service layered on top
Charts and historical data on the site
Paid API tier for businesses

Best for: travelers, casual conversions, and users who trust the XE brand.

Limitation: the API is enterprise-priced (annual plans starting in the high hundreds), and there's no meaningful free tier for developers.

4. Wise (formerly TransferWise) — Best for Sending Money

If you're actually moving money across borders, Wise is the most useful site in the list. Wise displays mid-market rates and then shows you the exact rate and fee you'll get if you send money — no hidden margin.

Mid-market rates with transparent fees
The rate shown is the rate you get
Supports 40+ currencies for transfers
Live rate alerts

Best for: international transfers, remote work payments, and anyone who wants to know the true cost of a conversion.

Limitation: it's a transfer service, not a reference data source. You can't build an app on top of the displayed rates.

5. European Central Bank (ECB) Reference Rates

The ECB publishes a daily reference rate at 16:00 CET, covering around 30 currencies against EUR. It's free, public, and widely used for accounting and regulatory reporting.

Completely free, no API key
Trusted by tax authorities across the EU
Daily snapshot (not real-time)
Only covers around 30 currencies, EUR-based

Best for: accounting, tax reporting, month-end FX conversions, and any use case where "end-of-day ECB rate" is a regulatory-acceptable answer.

Limitation: one update per day, EUR-centric, no intraday data, no crypto.

6. Reuters / Refinitiv — Best for Institutional Trading

Reuters/Refinitiv terminals are the gold standard for institutional FX data. The rates you see on most other sites — including AllRatesToday — ultimately trace back to Reuters or Bloomberg feeds.

True real-time interbank pricing
Deep historical data and analytics
Used by banks, hedge funds, and corporates

Best for: banks, trading desks, and institutional users with enterprise budgets.

Limitation: priced for enterprise. Not accessible for individual developers or small businesses.

7. Bloomberg — Institutional Alternative to Reuters

Same category as Reuters, same audience. Bloomberg Terminal is the other dominant institutional data source, with its own FX feeds and analytics. If you have access to a Bloomberg Terminal, you already know how to use it.

8. Your Bank's Online Portal

Last but worth mentioning: your bank's website shows the exchange rate they will apply to your transactions. That rate includes their margin and often a spread. It's the most honest answer to "what rate will I get?" even if it's far from the mid-market number.

Best for: understanding your actual conversion cost before initiating a wire or card transaction.

How to Choose the Right Exchange Rate Website

Match the tool to the job:

"I need a rate for a trip / quick conversion" — Google Finance or XE.
"I'm sending money abroad" — Wise.
"I'm building an app or website" — AllRatesToday.
"I need to file taxes / close the month" — ECB reference rates.
"I'm trading FX professionally" — Reuters, Bloomberg, or your broker's terminal.
"I want to know what my bank will charge" — your bank's portal, not a reference site.

If you need more than one of these in one place, an API is the only scalable answer — and that's where AllRatesToday sits.

Frequently Asked Questions

What is the most accurate exchange rate website?

The most accurate rates come from interbank feeds (Reuters, Bloomberg). Sites that source from those feeds — AllRatesToday, XE, Google Finance — deliver the closest-to-real mid-market numbers. Sites using daily central bank snapshots (Fixer, some free APIs) are accurate only for that one moment of the day.

Why does Google show a different rate than my bank?

Google shows the mid-market rate. Your bank adds a margin to buy and sell, so the rate they apply to your transaction is usually 1–4% worse than Google's number. This is normal and legal — just factor it in.

Is there a website that shows real-time exchange rates for free?

Yes. Google Finance shows frequently-updated mid-market rates for free. For programmatic access, AllRatesToday offers real-time rates through its API on a free tier (300 requests/month, no credit card).

Which website is best for historical exchange rates?

For casual use: XE or the ECB (free, around 30 currencies, 20+ years of history). For developers: AllRatesToday offers historical rates on its free tier, which almost no other API does.

Can I trust a free exchange rate website?

For reference data — yes. Free doesn't mean inaccurate. Just check the data source. A free site pulling from Reuters is more trustworthy than a paid site that scrapes another website. Always look for a "data source" or "methodology" section.

Bottom Line

There is no single "best" exchange rate website — but there is a best one for you.

For lookups: Google Finance.
For transfers: Wise.
For reporting: ECB.
For trading: Reuters / Bloomberg / XE.
For developers and apps: AllRatesToday — the only option on this list that combines real-time interbank-sourced rates, free historical data, and a developer-friendly API with SDKs in three languages.

If you're building anything that needs exchange rates programmatically, get a free AllRatesToday API key and stop screen-scraping Google.

DEV Community: viraj geeth

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)

1. The Oanda v20 REST API (for traders)

2. The Oanda Exchange Rates API (for businesses)

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

You need a brokerage account for the v20 API

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

Geofencing and regional restrictions

2026 free-tier restrictions

The Exchange Rates API is sold to procurement, not developers

What "Free Oanda API" Searches Actually Want

Oanda Alternatives for Developers

When Oanda Is the Right Choice

When to Skip Oanda

Drop-in Replacement Example

FAQ

Is the Oanda API free?

Can I use the Oanda API without a trading account?

Is the Oanda demo account API free?

What does the Oanda Exchange Rates API cost?

Is there a free alternative to the Oanda API?

Can I use Oanda data in a commercial product?

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

The Three Layers of "Update Frequency"

1. Real-Time vs Delayed Data

2. The "Free Tier" Trap

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

Which Update Frequency Do You Actually Need?

How to Verify an API's Update Frequency

The Bottom Line

14.6 million official exchange rates from 107 central banks and tax authorities, now on Hugging Face

Why "official" rates and not market rates

What is in it

Why not just use `Intl.NumberFormat`?