DEV Community: Madhushan

AllRatesToday vs Open Exchange Rates: The 2026 Exchange Rate API Comparison

Madhushan — Tue, 21 Apr 2026 19:43:23 +0000

AllRatesToday vs Open Exchange Rates: The 2026 Exchange Rate API Comparison

Open Exchange Rates has been a staple currency API for more than a decade. It's reliable, well-documented, and the 1,000-request free tier is generous on paper. But talk to developers shipping payments, invoicing, and multi-currency checkouts in 2026 and you hear the same five complaints repeatedly: USD-only base currency on the free tier, hourly updates, no official SDKs, time-series queries burn the quota, and the conversion endpoint is paid-only.

This article compares Open Exchange Rates against AllRatesToday across the criteria that actually matter, and explains where AllRatesToday was built specifically to fix each of those pain points.

TL;DR — Side-by-side

Feature	AllRatesToday	Open Exchange Rates
Update frequency	60 seconds	Hourly (free/Dev/Enterprise), 10 min (Unlimited $97/mo)
Free tier requests	300/month	1,000/month
Base currency (free)	Any	USD only
Multiple base currencies	All plans	Developer plan ($12/mo) and above
Historical data (free)	Yes, cheap	Yes, but each day = 1 request
Conversion endpoint	Free	Paid only
Official SDKs	JS, Python, PHP	None (community-maintained only)
MCP / AI integrations	Yes (Claude Code, Cursor, DeepSeek)	No
Data source	Reuters/Refinitiv + interbank	"Blended" (undisclosed)
HTTPS on free	Yes	Yes
CORS	Yes	Yes

Update frequency: real-time vs hourly

This is the single biggest technical difference.

AllRatesToday refreshes rates every 60 seconds from Reuters (Refinitiv) and interbank market feeds.
Open Exchange Rates refreshes hourly on its free, Developer ($12/mo), and Enterprise ($47/mo) tiers. Only the Unlimited plan ($97/mo) updates every 10 minutes — and that's still not real-time.

For anything where the exchange rate affects the amount of money changing hands — checkout pricing, cross-border quotes, treasury dashboards — hourly data can be 1% off the market during a volatile session. That 1% comes out of your margin.

OpenExchangeRates' hourly cadence made sense in 2012. In 2026, real-time rates are available for free from several providers, and your users will notice the difference.

Base currency: USD-only is a 2012-era constraint

Open Exchange Rates' free plan only supports USD as a base currency. If you're building anything with a non-USD home market — a European SaaS, an Indian fintech, a Southeast Asian marketplace — you have two options:

Fetch USD-based rates and do cross-rate math in application code (extra code, rounding risk).
Upgrade to the Developer plan ($12/mo) or higher to get flexible base currencies.

AllRatesToday lets you pass any base currency on any plan, including the free tier:

GET /api/v1/rates?source=EUR&target=USD,GBP,CHF

Done. No workarounds, no upgrade required.

Historical data: watch the quota burn

OpenExchangeRates does include historical data on the free plan — but with a catch. The time-series.json endpoint counts one request per day of data returned. A 30-day query uses 30 of your 1,000 monthly requests. A one-year backfill (365 days) uses 36.5% of your quota in a single call.

AllRatesToday's historical endpoint returns the entire range as one request:

GET /api/historical-rates?source=USD&target=EUR&from=2025-04-01&to=2026-04-01

One request, one year of data, no quota multiplier.

Conversion: free vs paid

Open Exchange Rates exposes a dedicated /api/convert.json endpoint — but it's paid-only. On the free tier you have to fetch rates and do the multiplication in your own code.

With AllRatesToday's official SDKs, convert() is a one-liner on every plan:

const result = await client.convert('USD', 'EUR', 1000);
// { from: 'USD', to: 'EUR', amount: 1000, rate: 0.9234, result: 923.4 }

Official SDKs

OpenExchangeRates' own documentation says it plainly: they don't maintain official SDKs. There are "several hundred" community integrations, but the company "isn't able to provide support for any of these libraries, except those they actively maintain or contribute to." In practice, that means picking a third-party library on GitHub, auditing it yourself, and hoping the maintainer is still active.

AllRatesToday ships first-party SDKs for three languages:

npm install @allratestoday/sdk (JavaScript/TypeScript)
pip install allratestoday (Python)
composer require allratestoday/sdk (PHP)

Plus an MCP server for AI coding tools (Claude Code, Cursor, Claude Desktop) and a DeepSeek function-calling package — integrations Open Exchange Rates doesn't ship at all.

Data source transparency

OpenExchangeRates describes its data as "blended" from multiple sources, but doesn't disclose which sources. That's fine for shopping-cart-accurate rates, but it's not enough for a regulated environment where auditors ask where the number came from.

AllRatesToday publishes its sources: Reuters (Refinitiv) and interbank market feeds. These are the same feeds used by Bloomberg terminals and enterprise treasury systems.

When Open Exchange Rates is still the right call

You already have a working integration and don't want to touch it.
You need 1,000+ requests/month on a free tier and can tolerate hourly data.
Your use case is USD-only accounting or price display where base flexibility doesn't matter.

When AllRatesToday is the better choice

You need real-time (60-second) rates without paying.
You need any-base-currency flexibility on a free plan.
You want official SDKs instead of community libraries.
You want MCP or DeepSeek tool-calling for AI assistants.
You need transparent data sources for compliance or audit.

Migration is a one-afternoon job

The two APIs share the same JSON shape for the core "get rates" call. In most projects, swapping the client is a handful of lines. We've written a full migration guide that covers every endpoint.

Ready to switch? Get your free AllRatesToday API key — real-time rates, any base currency, free historical data, and official SDKs. No credit card required.

Why Open Exchange Rates' USD-Only Base Currency Is a Problem (And How AllRatesToday Fixes It)

Madhushan — Tue, 21 Apr 2026 19:42:26 +0000

Why Open Exchange Rates' USD-Only Base Currency Is a Problem

Open Exchange Rates' free plan locks you to a single base currency: USD. If you want to query rates with EUR, GBP, INR, or any other currency as the base, you have to upgrade to the Developer plan at $12/month — and even that has per-base limits on the cheaper tiers.

For a US-market product, this is fine. For everyone else, it's an unnecessary constraint that leaks into your codebase. This article explains why, what the workarounds actually cost, and why AllRatesToday lets you use any base currency on any plan, including the free tier.

What "USD-only base" means in practice

When you call Open Exchange Rates' free /latest.json endpoint, the response is always "1 USD equals X of each target":

{
  "base": "USD",
  "rates": {
    "EUR": 0.9234,
    "GBP": 0.7891,
    "INR": 83.42,
    ...
  }
}

If your product thinks in EUR ("what's 1 EUR in USD and GBP?"), you can't ask that question directly. You have to ask for USD rates, then derive the EUR rates yourself:

const usdRates = await getOpenExchangeRates(); // base = USD
const eurToUsd = 1 / usdRates.EUR;             // invert
const eurToGbp = usdRates.GBP / usdRates.EUR;  // cross-rate
const eurToInr = usdRates.INR / usdRates.EUR;  // cross-rate

Three problems show up immediately:

Rounding accumulates. Every inversion and cross-rate multiplication introduces floating-point error. Over thousands of conversions a day, the drift is measurable.
Code clutter. Every place you'd write a single API call becomes three lines of math. Bugs hide in the transformation code.
Mental model mismatch. Your product thinks in EUR; your API thinks in USD. Engineers constantly translate back and forth when reading logs, tests, and metrics.

The workarounds (and what each costs you)

Workaround 1: Do the cross-rate math. Cheapest option, zero infra cost, but adds code complexity and a rounding-bug surface area. Fine for low-stakes use cases; risky for payments.

Workaround 2: Upgrade to the Developer plan. $12/month ($144/year) buys you base-currency flexibility — but you're also paying for features you might not need (larger quotas, priority support). If base currency is the only reason you're upgrading, that's $144/year for what should be a free feature.

Workaround 3: Cache both directions. Fetch USD-based rates, then pre-compute EUR-based rates on the way into your cache. Works, but now you have two code paths and a cache invalidation concern.

How AllRatesToday handles it

Any base currency, any plan, including the free tier:

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

Response:

{
  "source": "EUR",
  "rates": {
    "USD": 1.0830,
    "GBP": 0.8546,
    "INR": 90.34
  },
  "time": "2026-04-21T12:00:00Z"
}

No inversion, no cross-rate math, no upgrade required.

Who this actually affects

Most products outside the US hit this wall:

European SaaS billing in EUR, showing prices in GBP and CHF.
Indian fintech with INR as the home currency, quoting cross-border remittances.
Southeast Asian marketplaces with SGD or MYR as the base, displaying prices in regional currencies.
LATAM payment platforms with BRL, MXN, or ARS as the base.
Canadian and Australian products where CAD or AUD is the natural home currency.

Any of these use cases require either paying for Open Exchange Rates or writing cross-rate glue code. With AllRatesToday, you skip both.

Multi-base queries in one call

AllRatesToday also supports multi-target queries with any base. One request gives you EUR against every currency you care about:

GET /api/v1/rates?source=EUR

Open Exchange Rates' equivalent requires either upgrading or making one request per base — each of which counts against your quota.

The bigger picture

USD-only base on the free tier is an artifact of Open Exchange Rates' original design from the early 2010s, when USD was the default reference for almost every web app. In 2026, that assumption is showing its age. Cross-border commerce, EU and UK fintech, Indian SaaS, and Southeast Asian marketplaces all benefit from native multi-base support.

AllRatesToday was built with this in mind: every endpoint accepts any supported currency as the source, and there's no plan-gated "base currency" feature.

Done paying for a feature that should be free? Get your free AllRatesToday API key — any base currency, real-time rates, 160+ currencies, no credit card.

Open Exchange Rates Hourly Updates vs AllRatesToday's 60-Second Real-Time Feed

Madhushan — Tue, 21 Apr 2026 19:41:53 +0000

Open Exchange Rates Hourly Updates vs AllRatesToday's 60-Second Real-Time Feed

Open Exchange Rates' documentation is explicit about cadence: "All plans update hourly, except for the Unlimited Plan, which updates every 10 minutes." The Unlimited plan is $97/month.

That means unless you're paying top tier, the rate you see at 14:03 is the rate that was set at around 14:01 — and it will not change until roughly 15:01. Between the two timestamps, you're working with data that's up to 59 minutes stale.

AllRatesToday refreshes every 60 seconds across every plan, including the free tier. This article explains why that matters, when hourly data is enough, and how much hourly staleness costs in concrete scenarios.

The update cadence, plan by plan

Provider / Plan	Update interval
AllRatesToday — Free	60 seconds
AllRatesToday — Any paid plan	60 seconds
OpenExchangeRates — Free	60 minutes
OpenExchangeRates — Developer ($12/mo)	60 minutes
OpenExchangeRates — Enterprise ($47/mo)	60 minutes
OpenExchangeRates — Unlimited ($97/mo)	10 minutes

Even at $97/month, Open Exchange Rates is a 10-minute cadence. AllRatesToday's free tier is 10x fresher than their top-paid tier.

"Real-time" is a loaded word. Here's the reality.

No public API is truly tick-by-tick real-time — that data lives on paid Bloomberg/Refinitiv terminals. The practical question is: how stale can the number be when I display it?

60 seconds — fast enough that a displayed rate and the true market rate disagree by at most a few basis points for major pairs.
10 minutes — enough for markets to move 10-30 bps on a normal day, 50+ bps during announcements.
60 minutes — markets can move 50-100 bps on a calm day, 200+ bps during Fed/ECB announcements or macro surprises.

Concrete cost: a mid-size e-commerce checkout

Imagine an online store processing 1,000 cross-border orders per day with an average ticket of $100. The store displays prices in the customer's local currency and settles in USD.

Scenario A (60-second rates): the displayed price and the true market rate disagree by an average of ~2 bps across the day. Expected daily slippage cost: ~$20 (0.02% × $100,000).
Scenario B (hourly rates): the displayed price and the true market rate disagree by an average of ~15-25 bps across the day, depending on volatility. Expected daily slippage cost: ~$150-250.

On a calm day, hourly rates cost the business $130-230 more than 60-second rates. On a volatile day, the gap widens.

Over a year on a $36M GMV operation, that's tens of thousands of dollars in cumulative rate drift — a multiple of what any real-time rate API costs.

Where hourly data is actually fine

Not every use case cares. Hourly updates are sufficient for:

Read-only dashboards (analytics, reporting) where decisions aren't made in-flight.
Accounting rollups that only care about end-of-day or end-of-month snapshots.
Historical charting where intraday precision isn't the point.
Informational widgets (country pages, blog posts) where "roughly correct" is good enough.

If your app fits these profiles, Open Exchange Rates' hourly cadence is not a problem.

Where hourly data hurts

Payments and checkout. The rate that determines how much the customer pays.
Quotes and invoicing. A USD invoice converted at 09:00 can be 0.5% off by 09:55 on a volatile morning.
Treasury and cash management. Intra-day FX moves directly hit the balance sheet.
Trading and backtesting. Anywhere the rate is part of a P&L calculation.
Remittance marketplaces. Users comparing rates across providers; stale data = lost trust.

How AllRatesToday delivers 60-second rates

Rates are pulled from Reuters (Refinitiv) and interbank market feeds every 60 seconds and cached at the edge. The API response reflects the most recent snapshot, and every response includes a time field so you can confirm freshness:

{
  "source": "USD",
  "target": "EUR",
  "rate": 0.9234,
  "time": "2026-04-21T14:03:22Z"
}

If time is more than 60 seconds behind "now," something's wrong. With Open Exchange Rates' hourly cadence, the timestamp field is supposed to be up to 59 minutes old — so you can't use it as a freshness check.

Rate limits aren't the bottleneck. Data is.

A common misconception: "Open Exchange Rates gives 1,000 free requests, AllRatesToday gives 300. So Open Exchange Rates is more generous."

Request quota isn't the constraint for most apps — freshness is. Once you've fetched rates, you'll cache them for their validity window anyway. The question is how often the source updates, not how often you're allowed to poll.

With AllRatesToday, you can poll every 60 seconds and always get fresh data.
With Open Exchange Rates free, polling more than once per hour returns the same stale number. The extra 900 requests buy you nothing but duplicated responses.

In other words: a 300-request quota on a 60-second feed gives you more fresh data points per day than a 1,000-request quota on a 60-minute feed.

Migration: one URL swap

If you're on Open Exchange Rates' free tier and hourly data isn't cutting it, the migration is short. The JSON response shape is nearly identical — swap the URL and the auth header.

- https://openexchangerates.org/api/latest.json?app_id=XXX
+ https://allratestoday.com/api/v1/rates?source=USD
  (Authorization: Bearer YOUR_API_KEY)

A full migration guide walks through every endpoint.

Stop serving hour-old rates. Get your free AllRatesToday API key — 60-second updates from Reuters and interbank feeds, every plan including free.

No Official SDKs on Open Exchange Rates: AllRatesToday's JavaScript, Python, and PHP Libraries

Madhushan — Tue, 21 Apr 2026 19:41:20 +0000

No Official SDKs on Open Exchange Rates: AllRatesToday's JavaScript, Python, and PHP Libraries

Open Exchange Rates' own docs spell it out: "We don't actively support or maintain any of these community libraries (except where stated)." The recommended integration path is direct HTTP — "access latest.json via AJAX, CURL, Scrapy, node-httpagent, or your method of choice."

For a simple read-only endpoint, that's workable. But when you hit production concerns — retries, typed responses, caching, error normalization, rate-limit handling — you're reimplementing the same client wrapper every team has already written ten times over.

AllRatesToday ships first-party SDKs for JavaScript/TypeScript, Python, and PHP, plus MCP server and DeepSeek integration for AI coding tools. This article walks through why that matters and what the DX difference looks like in practice.

What "no official SDK" means

Open Exchange Rates' API Libraries & Extensions page lists community libraries for Ruby, Python, PHP, Node.js, .NET, Java, and others. Some are well-maintained; others were last updated in 2017. All are third-party.

What you give up without an official SDK:

Type definitions. Auto-complete for endpoint names, parameters, and response shapes.
Version-stable contract. Community libs sometimes drift from the official API spec.
Consistent error handling. Each lib defines its own error classes and conventions.
Unified retry/backoff. Each lib (re)implements retries from scratch, often badly.
Support. Open Exchange Rates can't help if the bug is in a third-party library.

AllRatesToday's official SDKs

JavaScript / TypeScript

npm install @allratestoday/sdk

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday(process.env.ALLRATES_API_KEY!);

// Single rate (typed response)
const { rate } = await client.getRate('USD', 'EUR');

// Convert with typed result
const { result } = await client.convert('USD', 'EUR', 1000);

// Historical — returns a typed time series
const history = await client.getHistoricalRates('USD', 'EUR', '30d');
history.rates.forEach(p => console.log(p.time, p.rate));

Full TypeScript types. Throws a typed AllRatesTodayError on 4xx/5xx. Handles retry/backoff by default.

Python

pip install allratestoday

from allratestoday import AllRatesToday

client = AllRatesToday(api_key="YOUR_KEY")

rate = client.get_rate("USD", "EUR")
result = client.convert("USD", "EUR", 1000)
history = client.get_historical_rates("USD", "EUR", "30d")

Ships with type hints, async variant (AsyncAllRatesToday), and context-manager support.

PHP

composer require allratestoday/sdk

use AllRatesToday\AllRatesToday;

$client = new AllRatesToday('YOUR_KEY');
$rate = $client->getRate('USD', 'EUR');
$result = $client->convert('USD', 'EUR', 1000);

PSR-18 compatible HTTP client, PSR-3 logger support.

The same task in raw HTTP (what you'd write against Open Exchange Rates)

Here's a realistic production client you'd need to write against Open Exchange Rates to get the same features the AllRatesToday SDK gives you for free:

async function getRate(from, to, attempt = 0) {
  const url = `https://openexchangerates.org/api/latest.json?app_id=${APP_ID}&base=${from}&symbols=${to}`;

  try {
    const res = await fetch(url);
    if (res.status === 429) {
      // rate limited — backoff
      if (attempt < 3) {
        await new Promise(r => setTimeout(r, 2 ** attempt * 1000));
        return getRate(from, to, attempt + 1);
      }
      throw new Error('Rate limited after retries');
    }
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    const data = await res.json();
    if (data.error) throw new Error(data.description);
    return data.rates[to];
  } catch (err) {
    // re-throw normalized
    throw err;
  }
}

About 20 lines of hand-rolled glue per team. The AllRatesToday SDK gives you all of this behind a three-word method call.

Note: the base=${from} parameter in the URL above won't work on the Open Exchange Rates free plan — base is USD-only. You'd need either the Developer tier or to switch to cross-rate math. We cover that pain point separately.

MCP and DeepSeek: AI-coding-tool integrations

AllRatesToday also ships integrations Open Exchange Rates doesn't offer at all:

MCP server (@allratestoday/mcp-server) — plugs into Claude Code, Cursor, Claude Desktop, ChatGPT Desktop. Your AI assistant can call get_exchange_rate, get_historical_rates, list_currencies, and get_rates_authenticated directly.
DeepSeek package (allratestoday-deepseek) — Python function-calling library for DeepSeek's Chat Completions API.

Neither of these makes sense without a well-defined SDK layer, and that's the practical payoff of shipping an official client: you can build higher-level integrations on top of it without every downstream user rebuilding the wrapper.

When community libraries are fine

If you're on a language AllRatesToday doesn't yet officially support (Ruby, Go, Rust, .NET, Java), the community libraries for Open Exchange Rates and AllRatesToday are both usable — just audit the maintenance status before shipping.

When you want an official SDK

Production apps where error handling and retry policy need to be consistent and tested.
TypeScript or typed Python codebases where response types avoid class of bugs.
Teams that want vendor support when something breaks.
Anyone building on top of the SDK (wrappers, higher-level libraries, custom agents).

Skip the hand-rolled HTTP client. Get your free AllRatesToday API key — install the SDK, start calling client.getRate(), done.

Open Exchange Rates Free Plan vs AllRatesToday Free Tier: What You Actually Get

Madhushan — Tue, 21 Apr 2026 19:40:51 +0000

Open Exchange Rates Free Plan vs AllRatesToday Free Tier: What You Actually Get

"Free" does a lot of work in API pricing pages. Two providers can both claim a free tier and deliver wildly different value. Open Exchange Rates' headline number — 1,000 requests/month — looks more generous than AllRatesToday's 300 requests/month until you put the feature matrices side by side.

This article walks through what each free tier actually gives you, and explains why more requests per month isn't the right metric for most apps.

Side-by-side feature matrix

Feature	AllRatesToday Free	OpenExchangeRates Free
Monthly requests	300	1,000
Update frequency	60 seconds	60 minutes
Base currency	Any	USD only
Multiple targets per call	Yes	Yes
Historical data	Yes (one request per range)	Yes (one request per day)
Conversion endpoint	Yes	Paid plans only
Time-series endpoint	Yes	Yes but burns quota
HTTPS	Yes	Yes
CORS	Yes	Yes
Official SDKs	JS, Python, PHP	None
MCP / DeepSeek integrations	Yes	No
Credit card required	No	No

Request quota: the number everyone looks at

1,000 vs 300 monthly requests. Numerically, Open Exchange Rates wins here.

But — critically — request count is not the same as data coverage. If you query Open Exchange Rates 1,000 times per month on the free tier, you're getting the same hourly snapshots over and over. Rates only change once per hour on their free plan.

With AllRatesToday's 60-second cadence:

You can poll once per minute and always get fresh data (1,440 new snapshots per day available, you fetch what you need).
A typical single-page app that fetches one rate on page load serves 300 unique users per month on the free plan — and each of them sees a rate that's at most 60 seconds old.

With Open Exchange Rates' 60-minute cadence:

The data only updates 24 times per day.
You can fire 1,000 requests per month, but anything above 24 × 30 = 720 requests fetches duplicate data.
For serving page loads, the cap-per-month number dominates; for serving fresh data, the cadence does.

Update frequency: 60x difference

This is the biggest real gap between the two free tiers.

AllRatesToday Free: 60-second updates from Reuters/Refinitiv and interbank feeds.
OpenExchangeRates Free: 60-minute updates, sourced from a blended feed (providers not publicly disclosed).

For anything involving money — checkout, invoicing, treasury, payments — 60-second beats 60-minute every time. We break down the cost of hourly staleness in a separate article.

Base currency: USD-only is a wall

Open Exchange Rates' free plan only supports USD as a base. Want EUR-based rates? Upgrade to Developer ($12/mo). Want INR? Same. Want GBP? Same.

AllRatesToday's free tier accepts any supported currency as the source:

GET /api/v1/rates?source=EUR&target=USD,GBP,CHF
GET /api/v1/rates?source=INR&target=USD,EUR,AED
GET /api/v1/rates?source=AUD&target=NZD,USD,EUR

If your product's home currency isn't USD, this single difference can decide which API you pick.

Historical data: quota-friendly vs quota-burning

Both providers include historical data on the free tier — but they count it differently.

OpenExchangeRates:

historical/{date}.json — one request per specific date.
time-series.json — one request per day returned. A 30-day range uses 30 requests. A one-year backfill uses 365 requests (36.5% of your monthly quota in a single call).

AllRatesToday:

historical-rates?from=X&to=Y — one request per range, regardless of how many days. A one-year backfill is one request, not 365.

If you're doing any kind of analytics, charting, or backtesting, this is a significant free-tier advantage.

Conversion endpoint: free vs paid

Open Exchange Rates has a dedicated /api/convert.json endpoint for "convert 1,000 USD to EUR" — but it's paid plans only. On the free tier, you fetch rates and do the multiplication client-side.

AllRatesToday ships conversion on every plan. With the SDK:

const result = await client.convert('USD', 'EUR', 1000);
// { from: 'USD', to: 'EUR', amount: 1000, rate: 0.9234, result: 923.4 }

For typical shopping-cart and invoicing flows, this alone saves a fair amount of glue code.

SDKs and AI integrations

Open Exchange Rates' free tier gives you raw HTTP access. AllRatesToday's free tier includes:

Official JavaScript/TypeScript SDK.
Official Python SDK.
Official PHP SDK.
MCP server for Claude Code, Cursor, Claude Desktop, ChatGPT Desktop.
DeepSeek function-calling package.

None of these incur extra cost — they're tools for working with the free tier.

When to pick each free tier

Pick OpenExchangeRates Free when:

You need 500+ rate lookups per month and hourly data is fine and USD-only base works and you don't need the conversion endpoint.
You already have a working integration and switching isn't worth the effort.

Pick AllRatesToday Free when:

You need real-time (60-second) rates — the top reason.
Your product isn't USD-centric (EUR, GBP, INR, AUD, SGD, BRL, etc.).
You want historical data without burning quota.
You want the conversion endpoint.
You want an official SDK.
You want MCP or DeepSeek support for AI tools.

The bigger picture

Free tiers are marketing. The numbers on the pricing page are chosen to make the provider look good on a comparison chart. Look at what each free tier enables — fresh data, flexible queries, real endpoints — and the gap narrows or reverses.

For most non-US products, AllRatesToday's free tier is the more useful one even though the request cap is lower. For USD-only products on hourly data, Open Exchange Rates works.

Get your free AllRatesToday API key — 60-second rates, any base currency, free historical, conversion endpoint, official SDKs. No credit card.

Open Exchange Rates Time-Series Burns Your Quota: AllRatesToday's Historical Rates Explained

Madhushan — Tue, 21 Apr 2026 19:40:17 +0000

Open Exchange Rates Time-Series Burns Your Quota

If you've shipped anything against Open Exchange Rates that touches history, you've probably hit this the hard way. Their documentation is explicit: "Requests to the time-series.json API endpoint count as one request for each day of data returned."

Meaning:

7 days of data = 7 requests
30 days = 30 requests (3% of your free 1,000/month cap)
90 days = 90 requests (9%)
365 days = 365 requests (36.5% of your free monthly quota in a single call)

For a charting use case that backfills a year of daily rates across 5 currency pairs, you're at 5 × 365 = 1,825 requests — past the free tier in a single page load.

AllRatesToday prices historical differently: one request per range, not per day. This article explains the difference, what it costs in practice, and how to design around either.

The quota model

OpenExchangeRates `time-series.json`

GET /api/time-series.json?app_id=XXX&start=2025-01-01&end=2025-12-31&base=USD&symbols=EUR
# costs: 365 requests against your monthly quota

The endpoint returns all 365 daily rates in one HTTP call — but internally it's billed as if you'd made 365 individual historical requests.

AllRatesToday `historical-rates`

GET /api/historical-rates?source=USD&target=EUR&from=2025-01-01&to=2025-12-31
# costs: 1 request against your monthly quota

One HTTP call, one quota decrement.

Concrete scenarios

Scenario 1: Dashboard with 5 pairs × 90-day history

OpenExchangeRates: 5 × 90 = 450 requests per dashboard load. Past the free 1,000/mo cap after two loads.
AllRatesToday: 5 × 1 = 5 requests per load. ~60 loads possible on the free 300/mo cap.

Scenario 2: Tax-year backfill (1 year, 1 pair)

OpenExchangeRates: 365 requests. One-shot operation consumes 36.5% of the monthly quota.
AllRatesToday: 1 request. 0.33% of the monthly quota.

Scenario 3: Multi-pair backtest (10 pairs × 3 years)

OpenExchangeRates: 10 × 1,095 = 10,950 requests. Well past any plan below Enterprise.
AllRatesToday: 10 requests.

The OpenExchangeRates model effectively turns historical analysis into a line-item purchase: every day of data you want, you pay for.

Why the pricing model exists

Historical data is bandwidth-heavy. An "all currencies for one day" response can be 5-10 KB. Open Exchange Rates' per-day billing reflects internal cost: each day is a separate backend lookup. It's defensible from an infra economics perspective.

It's still a bad developer experience. When your request count doesn't match your HTTP call count, capacity planning gets confusing fast. You have to explain to new team members why one line of code burned 365 requests.

AllRatesToday's approach is to price the API surface area, not the underlying row count. One call, one request, regardless of the date range. Simpler to reason about, easier to stay under quota.

When per-day billing is fine

You only pull history for specific dates (accounting, invoice reconciliation). Open Exchange Rates' historical/{date}.json is one request per date — the same price as AllRatesToday for single-date queries.
You rarely look at ranges — your app mostly uses current rates.

When range-based pricing matters

Charting: every dashboard render pulls a range.
Analytics: rolling 30/90/365-day windows.
Backtesting: long ranges across many pairs.
Reporting: monthly/quarterly/yearly recaps.

Any of these become 10-50x cheaper in quota terms on AllRatesToday.

AllRatesToday historical endpoint, in detail

curl -X GET "https://allratestoday.com/api/historical-rates?source=USD&target=EUR&from=2025-01-01&to=2025-12-31" \
  -H "Authorization: Bearer YOUR_API_KEY"

Response:

{
  "source": "USD",
  "target": "EUR",
  "from": "2025-01-01",
  "to": "2025-12-31",
  "rates": [
    { "time": "2025-01-01", "rate": 0.9521 },
    { "time": "2025-01-02", "rate": 0.9534 },
    ...
    { "time": "2025-12-31", "rate": 0.9214 }
  ]
}

Supported periods include shortcuts (period=30d, period=1y) and custom date ranges. Every range is one request.

Migrating a time-series query

Most apps using Open Exchange Rates' time-series.json pass start, end, and a base/symbols combination. The equivalent AllRatesToday call is:

- https://openexchangerates.org/api/time-series.json?start=2025-01-01&end=2025-12-31&base=USD&symbols=EUR&app_id=XXX
+ https://allratestoday.com/api/historical-rates?source=USD&target=EUR&from=2025-01-01&to=2025-12-31
  (Authorization: Bearer YOUR_API_KEY)

Response shape is different (array of {time, rate} vs keyed object), but the transformation is straightforward.

What if you still need per-day granularity?

Both APIs support single-date historical lookups at one-request-per-date:

OpenExchangeRates: GET /api/historical/2025-06-15.json
AllRatesToday: GET /api/historical-rates?source=USD&target=EUR&from=2025-06-15&to=2025-06-15

If your app cares about a handful of specific dates rather than ranges, either API is fine.

Get your free AllRatesToday API key — free historical data, one request per range, 60-second real-time updates. No credit card.

Migrating from Open Exchange Rates to AllRatesToday: A Developer's Guide

Madhushan — Tue, 21 Apr 2026 19:39:30 +0000

Migrating from Open Exchange Rates to AllRatesToday: A Developer's Guide

If you've decided to move off Open Exchange Rates — for real-time rates, any-base-currency flexibility, official SDKs, or free historical data — the migration itself is usually a one-afternoon job. The JSON shapes are similar enough that most of the work is mechanical.

This guide walks you through every endpoint, shows the URL and response-shape differences, and ends with the SDK drop-in for each supported language.

Before you start

Get your AllRatesToday API key at allratestoday.com/register. Free tier, no credit card.
Keep both keys active during migration so you can run a side-by-side comparison.
Write a wrapper in one place. If your codebase has inline fetch calls to openexchangerates.org, consolidate them before migrating. Then you'll only touch one file.

Endpoint-by-endpoint mapping

1. Latest rates

Open Exchange Rates:

GET https://openexchangerates.org/api/latest.json?app_id=YOUR_APP_ID

Response:

{
  "disclaimer": "...",
  "license": "...",
  "timestamp": 1713702122,
  "base": "USD",
  "rates": {
    "EUR": 0.9234,
    "GBP": 0.7891,
    ...
  }
}

AllRatesToday:

GET https://allratestoday.com/api/v1/rates?source=USD
Authorization: Bearer YOUR_API_KEY

Response:

{
  "source": "USD",
  "rates": {
    "EUR": 0.9234,
    "GBP": 0.7891,
    ...
  },
  "time": "2026-04-21T14:03:22Z"
}

Differences:

base → source
timestamp (Unix epoch) → time (ISO 8601)
No disclaimer/license fields (they don't exist in AllRatesToday responses).

2. Specific currency pair

Open Exchange Rates (free tier is USD-only):

GET https://openexchangerates.org/api/latest.json?symbols=EUR&app_id=YOUR_APP_ID

Response gives {base: "USD", rates: {EUR: 0.9234}}.

AllRatesToday:

GET https://allratestoday.com/api/v1/rates?source=USD&target=EUR

Response:

{
  "source": "USD",
  "target": "EUR",
  "rate": 0.9234,
  "time": "2026-04-21T14:03:22Z"
}

Note: AllRatesToday returns a scalar rate when a single target is specified, and a rates object when multiple are specified. Open Exchange Rates always returns a rates object.

3. Non-USD base currency

Open Exchange Rates (paid plans only):

GET https://openexchangerates.org/api/latest.json?base=EUR&app_id=YOUR_APP_ID

On the free tier, this fails with 403 and message "Changing the APIbasecurrency is available for Developer, Enterprise and Unlimited plan clients."

AllRatesToday (all plans, including free):

GET https://allratestoday.com/api/v1/rates?source=EUR

Just works. If you're currently doing cross-rate math client-side because of the USD-only restriction, you can delete all of that code.

4. Historical rate for a specific date

Open Exchange Rates:

GET https://openexchangerates.org/api/historical/2025-06-15.json?app_id=YOUR_APP_ID

AllRatesToday:

GET https://allratestoday.com/api/historical-rates?source=USD&target=EUR&from=2025-06-15&to=2025-06-15

Response returns an array with one entry.

5. Time-series / range historical

Open Exchange Rates (counts 1 request per day):

GET https://openexchangerates.org/api/time-series.json?start=2025-01-01&end=2025-12-31&base=USD&symbols=EUR&app_id=YOUR_APP_ID

Response:

{
  "base": "USD",
  "rates": {
    "2025-01-01": { "EUR": 0.9521 },
    "2025-01-02": { "EUR": 0.9534 },
    ...
  }
}

AllRatesToday (1 request per range):

GET https://allratestoday.com/api/historical-rates?source=USD&target=EUR&from=2025-01-01&to=2025-12-31

Response:

{
  "source": "USD",
  "target": "EUR",
  "from": "2025-01-01",
  "to": "2025-12-31",
  "rates": [
    { "time": "2025-01-01", "rate": 0.9521 },
    { "time": "2025-01-02", "rate": 0.9534 },
    ...
  ]
}

Transformation (OXR → ART shape):

const oxrRates = oxrResponse.rates;
const artRates = Object.entries(oxrRates).map(([date, pair]) => ({
  time: date,
  rate: pair[target]
}));

6. Currency conversion

Open Exchange Rates (paid plans only):

GET https://openexchangerates.org/api/convert/1000/USD/EUR?app_id=YOUR_APP_ID

On the free tier, this returns 403 with "The requested feature is not available on your current plan.".

AllRatesToday (all plans, including free), via SDK:

await client.convert('USD', 'EUR', 1000);
// { from: 'USD', to: 'EUR', amount: 1000, rate: 0.9234, result: 923.4 }

Or raw HTTP (fetch the rate and multiply client-side — same pattern you likely already have for OXR free tier):

const { rate } = await fetch('/api/v1/rates?source=USD&target=EUR').then(r => r.json());
const result = 1000 * rate;

7. List of supported currencies

Open Exchange Rates:

GET https://openexchangerates.org/api/currencies.json

Returns { "AED": "UAE Dirham", "AFN": "Afghan Afghani", ... }.

AllRatesToday:

GET https://allratestoday.com/api/v1/symbols
Authorization: Bearer YOUR_API_KEY

Returns the same shape.

Authentication difference

Open Exchange Rates uses a query-string app_id parameter:

?app_id=YOUR_APP_ID

AllRatesToday uses a standard Authorization: Bearer header:

Authorization: Bearer YOUR_API_KEY

If your current code has URL builders that interpolate app_id, swap to an HTTP client that sets the auth header once globally. The SDKs do this for you.

SDK drop-in replacements

Instead of replacing URLs by hand, replace your OXR client with AllRatesToday's SDK.

JavaScript / TypeScript

npm install @allratestoday/sdk

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday(process.env.ALLRATES_API_KEY!);

const { rate } = await client.getRate('USD', 'EUR');
const history = await client.getHistoricalRates('USD', 'EUR', '30d');
const { result } = await client.convert('USD', 'EUR', 1000);

Python

pip install allratestoday

from allratestoday import AllRatesToday

client = AllRatesToday("YOUR_API_KEY")
rate = client.get_rate("USD", "EUR")
history = client.get_historical_rates("USD", "EUR", "30d")

PHP

composer require allratestoday/sdk

use AllRatesToday\AllRatesToday;

$client = new AllRatesToday('YOUR_API_KEY');
$rate = $client->getRate('USD', 'EUR');

Side-by-side validation

Keep both providers live for a week and compare results:

const [oxr, art] = await Promise.all([
  fetchOXR('USD', 'EUR'),
  fetchART('USD', 'EUR'),
]);
const diffBps = Math.abs(oxr - art) / art * 10000;
if (diffBps > 20) logger.warn({ oxr, art, diffBps }, 'rate mismatch');

For major pairs, you should see the two within ~20 basis points during normal market hours. Larger diffs usually mean one of the sources is stale (OXR hourly cadence) or you're comparing different market timestamps.

After migration

Once you're on AllRatesToday:

Delete any cross-rate math that existed to work around OXR's USD-only free tier.
Reduce historical calls to one-per-range (instead of one-per-day) and reclaim quota.
Swap any /api/convert.json workarounds for client.convert().

Rollback plan

Keep the OXR client wrapper behind a feature flag for two weeks. If anything goes wrong, flip back with a config change while you debug. Don't delete the OXR code until you've had a full billing cycle on AllRatesToday.

Get your free AllRatesToday API key and start your migration today. Free tier, no credit card, 60-second rates.

Open Exchange Rates Pricing vs AllRatesToday: Which Exchange Rate API Is Cheaper in 2026?

Madhushan — Tue, 21 Apr 2026 19:38:30 +0000

Open Exchange Rates Pricing vs AllRatesToday: Which Exchange Rate API Is Cheaper in 2026?

Open Exchange Rates' pricing is straightforward on the surface: $12/month Developer, $47/month Enterprise, $97/month Unlimited, plus a Forever Free plan with 1,000 requests/month. The trick is reading what each tier gates.

Several features that most apps need — non-USD base currency, the conversion endpoint, 10-minute updates — are only available starting at Developer or Unlimited. By the time you've unlocked the basics, the monthly cost can exceed what you'd pay for a fully-featured tier elsewhere.

This article compares the two providers' pricing dollar-for-dollar and explains which tier you'd actually land on for common use cases.

Open Exchange Rates' plan breakdown

Plan	Price	Requests / month	Updates	Base currency	Conversion endpoint
Free	$0	1,000	Hourly	USD only	No
Developer	$12/mo ($120/yr)	10,000	Hourly	Any	Yes
Enterprise	$47/mo ($470/yr)	100,000	Hourly	Any	Yes
Unlimited	$97/mo ($970/yr)	Unlimited	10 min	Any	Yes

Key things to notice:

Real-time-ish data (10-minute updates) only appears on the $97/mo tier.
Every tier is hourly except Unlimited. There is no "true real-time" tier.
The conversion endpoint is paid-only — $12/mo minimum.
Any non-USD base currency requires paid — $12/mo minimum.

What Open Exchange Rates' tiers actually cost to unlock basic features

If your product needs any of these:

Non-USD base currency (EUR, GBP, INR, AUD, etc.)
The /api/convert.json endpoint
Faster than hourly updates

...then the effective floor is:

$12/month for Developer (non-USD base, conversion endpoint, hourly updates).
$97/month for Unlimited (10-minute updates).

AllRatesToday's pricing approach

AllRatesToday bundles the features most teams need into every plan — including the free tier:

Feature	Free	Paid
Update frequency	60 seconds	60 seconds
Base currency	Any	Any
Historical data	Yes (one request per range)	Yes
Conversion endpoint	Yes	Yes
HTTPS, CORS	Yes	Yes
Official SDKs	Yes	Yes
MCP / DeepSeek	Yes	Yes

Paid tiers raise request quotas and add higher rate limits — but no core feature is gated behind them.

Dollar-for-dollar: three real scenarios

Scenario 1: European SaaS pricing display (EUR base, 5,000 lookups/month)

OpenExchangeRates requires Developer plan ($12/mo).

Free plan fails: USD-only base currency.
Developer plan: $144/year, 10,000 req/month, hourly updates, any base.

AllRatesToday covers it on the free tier.

Free plan: 300 req/month + 60-second rates. But 5,000 lookups/month exceeds the free cap.
With server-side caching (one hourly fetch serves all pageviews): 720 req/month — still over.
With 5-minute caching: 8,640 req/month — still over.
Realistic path: a paid plan sized for 5,000-10,000 req/month. For apples-to-apples, call it comparable to OXR Developer.

Verdict: similar total cost, but AllRatesToday ships 60-second updates vs OXR hourly. You pay the same and get fresher data.

Scenario 2: US e-commerce checkout (USD base, 2,000 lookups/month)

OpenExchangeRates Free works.

USD-only base is fine for a US product.
1,000 req/month limit → either cache aggressively or upgrade to Developer ($12/mo).

AllRatesToday's free tier is tight at 2,000 lookups/month.

Same deal: cache aggressively or use a small paid tier.

Verdict: OXR Free is cheaper here if you can fit in 1,000 req/month and don't care about hourly vs 60-second. Otherwise costs are similar.

Scenario 3: Analytics dashboard with year-to-date historical (1 year × 5 pairs, reloaded 50x/day)

OpenExchangeRates:

time-series.json counts 1 request per day returned.
365 days × 5 pairs × 50 loads/day × 30 days = 2,737,500 requests/month.
This is well beyond Unlimited's "unlimited" threshold in practice (expect throttling/pricing conversation).

AllRatesToday:

historical-rates counts 1 request per range.
5 pairs × 50 loads/day × 30 days = 7,500 requests/month.

Verdict: 365x less quota consumption for the same user experience.

Per-feature cost rollup

For each feature, here's the minimum monthly cost to unlock it:

Feature	OpenExchangeRates	AllRatesToday
60-second rate updates	Not available at any tier	Free
10-minute rate updates	$97/mo	Free
Hourly updates	Free	Free
Non-USD base currency	$12/mo	Free
Conversion endpoint	$12/mo	Free
Historical time-series (365 days)	$0 at 365 reqs or $12/mo for comfort	Free (1 request)
Official SDK	Not available	Free
MCP server	Not available	Free

When Open Exchange Rates' pricing is competitive

You're building a USD-only product (US e-commerce, US SaaS, US fintech).
Hourly data is acceptable.
You don't need the conversion endpoint.
You already have an Open Exchange Rates integration and churn isn't worth a few dollars saved.

When AllRatesToday is the clear price winner

Any product whose home currency isn't USD.
Anything where fresher-than-hourly data matters.
Analytics/dashboards that pull historical ranges.
Teams that use AI coding assistants and want MCP integration.

Get your free AllRatesToday API key — every feature unlocked, 60-second rates, any base currency, and historical data, at $0. No credit card required.

Open Exchange Rates Conversion Endpoint Is Paid-Only: How AllRatesToday Handles Currency Conversion

Madhushan — Tue, 21 Apr 2026 19:36:48 +0000

Open Exchange Rates Conversion Endpoint Is Paid-Only

Open Exchange Rates has a dedicated conversion endpoint — GET /api/convert/{value}/{from}/{to} — that returns the converted amount in one call. Convenient, except for one thing: it's paid plans only.

Call it on the free tier and you get:

{
  "error": true,
  "status": 403,
  "message": "not_allowed",
  "description": "The requested feature is not available on your current plan."
}

AllRatesToday ships conversion on every plan, including the free tier — as both an API endpoint and as a one-liner in the official SDKs. This article explains the gap and the three ways to work around it (or avoid it entirely).

What the conversion endpoint does

Both providers expose something equivalent to: "convert 1,000 USD to EUR, return the amount."

Open Exchange Rates (Developer plan and up):

GET https://openexchangerates.org/api/convert/1000/USD/EUR?app_id=YOUR_APP_ID

Returns:

{
  "request": { "query": "/convert/1000/USD/EUR", "amount": 1000, "from": "USD", "to": "EUR" },
  "meta": { "timestamp": 1713702122, "rate": 0.9234 },
  "response": 923.4
}

AllRatesToday (every plan):

Via SDK:

const result = await client.convert('USD', 'EUR', 1000);
// { from: 'USD', to: 'EUR', amount: 1000, rate: 0.9234, result: 923.4 }

Via HTTP:

GET https://allratestoday.com/api/v1/convert?source=USD&target=EUR&amount=1000
Authorization: Bearer YOUR_API_KEY

Why the conversion endpoint matters

You can always fetch the rate and multiply in application code. That's what OXR free-tier users end up doing. So why is a dedicated endpoint useful?

Three reasons:

One round trip instead of two. Some apps fetch rates only when they need to convert a specific amount.
Consistent rounding. Server-side conversion uses a canonical multiplication, avoiding floating-point drift between clients.
Clean call sites. convert(amount, from, to) reads more clearly than a rate fetch followed by a multiplication.

For a checkout flow, an invoicing system, or a remittance quote, this is the natural shape.

How to work around the OXR free-tier lock

If you're on Open Exchange Rates' free tier and need conversion, you have three options:

Option 1: Fetch rate, multiply client-side

async function convertOXR(amount, from, to) {
  // Note: free tier is USD-base only, so if `from !== 'USD'` you need cross-rate math
  const res = await fetch(`https://openexchangerates.org/api/latest.json?app_id=${APP_ID}&symbols=${to}`);
  const data = await res.json();
  const rate = data.rates[to];
  return amount * rate;
}

Downsides: two issues compound here — no conversion and USD-only base. For non-USD sources, you end up with cross-rate inversions.

Option 2: Upgrade to Developer plan

$12/month unlocks conversion along with non-USD base and a larger quota. If that's the only feature you need, it's an expensive upgrade.

Option 3: Switch to AllRatesToday

Free tier, conversion endpoint included, no upgrade required.

import AllRatesToday from '@allratestoday/sdk';
const client = new AllRatesToday(process.env.ALLRATES_API_KEY);
const { result } = await client.convert('USD', 'EUR', 1000);

Where AllRatesToday's conversion shines

Multi-currency invoicing

const quote = await Promise.all([
  client.convert('USD', 'EUR', 12000),
  client.convert('USD', 'GBP', 12000),
  client.convert('USD', 'INR', 12000),
]);

console.table(quote);
// [
//   { from: 'USD', to: 'EUR', amount: 12000, rate: 0.9234, result: 11080.80 },
//   { from: 'USD', to: 'GBP', amount: 12000, rate: 0.7891, result:  9469.20 },
//   { from: 'USD', to: 'INR', amount: 12000, rate: 83.42,  result: 1001040.00 }
// ]

Cross-border checkout

const settleCurrency = 'USD';
const displayCurrency = detectUserCurrency(req);
const { result: displayPrice, rate } = await client.convert(settleCurrency, displayCurrency, productPrice);
// display: show displayPrice in displayCurrency
// settle:  record settleCurrency amount for payment processor
// audit:   log `rate` + timestamp for reconciliation

Remittance quotes

async function quoteRemittance(amount, from, to) {
  const { rate, result } = await client.convert(from, to, amount);
  const fee = computeFee(amount, from);
  return {
    sendAmount: amount,
    sendCurrency: from,
    receiveAmount: result - fee,
    receiveCurrency: to,
    rate,
    fee,
    quotedAt: new Date().toISOString(),
  };
}

What if I'm on Unlimited anyway?

If you're already paying Open Exchange Rates for Unlimited ($97/mo), you have conversion access. That's fine — the migration calculus is whether the other AllRatesToday wins (60-second updates, free historical ranges, official SDKs, MCP integration) are worth the switch.

For teams building AI-assisted applications, the MCP server alone is usually the tipping point. Your coding assistant can call convert_currency as a tool, without you writing any integration glue.

Conversion rounding: one subtle note

Both providers compute result = amount × rate server-side. Both are exposed to floating-point representation issues for very large amounts. If you're in a context where exact decimal arithmetic matters (payments, accounting), you should always round to the target currency's minor unit (usually 2 decimal places):

const { result } = await client.convert('USD', 'EUR', 1000);
const euros = Math.round(result * 100) / 100;

The conversion endpoint doesn't exempt you from doing this — it just saves the round trip.

Stop paying $12/month for a feature that should be free. Get your free AllRatesToday API key — conversion endpoint, any base currency, 60-second rates. No credit card.

Data Sources: Open Exchange Rates' Blended Feed vs AllRatesToday's Reuters + Interbank

Madhushan — Tue, 21 Apr 2026 19:36:11 +0000

Data Sources: Open Exchange Rates' Blended Feed vs AllRatesToday's Reuters + Interbank

When your product touches money, "where does the rate come from?" is a question your risk, compliance, or audit team will eventually ask. If the answer is vague, the conversation gets expensive.

Open Exchange Rates describes its data as: "collected from several reliable sources and blended together algorithmically... other sources are not currently disclosed, but providers are monitored closely and routinely checked." That's a reasonable description for a consumer-facing product. For a regulated environment, it leaves gaps.

AllRatesToday publishes its sources explicitly: Reuters (Refinitiv) and interbank market feeds. This article explains why that transparency matters, what the practical accuracy difference looks like, and when it actually affects your decision.

The two approaches

Open Exchange Rates: blended, undisclosed

From their FAQ and documentation:

Data is aggregated from multiple sources.
The specific providers are not disclosed publicly.
Providers are monitored internally.
Rates aim to be "consistent and unbiased, providing the most representative market rate possible — generally the midpoint between the most common buy/sell prices."
They note rates "are accurate enough for 99% of cases (shopping carts, personal finance, estimates, etc.)."

For most web apps, this is fine. For a regulated fintech or a public company's accounting close, the audit trail stops at "a blend."

AllRatesToday: named, publicly disclosed

Sources:

Reuters (Refinitiv) — the institutional FX data feed used by banks, asset managers, and trading desks.
Interbank market feeds — the rates at which banks transact with each other.

Same mid-market rate philosophy: no bank markup, no retail spread, just the midpoint between buy and sell in the institutional market.

Why sourcing transparency matters

Compliance and audit

SOX (US public companies): auditors ask how revenue denominated in foreign currencies was translated. "Blended from undisclosed sources" is a weak answer.
IFRS / GAAP reporting: exchange rate disclosures in financial statements often require naming the source.
SOC 2 / ISO 27001: service organization controls ask about data provenance for inputs to pricing and billing.
FX-regulated industries (remittance, payments, broker-dealer): regulators care whether your rate source is reproducible and independently verifiable.

Reuters/Refinitiv and interbank are named, industry-standard feeds. Easy to describe in an audit memo, easy to reproduce if someone asks.

Accuracy under stress

Blended feeds average out discrepancies between sources. That can be good (no single outlier dominates) or bad (a real move gets smoothed before it propagates). Reuters/Refinitiv publishes continuous intraday quotes sampled from actual interbank transactions, so the feed reflects real market activity, not a cleaned-up mid-market synthesis.

In calm markets, the two approaches produce nearly identical numbers. In volatile markets — central bank announcements, macro surprises, geopolitical events — the Reuters/interbank feed tends to move first and more sharply.

Reproducibility

If a customer disputes a rate ("you charged me at 0.923 but the market was at 0.925 at that time"), you need to point them at a source they can verify. A named feed makes that trivial; a blended feed makes it a judgment call.

When the difference doesn't matter

Price display for informational purposes ("USD/EUR is roughly 0.92 today").
Shopping carts where rates are hedged through a payment processor (the processor's rate is what actually applies).
Analytics dashboards where accuracy to within 5-10 basis points is fine.
Non-regulated use cases where no one will ever ask for source documentation.

When the difference matters

Anywhere the rate is the contractual conversion rate (remittance, cross-border invoicing, settlement).
Audited financial reporting.
Regulated industries (fintech, broker-dealer, payments).
Backtests where you want the most realistic intraday behavior.
Any case where a customer or auditor could demand source documentation.

The data-pipeline picture

OpenExchangeRates (inferred from public descriptions)

[Undisclosed Source A] ──┐
[Undisclosed Source B] ──┤
[Undisclosed Source C] ──┼──> Blending algorithm ──> latest.json (updated hourly)
[Undisclosed Source N] ──┘

Opacity: which sources, how many, what weights, what rejection rules.

AllRatesToday

Reuters (Refinitiv) FX feed ──┐
Interbank market feeds ───────┼──> Mid-market aggregation ──> /api/v1/rates (updated every 60s)

Transparency: sources named, philosophy stated (mid-market), cadence documented.

How to evaluate your own situation

Ask these questions about your use case:

Will anyone ever ask where this rate came from? (Auditor, regulator, customer, internal finance team.)
Is the rate the contractual amount? (Vs. a display-only reference.)
Does my industry have rules about FX data provenance? (Payments, remittance, insurance, broker-dealer.)
Do I need the freshest possible rate during volatile sessions? (Trading-adjacent, treasury, hedging.)

One "yes" = sourcing transparency matters enough to choose a named-feed provider. No "yes"es = blended is fine.

The practical test

Run both providers side-by-side for a month and log the delta on major pairs during volatile days (US CPI release, ECB meeting, BoJ intervention). You'll see:

Calm day: delta <5 bps most of the time.
Volatile hour: delta can reach 20-50 bps as OpenExchangeRates' hourly cadence lags the Reuters/interbank feed.

For most apps, 5 bps on a calm day doesn't matter. For any app where the rate is the contractual amount, a 30-bp gap during volatility does.

Get your free AllRatesToday API key — Reuters/Refinitiv + interbank feeds, 60-second updates, named and auditable sources. No credit card.

How to Use the AllRatesToday MCP Server with Claude Code and Cursor

Madhushan — Tue, 21 Apr 2026 19:20:39 +0000

How to Use the AllRatesToday MCP Server with Claude Code and Cursor

AI coding tools are great at writing code and explaining diffs, but they're unreliable at anything numeric and time-sensitive. Ask Claude Code "what's today's USD to EUR rate?" and you'll get a stale guess. The Model Context Protocol (MCP) fixes this by letting clients call real tools. This post walks through the AllRatesToday MCP server — what it does, how to install it in four different clients, and how to debug when something goes wrong.

What is the AllRatesToday MCP server?

It's a small npm package — @allratestoday/mcp-server — that exposes four currency tools over the MCP stdio transport. Any MCP-compatible client (Claude Code, Cursor, Claude Desktop, ChatGPT Desktop, and any custom MCP host) can call them:

Tool	API key?	Description
`get_exchange_rate`	no	Current mid-market rate between two currencies.
`get_historical_rates`	yes	Time series over 1d, 7d, 30d, or 1y.
`get_rates_authenticated`	yes	Multi-target rates with higher limits.
`list_currencies`	no	All 160+ supported currencies.

Two of the four tools (get_exchange_rate and list_currencies) work without an API key. Set ALLRATES_API_KEY for the historical and multi-target endpoints.

Prerequisites

Node.js 18 or newer. npx ships with Node and handles installing the package on first run.
An MCP-compatible client. Claude Code, Cursor (0.42+), Claude Desktop, or ChatGPT Desktop all qualify.
Optional: AllRatesToday API key — register for a free one if you need higher limits.

Install in Claude Code

claude mcp add allratestoday -- npx -y @allratestoday/mcp-server
claude mcp env allratestoday ALLRATES_API_KEY=art_live_xxxxx   # optional

Claude Code will install the package on first invocation via npx. Verify it's loaded:

claude mcp list
# should show: allratestoday  running  (4 tools)

Now open any chat and ask: "What's the USD to EUR rate right now?" Claude Code picks up the get_exchange_rate tool, calls it, and answers with the live number.

Install in Cursor

Edit ~/.cursor/mcp.json (or create a project-local .cursor/mcp.json):

{
  "mcpServers": {
    "allratestoday": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "ALLRATES_API_KEY": "art_live_xxxxx"
      }
    }
  }
}

Restart Cursor. Settings → Cursor Settings → MCP should now list "allratestoday" with a green indicator. You can toggle individual tools there if you want.

Install in Claude Desktop (and ChatGPT Desktop)

Edit the desktop client's config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
ChatGPT Desktop uses the same JSON shape in its own config — paste the block below.

{
  "mcpServers": {
    "allratestoday": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "ALLRATES_API_KEY": "art_live_xxxxx"
      }
    }
  }
}

Fully quit and reopen the app. The "Search and tools" icon should show allratestoday with four tools.

Example prompts

A few prompts that exercise each tool:

"What's 1,250 GBP in Singapore dollars?" — calls get_exchange_rate, multiplies client-side.
"Show me the trend of USD/JPY over the last 30 days." — calls get_historical_rates with period=30d.
"Get me today's rates for EUR against USD, GBP, and CHF in one call." — calls get_rates_authenticated with comma-separated targets (requires API key).
"What currencies does AllRatesToday support?" — calls list_currencies.

Debugging tool calls

If the assistant isn't calling the tool, or calls are failing, there are three quick checks.

1. Is the server actually running?

In your terminal:

npx -y @allratestoday/mcp-server
# waits on stdin — this is correct, stdio transport

Press Ctrl+C to exit. If this errors (e.g. command not found: npx), install Node 18+.

2. Send a raw `tools/list` request

MCP is JSON-RPC over stdio. You can drive it manually:

printf '%s\n' \
  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}' \
  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
  '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
  | npx -y @allratestoday/mcp-server

You'll see the handshake plus a list of all five tool schemas. If this works, the server is healthy — the problem is in the client config.

3. Check the client's MCP log

Claude Desktop writes a log you can read at:

# macOS
~/Library/Logs/Claude/mcp*.log

# Windows
%APPDATA%\Claude\logs\mcp*.log

Look for allratestoday lines. A common issue: the config's JSON is invalid (trailing comma, missing quote). The log will say so.

Do I need an API key?

Only for two of the four tools. get_exchange_rate and list_currencies call public endpoints and work without a key. get_historical_rates and get_rates_authenticated both require ALLRATES_API_KEY. Set one if you want:

Historical rate data (1d/7d/30d/1y periods).
Multi-target single-call lookups (e.g. EUR against USD + GBP + CHF).
Higher rate limits (the public endpoints have reasonable but not unlimited quotas).

A free key with 300 requests/month is available at registration — no credit card.

What about privacy?

The MCP server runs locally on your machine and talks to allratestoday.com/api directly. It doesn't log prompts, and it doesn't proxy through a third party. Source is on GitHub — you can read it end-to-end in under 15 minutes.

Related integrations

DeepSeek (Python): allratestoday-deepseek — same tools, wired into DeepSeek's function calling.
Any LLM with browsing: our /llms.txt tells them the public endpoint to call.
Every supported client: the full rundown is on the MCP landing page.

Next steps

Install the server in your preferred client (above).
Ask your assistant for a live rate — confirm it cites the number.
If you need multi-target or higher limits, grab a free API key and set ALLRATES_API_KEY.
Open an issue or PR on the repo if something's missing.

Give your AI assistant real currency data. Install in one line. Free tier with real-time rates. No credit card. Get your free API key.

AllRatesToday in Claude Code, Cursor, and DeepSeek (MCP + Tool Calling)

Madhushan — Tue, 21 Apr 2026 19:20:00 +0000

AllRatesToday in Claude Code, Cursor, and DeepSeek

If you ask ChatGPT, Claude, or DeepSeek "what's the USD to EUR rate today?", you usually get a confident-sounding hallucination. Large language models don't know this week's exchange rates — they know rough historical ranges from their training data. For anything financial, that's a problem.

Today we're shipping two integrations that fix this specifically for AllRatesToday:

An MCP server — so Claude Code, Cursor, Claude Desktop, and any other Model Context Protocol client can call our rate endpoints directly.
A DeepSeek function-calling package — a Python module that wires up real-time rates as tools for deepseek-chat and deepseek-reasoner.

Both are open source, MIT-licensed, and share the same set of tools: current rate, currency conversion, historical data, and supported-currency list. The first two work without an API key.

Why add currency tools to an AI assistant?

Three concrete use cases we've heard from users in the last month:

Invoice review. "I have an invoice in USD, my books are in EUR — what should I record this as today?" The assistant needs a real rate, not a guess.
Travel planning. "Plan a 5-day Tokyo trip for 300,000 JPY." Without a live rate, the model can't accurately translate that into your home currency.
Cross-border quotes. "Quote this SOW at $12,000 USD but show the Brazilian client a BRL figure." Same problem — requires today's mid-market rate.

In each case, the LLM is doing the hard part (understanding intent, formatting output). What it needs is a deterministic tool for the numeric step. That's what these integrations are.

The MCP server: for Claude Code, Cursor, Claude Desktop

The @allratestoday/mcp-server package implements the Model Context Protocol — a standard that lets any MCP-compatible AI client call your tools over stdio.

Install in Claude Code

claude mcp add allratestoday -- npx -y @allratestoday/mcp-server
claude mcp env allratestoday ALLRATES_API_KEY=art_live_xxxxx

Install in Cursor or Claude Desktop

Add this to your MCP config (~/.cursor/mcp.json or Claude Desktop's config file):

{
  "mcpServers": {
    "allratestoday": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": { "ALLRATES_API_KEY": "art_live_xxxxx" }
    }
  }
}

Restart the client. Your assistant now has four new tools: get_exchange_rate, get_historical_rates, get_rates_authenticated, and list_currencies. Two of them (get_exchange_rate and list_currencies) don't need a key; the other two do.

Full docs and source: allratestoday.com/mcp and github.com/cahthuranag/mcp-server.

The DeepSeek package: Python function calling

DeepSeek's Chat Completions API is OpenAI-compatible, which means the same function-calling mechanism works out of the box. The allratestoday-deepseek package ships tool schemas, an agent wrapper, and a CLI.

One-shot question

pip install allratestoday-deepseek
export DEEPSEEK_API_KEY=sk-xxxxx
allratestoday-deepseek --ask "What is 2500 USD in EUR right now?"

Library usage

from allratestoday_deepseek import DeepSeekCurrencyAgent

with DeepSeekCurrencyAgent() as agent:
    print(agent.ask("How many Japanese Yen is 500 Swiss Francs?"))

Under the hood, the agent sends your question to deepseek-chat with the tool schemas attached. If DeepSeek decides to call convert_currency, the package executes it against the AllRatesToday API and passes the JSON result back. DeepSeek then produces a final answer citing the actual rate.

If you'd rather drive the tool loop yourself (for integration into LangChain, LangGraph, or a custom orchestrator), import TOOLS and dispatch_tool and wire them in directly. See the raw example.

Full docs: allratestoday.com/deepseek.

What about ChatGPT?

ChatGPT Desktop added MCP support in late 2025, so the MCP server above works there too — same config format as Claude Desktop. For plain chatgpt.com, you can build a Custom GPT with Actions pointed at our OpenAPI spec. That's on our roadmap as an official first-party GPT; until then, our llms.txt tells any browsing-enabled LLM exactly which endpoints to call.

Under the hood: same four tools everywhere

Whether you're using MCP, DeepSeek function calling, or the raw REST API, the operations are the same:

Tool	Endpoint	API key?
`get_exchange_rate`	`GET /api/rate?source=X&target=Y`	no
`convert_currency`	(rate × amount, client-side)	no
`get_historical_rates`	`GET /api/historical-rates`	yes
`get_rates_authenticated`	`GET /api/v1/rates`	yes
`list_currencies`	`GET /api/v1/symbols`	no

All rates are mid-market, sourced from Reuters (Refinitiv) and interbank market feeds. 160+ currencies supported.

Licensing & contributions

Both packages are MIT-licensed. Issues and pull requests are welcome:

github.com/cahthuranag/mcp-server — MCP server
github.com/cahthuranag/allratestoday-deepseek — DeepSeek integration

If you build something on top of these — a custom agent, a Slack bot, a trading notebook — we'd love to hear about it.

Real currency data in your AI stack. Free tier with 300 requests per month. No credit card required. Get your free API key.

DEV Community: Madhushan

AllRatesToday vs Open Exchange Rates: The 2026 Exchange Rate API Comparison

AllRatesToday vs Open Exchange Rates: The 2026 Exchange Rate API Comparison

TL;DR — Side-by-side

Update frequency: real-time vs hourly

Base currency: USD-only is a 2012-era constraint

Historical data: watch the quota burn

Conversion: free vs paid

Official SDKs

Data source transparency

When Open Exchange Rates is still the right call

When AllRatesToday is the better choice

Migration is a one-afternoon job

Why Open Exchange Rates' USD-Only Base Currency Is a Problem (And How AllRatesToday Fixes It)

Why Open Exchange Rates' USD-Only Base Currency Is a Problem

What "USD-only base" means in practice

The workarounds (and what each costs you)

How AllRatesToday handles it

Who this actually affects

Multi-base queries in one call

The bigger picture

Open Exchange Rates Hourly Updates vs AllRatesToday's 60-Second Real-Time Feed

Open Exchange Rates Hourly Updates vs AllRatesToday's 60-Second Real-Time Feed

The update cadence, plan by plan

"Real-time" is a loaded word. Here's the reality.

Concrete cost: a mid-size e-commerce checkout

Where hourly data is actually fine

Where hourly data hurts

How AllRatesToday delivers 60-second rates

Rate limits aren't the bottleneck. Data is.

Migration: one URL swap

No Official SDKs on Open Exchange Rates: AllRatesToday's JavaScript, Python, and PHP Libraries

No Official SDKs on Open Exchange Rates: AllRatesToday's JavaScript, Python, and PHP Libraries

What "no official SDK" means

AllRatesToday's official SDKs

JavaScript / TypeScript

Python

PHP

The same task in raw HTTP (what you'd write against Open Exchange Rates)

MCP and DeepSeek: AI-coding-tool integrations

When community libraries are fine

When you want an official SDK

Open Exchange Rates Free Plan vs AllRatesToday Free Tier: What You Actually Get

Open Exchange Rates Free Plan vs AllRatesToday Free Tier: What You Actually Get

Side-by-side feature matrix

Request quota: the number everyone looks at

Update frequency: 60x difference

Base currency: USD-only is a wall

Historical data: quota-friendly vs quota-burning

Conversion endpoint: free vs paid

SDKs and AI integrations

When to pick each free tier

The bigger picture

Open Exchange Rates Time-Series Burns Your Quota: AllRatesToday's Historical Rates Explained

Open Exchange Rates Time-Series Burns Your Quota

The quota model

OpenExchangeRates time-series.json

AllRatesToday historical-rates

Concrete scenarios

Why the pricing model exists

When per-day billing is fine

When range-based pricing matters

AllRatesToday historical endpoint, in detail

Migrating a time-series query

What if you still need per-day granularity?

Migrating from Open Exchange Rates to AllRatesToday: A Developer's Guide

Migrating from Open Exchange Rates to AllRatesToday: A Developer's Guide

Before you start

Endpoint-by-endpoint mapping

1. Latest rates

2. Specific currency pair

3. Non-USD base currency

4. Historical rate for a specific date

5. Time-series / range historical

6. Currency conversion

7. List of supported currencies

Authentication difference

SDK drop-in replacements

JavaScript / TypeScript

Python

OpenExchangeRates `time-series.json`

AllRatesToday `historical-rates`

2. Send a raw `tools/list` request