DEV Community: Chathuranga Basnayaka

How to Handle Base Currency Conversion in Your App

Chathuranga Basnayaka — Thu, 09 Apr 2026 13:49:30 +0000

"How do I convert from EUR to GBP if my API only supports USD as the base currency?" This question appears in nearly every exchange rate API support forum. It is one of the most common developer pain points — and it is entirely avoidable with the right API or the right code.

The Base Currency Problem

Most exchange rate APIs return rates relative to a base (source) currency. When you call GET /rates?base=USD, you get:

{
  "base": "USD",
  "rates": {
    "EUR": 0.9234,
    "GBP": 0.7891,
    "JPY": 151.42
  }
}

This tells you how much 1 USD buys in each currency. But what if your users are in Europe and you need EUR to GBP?

The catch: Many free API plans lock the base currency to USD. Changing the base to EUR, GBP, or any other currency requires a paid upgrade.

API	Free Base Currency	Any Base Currency
AllRatesToday	Any currency	All plans
Open Exchange Rates	USD only	Developer plan ($12/mo)
Fixer.io	EUR only	Basic plan ($10/mo)
CurrencyAPI	USD only	Pro plan

The Easy Way: Use an API That Supports Any Base

With AllRatesToday, just change the source parameter:

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

# INR as base
curl "https://allratestoday.com/api/v1/rates?source=INR&target=AUD" \
  -H "Authorization: Bearer YOUR_API_KEY"

This works on all plans, including the free tier.

The Manual Way: Cross-Rate Calculation

If you are stuck with a USD-locked API, you can calculate cross-rates yourself:

Cross-rate formula: A/B = USD_rate_B / USD_rate_A

Example: EUR to GBP

Given USD-based rates:

USD/EUR = 0.9234
USD/GBP = 0.7891

Cross-rate: EUR/GBP = 0.7891 / 0.9234 = 0.8546

So 1 EUR = 0.8546 GBP.

JavaScript Implementation

function crossRate(usdRates, from, to) {
  if (from === 'USD') return usdRates[to];
  if (to === 'USD') return 1 / usdRates[from];
  return usdRates[to] / usdRates[from];
}

const usdRates = {
  EUR: 0.9234,
  GBP: 0.7891,
  JPY: 151.42,
  INR: 83.45,
  AUD: 1.5312
};

console.log('EUR to GBP:', crossRate(usdRates, 'EUR', 'GBP'));  // 0.8546
console.log('GBP to JPY:', crossRate(usdRates, 'GBP', 'JPY'));  // 191.89
console.log('INR to AUD:', crossRate(usdRates, 'INR', 'AUD'));   // 0.01835

Python Implementation

def cross_rate(usd_rates: dict, source: str, target: str) -> float:
    """Calculate cross-rate from USD-based rates."""
    if source == "USD":
        return usd_rates[target]
    if target == "USD":
        return 1 / usd_rates[source]
    return usd_rates[target] / usd_rates[source]


usd_rates = {
    "EUR": 0.9234,
    "GBP": 0.7891,
    "JPY": 151.42,
    "INR": 83.45,
    "AUD": 1.5312,
}

print(f"EUR to GBP: {cross_rate(usd_rates, 'EUR', 'GBP'):.4f}")  # 0.8546
print(f"GBP to JPY: {cross_rate(usd_rates, 'GBP', 'JPY'):.2f}")  # 191.89

The Rounding Problem

// Wrong: floating-point precision issues
const amount = 1999.99;
const rate = 0.9234;
const result = amount * rate;  // 1846.7907659999998

// Right: round to the target currency's decimal places
function convertAmount(amount, rate, decimals = 2) {
  return Number((amount * rate).toFixed(decimals));
}

console.log(convertAmount(1999.99, 0.9234));      // 1846.79
console.log(convertAmount(1999.99, 151.42, 0));    // 302840 (JPY has 0 decimals)

Currency decimal places: Most currencies use 2 decimal places, but JPY, KRW, VND use 0. BHD, KWD, OMR use 3. Always round correctly for the target currency.

Using the AllRatesToday SDK

The SDK handles base currency and conversion in a single call:

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');

// Direct conversion — any base currency, any target
const result = await client.convert('EUR', 'GBP', 5000);
console.log(`5,000 EUR = ${result.result} GBP`);

// Get rate for any pair directly
const rate = await client.getRate('INR', 'AUD');
console.log(`1 INR = ${rate} AUD`);

Summary

The base currency is the reference point for all rates in an API response.
Many free API plans lock you to USD — forcing manual cross-rate math.
Cross-rate formula: A/B = USD_rate_B / USD_rate_A
Always round to the correct decimal places for the target currency.
The easiest solution: use an API that supports any base currency on all plans.

AllRatesToday supports all 160+ currencies as the source — even on the free tier. No cross-rate workarounds needed.

Get your free API key | Documentation | GitHub

How to Cache Exchange Rates and Avoid Rate Limit Errors

Chathuranga Basnayaka — Thu, 09 Apr 2026 13:48:40 +0000

You integrated an exchange rate API, deployed to production, and then hit HTTP 429: Rate limit exceeded. This is the most common operational issue developers face with exchange rate APIs — and it is entirely preventable with proper caching.

Why You Need to Cache Exchange Rates

Exchange rates don't change every millisecond. Even "real-time" APIs like AllRatesToday update every 60 seconds. Fetching the same rate on every page load is wasteful and will quickly exhaust your quota.

Consider a simple e-commerce site with 10,000 daily visitors:

Without caching: 10,000 API calls/day = 300,000/month. You'll need a Large plan.
With 5-minute cache: 288 API calls/day = 8,640/month. A Small plan covers it.
With 1-hour cache: 24 API calls/day = 720/month. The Free tier is enough.

The math: If your API updates every 60 seconds, caching for 5 minutes means you are at most 4 minutes behind — which is perfectly acceptable for price displays and most applications.

Choosing Your Cache Duration (TTL)

Use Case	Recommended TTL	Why
Trading / Forex	No cache or 1–5s	Every second counts
Payment checkout	30–60 seconds	Rate should be current at time of charge
E-commerce price display	1–5 minutes	Visitors tolerate slight delays
Dashboard / analytics	5–15 minutes	Refresh rates match dashboard refresh
Invoicing / billing	1–24 hours	Rate is locked at invoice generation
Accounting reports	24 hours	End-of-day rates are standard

Strategy 1: Simple In-Memory Cache (JavaScript)

No dependencies needed:

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');
const cache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

async function getRate(source, target) {
  const key = `${source}_${target}`;
  const cached = cache.get(key);

  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.rate;
  }

  const rate = await client.getRate(source, target);
  cache.set(key, { rate, timestamp: Date.now() });
  return rate;
}

// Only hits the API once per 5 minutes per currency pair
const rate1 = await getRate('USD', 'EUR');  // API call
const rate2 = await getRate('USD', 'EUR');  // Served from cache

Strategy 2: Simple In-Memory Cache (Python)

import time
from allratestoday import AllRatesToday

client = AllRatesToday("YOUR_API_KEY")
_cache = {}
CACHE_TTL = 300  # 5 minutes

def get_rate(source: str, target: str) -> float:
    key = f"{source}_{target}"
    cached = _cache.get(key)

    if cached and time.time() - cached["timestamp"] < CACHE_TTL:
        return cached["rate"]

    rate = client.get_rate(source, target)
    _cache[key] = {"rate": rate, "timestamp": time.time()}
    return rate

Strategy 3: Stale-While-Revalidate

The best strategy for production. Serve cached (possibly stale) data immediately, refresh in the background. Users never wait for an API call.

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');
const cache = new Map();
const FRESH_TTL = 60 * 1000;       // Fresh for 1 minute
const STALE_TTL = 10 * 60 * 1000;  // Serve stale up to 10 minutes
const refreshing = new Set();

async function getRate(source, target) {
  const key = `${source}_${target}`;
  const cached = cache.get(key);
  const now = Date.now();

  if (cached) {
    const age = now - cached.timestamp;

    if (age < FRESH_TTL) {
      return cached.rate; // Fresh
    }

    if (age < STALE_TTL) {
      // Stale but usable — refresh in background
      if (!refreshing.has(key)) {
        refreshing.add(key);
        client.getRate(source, target)
          .then(rate => cache.set(key, { rate, timestamp: Date.now() }))
          .finally(() => refreshing.delete(key));
      }
      return cached.rate;
    }
  }

  // No cache or expired
  const rate = await client.getRate(source, target);
  cache.set(key, { rate, timestamp: now });
  return rate;
}

Why this works: Exchange rates don't jump dramatically in 10 minutes. Serving a 5-minute-old rate instantly is better than making your user wait 200ms for a rate that's 0.01% more accurate.

Strategy 4: Redis Cache (High-Traffic Apps)

For multi-instance applications, use Redis to share a cache:

import AllRatesToday from '@allratestoday/sdk';
import Redis from 'ioredis';

const client = new AllRatesToday('YOUR_API_KEY');
const redis = new Redis(process.env.REDIS_URL);
const CACHE_TTL = 300; // 5 minutes

async function getRate(source, target) {
  const key = `exchange_rate:${source}:${target}`;

  const cached = await redis.get(key);
  if (cached) return parseFloat(cached);

  const rate = await client.getRate(source, target);
  await redis.setex(key, CACHE_TTL, rate.toString());
  return rate;
}

Strategy 5: Batch Prefetch

If you know which currencies you need, fetch them all on a schedule:

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');
let ratesCache = {};

const CURRENCIES = ['EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CHF', 'INR'];

async function refreshAllRates() {
  try {
    const allRates = await client.getRates('USD');
    const rates = {};
    for (const currency of CURRENCIES) {
      rates[`USD_${currency}`] = allRates[currency];
    }
    rates.lastUpdated = Date.now();
    ratesCache = rates;
  } catch (err) {
    console.error('Refresh failed, keeping stale cache:', err.message);
  }
}

refreshAllRates();
setInterval(refreshAllRates, 5 * 60 * 1000);

// Synchronous access — no await needed
function getRate(source, target) {
  return ratesCache[`${source}_${target}`];
}

Request math: 1 API call per 5 minutes = 288 calls/day = 8,640/month. Serves unlimited concurrent users.

Common Mistakes to Avoid

Fetching on every request: The #1 cause of rate limit errors. Always cache.
Client-side API calls: Never expose your API key in frontend JavaScript. Fetch server-side and proxy.
Cache per user: Exchange rates are the same for everyone. Use a global cache.
Ignoring cache stampede: When cache expires, 100 concurrent requests all hit the API. Use stale-while-revalidate or a lock.

Security: Never call the exchange rate API directly from the browser. Your API key will be visible in the network tab. Always proxy through your backend.

Summary

Strategy	Best For	Complexity
Simple TTL cache	Small apps, single server	Low
Stale-while-revalidate	User-facing apps needing instant response	Medium
Redis cache	Multi-instance / high-traffic	Medium
Batch prefetch	Known currency set, predictable traffic	Low

AllRatesToday — 60-second updates, 160+ currencies, official SDKs. Start with 300 free requests/month — plenty for a cached application.

Get your free API key | Documentation | GitHub

The Best Free Currency Exchange Rate API in 2026

Chathuranga Basnayaka — Thu, 09 Apr 2026 13:26:36 +0000

If you need exchange rate data in your application, your options range from free-with-caveats to expensive-with-everything. Most developers start by searching "free currency API" and end up with a service that caps at 100 requests per month, requires a credit card for signup, or returns stale data cached from yesterday. Then they outgrow it, switch to a paid service, and rewrite their integration.

This article compares the major free currency exchange APIs available in 2026 and explains why AllRatesToday is the best option for most use cases: real-time mid-market rates for 160+ currencies, sourced from Reuters (Refinitiv) and interbank market feeds, with official SDKs and a generous free tier.

Comparing Free Currency APIs in 2026

API	Free Tier	Currencies	Update Frequency	Credit Card
AllRatesToday	300 req/month	160+	Real-time (60s)	No
ExchangeRate-API	1,500 req/month	160+	Daily	Yes (for upgrades)
Open Exchange Rates	1,000 req/month	170+	Hourly	Yes
Frankfurter	Unlimited	30+	Daily (ECB)	No
CurrencyAPI	300 req/month	170+	Daily	Yes
Fixer.io	100 req/month	170+	Daily	Yes
AbstractAPI	1,000 req/month	150+	Daily	Yes

The key differentiators for AllRatesToday: real-time rates updated every 60 seconds (not daily), mid-market rates sourced from Reuters/Refinitiv, official SDKs for three languages, and no credit card required to get started.

Getting Started in 30 Seconds

Sign up at allratestoday.com/register to get your free API key. No credit card required. The free tier includes 300 requests/month across all endpoints.

Fetch exchange rates

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

Response:

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

Historical rates

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

Historical rates are useful for financial reporting, tax calculations, and charting exchange rate trends over time.

Official SDKs

Unlike most currency APIs that leave you writing raw HTTP calls, AllRatesToday provides official SDKs for the three most popular server-side languages.

JavaScript / TypeScript

npm install @allratestoday/sdk

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');

// Get a single rate
const rate = await client.getRate('USD', 'EUR');
console.log(`1 USD = ${rate} EUR`);

// Convert an amount
const result = await client.convert('USD', 'EUR', 1000);
console.log(`$1,000 = €${result.result}`);

// Historical rates
const history = await client.getHistoricalRates('USD', 'EUR', '30d');
history.rates.forEach(point => {
  console.log(`${point.time}: ${point.rate}`);
});

npm: @allratestoday/sdk — View on GitHub

Python

pip install allratestoday

from allratestoday import AllRatesToday

client = AllRatesToday("YOUR_API_KEY")

# Get exchange rate
rate = client.get_rate("USD", "EUR")
print(f"1 USD = {rate} EUR")

# Convert amount
result = client.convert("USD", "EUR", 1000)
print(f"$1,000 = €{result['result']}")

# Historical rates
history = client.get_historical_rates("USD", "EUR", "30d")
for point in history["rates"]:
    print(f"{point['time']}: {point['rate']}")

PyPI: allratestoday — View on GitHub

PHP

composer require allratestoday/sdk

use AllRatesToday\AllRatesToday;

$client = new AllRatesToday('YOUR_API_KEY');

// Get exchange rate
$rate = $client->getRate('USD', 'EUR');
echo "1 USD = {$rate[0]['rate']} EUR\n";

// Convert amount
$result = $client->convert('USD', 'EUR', 100);
echo "$100 = €{$result['result']}\n";

// Historical rates
$history = $client->getHistoricalRates('USD', 'EUR', '30d');
foreach ($history['rates'] as $point) {
    echo "{$point['time']}: {$point['rate']}\n";
}

Packagist: allratestoday/sdk — View on GitHub

React Price Display Component

A drop-in React component that shows prices in multiple currencies:

import { useState, useEffect } from 'react';
import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('YOUR_API_KEY');

function useExchangeRate(from, to) {
  const [rate, setRate] = useState(null);

  useEffect(() => {
    client.getRate(from, to).then(setRate);
  }, [from, to]);

  return rate;
}

function PriceDisplay({ amount, from, to }) {
  const rate = useExchangeRate(from, to);

  if (!rate) return <span>Loading...</span>;

  return (
    <span>
      {(amount * rate).toFixed(2)} {to}
    </span>
  );
}

// Usage: <PriceDisplay amount={99.99} from="USD" to="EUR" />

Why AllRatesToday Over Other APIs?

Real-time rates: Updated every 60 seconds from Reuters/Refinitiv and interbank feeds. Most free APIs only update once daily from the ECB.
Mid-market rates: The true exchange rate between currencies, without any bank markup. This is the rate financial professionals reference.
160+ currencies: Major, minor, and exotic currency pairs. Far more than the 30 currencies offered by ECB-only services like Frankfurter.
Official SDKs: Production-ready libraries for JavaScript, Python, and PHP. Install from npm, PyPI, or Packagist and start coding in minutes.
Historical data: Access historical exchange rates for charting, reporting, and reconciliation.
No credit card: The free tier requires no payment information. Upgrade only when you need to.

Data Source and Accuracy

AllRatesToday sources its exchange rates from Reuters (Refinitiv) and interbank market feeds via the Wise (TransferWise) infrastructure. These are mid-market rates — the real exchange rate between currencies before any bank markup is applied.

This is the same data used by financial institutions and platforms like Google Finance, XE, and Bloomberg for their rate displays.

Pricing

Plan	Requests/Month	Price
Free	300	Free
Small	5,000	€4.99/mo
Medium	10,000	€9.99/mo
Large	100,000	€49.99/mo

Quick Reference

Get rates: GET /api/v1/rates?source=USD&target=EUR
Historical: GET /api/historical-rates?source=USD&target=EUR&from=2026-01-01&to=2026-03-31
Auth: Authorization: Bearer YOUR_API_KEY
SDKs: npm install @allratestoday/sdk | pip install allratestoday | composer require allratestoday/sdk
GitHub: allratestoday/exchange-rates-api
Register (Free): allratestoday.com/register
Docs: allratestoday.com/developers