DEV Community: Madhushan

Exchange Rate API in Claude Code, Cursor, and DeepSeek (MCP + Tool Calling) — Exchange Rate API

Madhushan — Thu, 28 May 2026 08:50:28 +0000

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 Exchange Rate API:

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 @exchangerateapi/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 exchangerateapi -- npx -y @exchangerateapi/mcp-server
claude mcp env exchangerateapi EXCHANGERATE_API_KEY=your_key_here

Install in Cursor or Claude Desktop

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

{
  "mcpServers": {
    "exchangerateapi": {
      "command": "npx",
      "args": ["-y", "@exchangerateapi/mcp-server"],
      "env": { "EXCHANGERATE_API_KEY": "your_key_here" }
    }
  }
}

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: exchange-rateapi.com/mcp and github.com/Exchange-RateAPI/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 exchange-rateapi-deepseek package ships tool schemas, an agent wrapper, and a CLI.

One-shot question

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

Library usage

from exchange_rateapi_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 Exchange Rate 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: exchange-rateapi.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/Exchange-RateAPI/mcp-server -- MCP server
github.com/Exchange-RateAPI/exchange-rateapi-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.

Start building in seconds

npm install @exchangerateapi/sdk

ExchangeRate-API Alternative: Why Developers Are Switching in 2026

Madhushan — Thu, 28 May 2026 08:49:54 +0000

ExchangeRate-API (exchangerate-api.com) is one of the most popular free currency APIs on the web. It's simple, it works, and the free tier is generous at 1,500 requests per month. But as your project grows past a prototype, you start hitting real limitations: daily-only updates, no official SDKs, and no path to real-time data at any price.

This article is an honest, feature-by-feature comparison of ExchangeRate-API vs Exchange Rate API (exchange-rateapi.com) so you can decide which fits your use case.

Feature-by-Feature Comparison

Feature	ExchangeRate-API	Exchange Rate API
Update Frequency	Once per day	Every 60 seconds (paid) / daily (free)
Free Tier	1,500 req/month	300 req/month (real-time capable)
Official SDKs	None	JavaScript, Python, PHP, Java
Base Currency	Any (paid plans)	Any (all plans)
HTTPS	All plans	All plans (including free)
Historical Rates	Paid only	Free tier included
Currencies	161	160+
Data Source	Open-access aggregation	Reuters / Refinitiv
Starting Price	$9.99/mo	€4.99/mo

Update Frequency: Daily vs 60-Second

This is the single biggest difference. ExchangeRate-API updates all rates once per day , regardless of which plan you're on. That's fine for invoicing workflows where yesterday's rate is acceptable, but it's a dealbreaker for:

E-commerce checkout where customers see stale prices
Payment processing where a day-old rate creates margin risk
Trading dashboards where users expect near-live data
Multi-currency SaaS where pricing needs to reflect current markets

Exchange Rate API refreshes rates every 60 seconds from Reuters/Refinitiv on paid tiers. Even on the free tier, you get daily rates sourced from the same institutional feed.

Free Tier: Quantity vs Quality

ExchangeRate-API's free tier gives you 1,500 requests per month. That sounds generous compared to Exchange Rate API's 300. But consider what you get per request:

ExchangeRate-API Free : Daily rates, open-access data, no historical, limited endpoints
Exchange Rate API Free : Daily rates from Reuters/Refinitiv, historical rates included, any base currency, HTTPS

If you're building something that needs to go beyond a demo, the data quality and historical access in Exchange Rate API's free tier gives you a much stronger foundation to build on.

SDKs: Build Faster with Official Libraries

ExchangeRate-API doesn't provide official SDKs. You write raw HTTP calls and parse JSON yourself. Exchange Rate API ships official SDKs for the four most popular server-side languages:

JavaScript / Node.js

import ExchangeRateAPI from '@exchangerateapi/sdk';

const client = new ExchangeRateAPI('YOUR_API_KEY');
const rate = await client.getRate('USD', 'EUR');
console.log(rate); // 0.9142

Python

from exchangerateapi import Client

client = Client("YOUR_API_KEY")
rate = client.get_rate("USD", "EUR")
print(rate)  # 0.9142

Official SDKs mean type safety, automatic retries, built-in error handling, and no time wasted writing boilerplate HTTP code.

Base Currency Flexibility

ExchangeRate-API limits base currency selection on the free plan. Exchange Rate API lets you use any of its 160+ currencies as a base on every plan, including free. This matters if your users are in countries outside the USD/EUR mainstream and you need rates relative to BRL, INR, or NGN.

Data Source Quality

ExchangeRate-API aggregates from open-access sources. Exchange Rate API sources from Reuters/Refinitiv , the same institutional feed used by banks and financial platforms like XE. For most developer use cases the difference is negligible on major pairs (USD, EUR, GBP), but it can matter on exotic currencies where open-access sources have wider spreads.

When ExchangeRate-API Is Still a Good Choice

You're building a hobby project and need the highest free request count
Daily updates are genuinely sufficient for your use case
You prefer ExchangeRate-API's simpler endpoint structure
You don't need historical data or SDKs

When to Switch to Exchange Rate API

You need real-time (60-second) updates
You want official SDKs for faster integration
You need historical rates (included free)
You care about institutional-grade data sourcing
You're building a production SaaS, e-commerce, or fintech product

Migration Is Simple

Switching from ExchangeRate-API to Exchange Rate API takes about 10 minutes. The response format is similar JSON, and if you use the SDK, you can reduce your integration code significantly:

# Before (ExchangeRate-API, raw HTTP)

import requests

resp = requests.get("https://v6.exchangerate-api.com/v6/KEY/latest/USD")

rate = resp.json()["conversion_rates"]["EUR"]

  
  
  After (Exchange Rate API, official SDK)


from exchangerateapi import Client

client = Client("YOUR_API_KEY")

rate = client.get_rate("USD", "EUR")

FAQ

Is ExchangeRate-API free?

Yes, ExchangeRate-API offers a free tier with 1,500 requests per month. However, rates are updated only once per day and historical data is not included. For real-time rates, paid plans start at $9.99/month.

What is the best alternative to ExchangeRate-API?

Exchange Rate API (exchange-rateapi.com) is the top alternative for developers who need real-time updates, official SDKs, and historical data. Plans start at just €4.99/month with 60-second refresh rates.

Does ExchangeRate-API support real-time rates?

No. ExchangeRate-API updates rates once per day on all plans, including paid tiers. If you need real-time (60-second) updates, Exchange Rate API provides them starting on its lowest paid tier.

Ready to upgrade from daily rates to real-time? Get a free Exchange Rate API key and start integrating in minutes.

Get started in seconds

npm install @exchangerateapi/sdk

How to Use Exchange Rate APIs with AI Agents, LLMs, and Chatbots

Madhushan — Thu, 28 May 2026 08:49:34 +0000

How to Use Exchange Rate APIs with AI Agents, LLMs, and Chatbots

Large language models are increasingly embedded in products that require accurate, real-time data. When a user asks a chatbot "How much is 500 EUR in Japanese yen right now?" the model cannot answer from its training data alone. Training corpora are months or years out of date, and exchange rates change every few seconds during market hours. The model needs a live data source.

An exchange rate API solves this problem. It gives AI agents, LLMs, and chatbots a structured way to fetch current and historical currency data on demand, turning a hallucination-prone guess into a precise, timestamped answer.

This guide covers three integration approaches -- MCP servers, function calling (tool use), and direct API injection -- with working code examples for each. All examples use the Exchange Rate API, which returns JSON, supports 160+ currencies, and provides a free tier with 1,500 requests per month.

Why AI Agents Need Real-Time Exchange Rates

LLMs have a fundamental limitation when it comes to financial data: their training data is static. A model trained in early 2025 has no idea what the USD/EUR rate is today, and even if it memorizes a rate from its training set, that number is almost certainly wrong by now.

This matters for several reasons:

Accuracy expectations are high. Users asking about money expect precise answers. A chatbot that says "1 USD is approximately 0.85 EUR" when the actual rate is 0.92 will lose trust immediately.
Exchange rates are volatile. Major currency pairs can move 1-2% in a single day during periods of economic uncertainty. Emerging market currencies can swing much more.
Financial decisions depend on correct data. Whether a user is sending a remittance, pricing a product for international customers, or analyzing a portfolio, stale rates lead to real financial consequences.
Compliance and audit trails. Applications in fintech, e-commerce, and accounting often need to record the exact rate used for a transaction, along with its timestamp and source.

An exchange rate API provides the missing link between the LLM's reasoning capabilities and the live data it needs to answer currency questions correctly.

Three Integration Approaches

Approach	Best For	Complexity
MCP Servers	Claude Code, Cursor, AI IDEs	Low
Function Calling / Tool Use	OpenAI, Anthropic, custom agents	Medium
RAG / Direct API Calls	Custom chatbots, pipelines	Medium

Approach 1: MCP Servers (Model Context Protocol)

What Is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI applications connect to external data sources and tools through a unified interface. Think of MCP as a USB port for AI tools. Once a data source exposes an MCP server, any MCP-compatible client -- Claude Code, Cursor, Windsurf, or a custom application -- can connect to it without custom integration code.

An MCP server exposes tools (functions the AI can call), resources (data the AI can read), and prompts (reusable templates). For exchange rates, the tools are the important part: they let the AI fetch live rates, convert amounts, and look up historical data by calling the API on behalf of the user.

The Exchange Rate API MCP Server

The Exchange Rate API provides an official MCP server as an npm package: @allratestoday/mcp-server. It exposes tools for fetching latest rates, converting currencies, retrieving historical rates, and querying time-series data. Authentication, request formatting, and response parsing are all handled internally.

Setting Up in Claude Code

Add the MCP server to your project's .mcp.json configuration file:

{
  "mcpServers": {
    "exchange-rates": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "EXCHANGE_RATE_API_KEY": "era_live_your_api_key_here"
      }
    }
  }
}

Once configured, Claude Code can directly answer questions like "What is the current USD to EUR rate?", "Convert 1000 GBP to INR", or "Show me how the EUR/JPY rate changed over the last 30 days." The AI automatically selects the right tool, calls the MCP server, and formats the response. No additional code is required.

Setting Up in Cursor

For Cursor, create a .cursor/mcp.json file in your project root with the same configuration:

{
  "mcpServers": {
    "exchange-rates": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "EXCHANGE_RATE_API_KEY": "era_live_your_api_key_here"
      }
    }
  }
}

The setup is identical because both tools follow the MCP standard. Write one server, use it everywhere.

Setting Up in Claude Desktop

Edit the configuration file at ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows) with the same mcpServers block shown above. After restarting Claude Desktop, the exchange rate tools will appear in the tools menu automatically.

Approach 2: Function Calling / Tool Use

Function calling (also called tool use) is the most common way to integrate external APIs with LLMs programmatically. You define a set of tools with their parameters and descriptions, the model decides when to call them, and your application executes the actual API request and feeds the result back.

OpenAI Function Calling Example

import json
import requests
from openai import OpenAI

EXCHANGE_RATE_API_KEY = "era_live_your_api_key_here"
EXCHANGE_RATE_BASE_URL = "https://api.allratestoday.com/v1"

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_exchange_rate",
            "description": "Get the current exchange rate between two currencies and optionally convert an amount.",
            "parameters": {
                "type": "object",
                "properties": {
                    "base": {"type": "string", "description": "The source currency code (e.g., USD, EUR, GBP)"},
                    "target": {"type": "string", "description": "The target currency code (e.g., JPY, CAD, INR)"},
                    "amount": {"type": "number", "description": "The amount to convert. Defaults to 1."}
                },
                "required": ["base", "target"]
            }
        }
    }
]

def call_exchange_rate_api(base: str, target: str, amount: float = 1.0) -> dict:
    """Call the Exchange Rate API and return the result."""
    response = requests.get(
        f"{EXCHANGE_RATE_BASE_URL}/latest",
        params={"base": base, "symbols": target},
        headers={"Authorization": f"Bearer {EXCHANGE_RATE_API_KEY}"}
    )
    response.raise_for_status()
    data = response.json()
    rate = data["rates"][target]
    return {
        "base": base,
        "target": target,
        "rate": rate,
        "converted_amount": round(rate * amount, 4),
        "amount": amount,
        "date": data["date"]
    }

def chat_with_exchange_rates(user_message: str) -> str:
    """Send a message to the model with exchange rate tool access."""
    messages = [
        {"role": "system", "content": "You are a helpful financial assistant. Use the get_exchange_rate tool to answer currency questions with live data. Always cite the date of the rate."},
        {"role": "user", "content": user_message}
    ]

    response = client.chat.completions.create(
        model="gpt-4o", messages=messages, tools=tools, tool_choice="auto"
    )
    message = response.choices[0].message

    if message.tool_calls:
        for tool_call in message.tool_calls:
            args = json.loads(tool_call.function.arguments)
            result = call_exchange_rate_api(**args)
            messages.append(message)
            messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(result)})

        final_response = client.chat.completions.create(model="gpt-4o", messages=messages)
        return final_response.choices[0].message.content

    return message.content

print(chat_with_exchange_rates("How much is 500 euros in Japanese yen?"))

Anthropic Claude Tool Use Example

The Anthropic Messages API uses a similar pattern with a slightly different schema format:

import json
import requests
import anthropic

EXCHANGE_RATE_API_KEY = "era_live_your_api_key_here"
EXCHANGE_RATE_BASE_URL = "https://api.allratestoday.com/v1"

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_exchange_rate",
        "description": "Get the current exchange rate between two currencies and optionally convert an amount.",
        "input_schema": {
            "type": "object",
            "properties": {
                "base": {"type": "string", "description": "The source currency code (e.g., USD, EUR, GBP)"},
                "target": {"type": "string", "description": "The target currency code (e.g., JPY, CAD, INR)"},
                "amount": {"type": "number", "description": "The amount to convert. Defaults to 1."}
            },
            "required": ["base", "target"]
        }
    }
]

def call_exchange_rate_api(base: str, target: str, amount: float = 1.0) -> dict:
    response = requests.get(
        f"{EXCHANGE_RATE_BASE_URL}/latest",
        params={"base": base, "symbols": target},
        headers={"Authorization": f"Bearer {EXCHANGE_RATE_API_KEY}"}
    )
    response.raise_for_status()
    data = response.json()
    rate = data["rates"][target]
    return {"base": base, "target": target, "rate": rate, "converted_amount": round(rate * amount, 4), "date": data["date"]}

def chat_with_exchange_rates(user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]
    system = "You are a helpful financial assistant. Use the get_exchange_rate tool to answer currency questions with live data. Always cite the date of the rate."

    response = client.messages.create(
        model="claude-sonnet-4-20250514", max_tokens=1024, system=system, tools=tools, messages=messages
    )

    if response.stop_reason == "tool_use":
        tool_use_block = next(b for b in response.content if b.type == "tool_use")
        result = call_exchange_rate_api(**tool_use_block.input)

        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": [{"type": "tool_result", "tool_use_id": tool_use_block.id, "content": json.dumps(result)}]})

        final_response = client.messages.create(
            model="claude-sonnet-4-20250514", max_tokens=1024, system=system, tools=tools, messages=messages
        )
        return final_response.content[0].text

    return response.content[0].text

print(chat_with_exchange_rates("Convert 250 GBP to Indian rupees"))

Expanding to Multiple Tools

For more capable agents, define separate tools for different API endpoints:

tools = [
    {"name": "get_latest_rate", "description": "Get the current exchange rate between two currencies.", ...},
    {"name": "convert_currency", "description": "Convert a specific amount from one currency to another.", ...},
    {"name": "get_historical_rate", "description": "Get the exchange rate on a specific past date.", ...}
]

This lets the model route "What was the USD to EUR rate on January 1st?" to get_historical_rate, while "Convert 100 dollars to pounds" triggers convert_currency.

Approach 3: RAG / Direct API Calls

For custom chatbots or pipelines where you control the prompt, you can fetch exchange rate data before calling the LLM and inject it directly. This works with any model, including those without function calling support.

Python Chatbot with Exchange Rate Lookup

import requests

EXCHANGE_RATE_API_KEY = "era_live_your_api_key_here"
BASE_URL = "https://api.allratestoday.com/v1"

CURRENCY_CODES = ["USD", "EUR", "GBP", "JPY", "CAD", "AUD", "CHF", "CNY", "INR", "MXN", "BRL", "KRW"]

def detect_currencies(text: str) -> list:
    text_upper = text.upper()
    return [code for code in CURRENCY_CODES if code in text_upper]

def fetch_rates(base: str, targets: list) -> dict:
    response = requests.get(
        f"{BASE_URL}/latest",
        params={"base": base, "symbols": ",".join(targets)},
        headers={"Authorization": f"Bearer {EXCHANGE_RATE_API_KEY}"}
    )
    response.raise_for_status()
    return response.json()

def build_prompt_with_rates(user_message: str) -> str:
    currencies = detect_currencies(user_message)
    rate_context = ""

    if len(currencies) >= 2:
        base, targets = currencies[0], currencies[1:]
        rate_data = fetch_rates(base, targets)
        rate_context = f"\n\nCurrent exchange rates as of {rate_data['date']}:\n"
        for currency, rate in rate_data["rates"].items():
            rate_context += f"  1 {base} = {rate} {currency}\n"
        rate_context += "Source: Exchange Rate API (exchange-rateapi.com)\n"

    system = "You are a helpful financial assistant. Answer currency questions using the provided exchange rate data. Always mention the date and cite the source."
    return f"{system}{rate_context}\n\nUser question: {user_message}"

# Build the prompt, then send to any LLM
prompt = build_prompt_with_rates("How much is 500 EUR in JPY?")
# response = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}])

Using the Official SDKs

For cleaner code, use the official SDKs instead of raw HTTP calls:

Python:

from exchangerateapi import ExchangeRateApi

api = ExchangeRateApi(api_key="era_live_your_api_key_here")
rates = api.latest(base="USD", symbols=["EUR", "GBP", "JPY"])
result = api.convert(from_currency="EUR", to_currency="USD", amount=1000)

JavaScript:

import { ExchangeRateApi } from "@exchangerateapi/sdk";

const api = new ExchangeRateApi({ apiKey: "era_live_your_api_key_here" });
const rates = await api.latest({ base: "USD", symbols: ["EUR", "GBP", "JPY"] });
const result = await api.convert({ from: "EUR", to: "USD", amount: 1000 });

Use Cases

Customer Support Bots with Live Pricing

E-commerce companies serving international customers can embed exchange rate lookups into their support chatbots. When a customer asks "How much does this cost in my currency?", the bot fetches the live rate, calculates the localized price, and presents it alongside the original price.

Financial Analysis Assistants

AI-powered financial analysis tools can use historical exchange rate data to generate reports on currency trends, calculate cross-border investment returns adjusted for FX movements, or flag unusual rate movements.

Travel Planning Agents

Travel chatbots can answer questions like "What's a good budget for a week in Tokyo in US dollars?" by combining general knowledge with live JPY/USD rates. They can also track rate changes and notify users when a favorable rate appears.

E-Commerce Price Localization

Online stores can use AI agents to dynamically localize prices during checkout. The agent fetches the latest rate, applies a markup or rounding strategy, and presents the price in the customer's local currency -- all without hard-coding rates into the application.

Multi-Currency Accounting

Accounting teams dealing with multiple currencies can use AI agents to reconcile transactions, calculate realized gains and losses from FX movements, and generate reports that pull historical rates for each transaction date.

Best Practices

Cache Exchange Rates

Exchange rates do not change every second for most use cases. Caching rates for 5-15 minutes reduces API calls significantly without affecting accuracy. This is especially important for AI agents, where a single conversation might trigger multiple lookups.

from functools import lru_cache
from datetime import datetime

@lru_cache(maxsize=128)
def get_cached_rate(base: str, target: str, cache_key: str) -> dict:
    response = requests.get(
        f"{BASE_URL}/latest", params={"base": base, "symbols": target},
        headers={"Authorization": f"Bearer {EXCHANGE_RATE_API_KEY}"}
    )
    response.raise_for_status()
    return response.json()

def get_rate(base: str, target: str) -> dict:
    now = datetime.utcnow()
    cache_key = now.strftime("%Y-%m-%d-%H") + f"-{now.minute // 10}"
    return get_cached_rate(base, target, cache_key)

Handle Rate Limits Gracefully

The free tier provides 1,500 requests per month. For production agents, handle 429 responses with a fallback message rather than crashing:

def call_api_with_fallback(base: str, target: str) -> dict:
    try:
        response = requests.get(
            f"{BASE_URL}/latest", params={"base": base, "symbols": target},
            headers={"Authorization": f"Bearer {EXCHANGE_RATE_API_KEY}"}, timeout=10
        )
        if response.status_code == 429:
            return {"error": "rate_limited", "message": "Exchange rate data is temporarily unavailable."}
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        return {"error": "request_failed", "message": str(e)}

Request Only the Currencies You Need

Always use the symbols parameter instead of fetching all 160+ rates. This reduces payload size and response times, which matters when the API call is happening inside a tool-call loop that blocks the conversation.

Write Clear Tool Descriptions

The quality of your tool descriptions directly affects how well the model uses them:

# Weak -- the model may not know when to use this
"description": "Get exchange rates"

# Strong -- the model knows exactly when and why to call this tool
"description": "Get the current exchange rate between two currencies. Use this whenever the user asks about currency conversion, exchange rates, how much something costs in another currency, or foreign exchange prices. Returns the live mid-market rate with a timestamp."

Include Rate Metadata in Responses

Always include the date and source of the rate in the AI's response. This builds user trust and creates an audit trail. Add instructions in your system prompt:

When providing exchange rate information:
1. Always state the date the rate was retrieved
2. Mention that rates are mid-market rates from Exchange Rate API
3. Note that actual bank or payment provider rates may differ
4. For financial decisions, suggest verifying the rate at transaction time

Choosing the Right Approach

Factor	MCP Server	Function Calling	Direct API / RAG
Setup effort	Minimal (JSON config)	Moderate (code required)	Moderate (code required)
Model support	Claude, Cursor, MCP clients	OpenAI, Anthropic, most LLMs	Any LLM
User control	Low (AI decides when to call)	Medium (you define tools)	High (you control everything)
Best for	Developer tools, AI IDEs	Production chatbots, agents	Custom pipelines, batch jobs

For most production applications, function calling provides the best balance of control and ease of use. For developer-facing tools and AI-assisted coding, MCP servers are the fastest path to integration. For legacy systems or models without tool support, direct API injection works reliably.

Getting Started

Sign up for a free API key at exchange-rateapi.com. The free tier includes 1,500 requests per month.
Choose your approach based on the comparison table above.
Install the SDK if you prefer a higher-level interface:
JavaScript: npm install @exchangerateapi/sdk
Python: pip install exchangerateapi
MCP: npx -y @allratestoday/mcp-server
Start with a single tool (get_exchange_rate) and expand as needed.
Add caching before going to production to stay within rate limits and reduce latency.

Conclusion

AI agents are only as useful as the data they can access. For any application that touches international commerce, travel, or finance, real-time exchange rates are a core requirement -- not a nice-to-have. By integrating the Exchange Rate API through MCP servers, function calling, or direct API injection, you give your AI system the ability to answer currency questions accurately, with live data and proper citations.

The three approaches covered in this guide serve different needs. MCP servers offer zero-code setup for tools like Claude Code and Cursor. Function calling provides fine-grained control for production chatbots built on OpenAI or Anthropic APIs. Direct API calls work with any LLM, including open-source models running locally.

Whichever approach you choose, the principles are the same: fetch live data instead of relying on training knowledge, cache aggressively to manage costs and latency, handle errors gracefully, and always tell the user when the rate was last updated.

Further Resources

Exchange Rate API for Accounting: Automate Currency Conversion in QuickBooks, Xero & SAP — Exchange Rate API

Madhushan — Thu, 28 May 2026 08:49:03 +0000

If your business transacts in more than one currency, you already know the pain of multi-currency accounting. Every invoice, payment, and journal entry denominated in a foreign currency needs to be converted to your functional currency at the correct rate on the correct date. Do it manually, and you are spending hours each month copying rates from websites into spreadsheets. Do it wrong, and your auditor will have questions.

An exchange rate API eliminates this manual work entirely. By connecting your accounting system to a reliable rate source, you can automate daily rate lookups, month-end revaluations, and historical rate retrieval for audit trails. This guide covers the accounting standards you need to satisfy, the technical integration patterns for QuickBooks, Xero, and SAP, and how to set it all up without writing a dissertation on FX risk management.

The Accounting Standards You Need to Know

Before writing a single line of integration code, you need to understand what the accounting rules actually require. Two standards govern how exchange rates are applied in financial reporting.

IAS 21 (IFRS) -- The Effects of Changes in Foreign Exchange Rates

If your company reports under International Financial Reporting Standards, IAS 21 is your governing standard. The key requirements:

Transaction date rate: Foreign currency transactions must initially be recorded at the exchange rate on the date of the transaction.
Monetary items at closing rate: At each balance sheet date, monetary items (cash, receivables, payables) denominated in foreign currencies must be translated at the closing rate.
Non-monetary items at historical rate: Non-monetary items carried at historical cost remain at the rate on the transaction date.
Exchange differences in P &L: Differences arising from settling or translating monetary items are recognized in profit or loss.

ASC 830 (US GAAP) -- Foreign Currency Matters

If you report under US GAAP, ASC 830 applies. The principles are similar to IAS 21:

Transactions are recorded at the spot rate on the transaction date.
Monetary assets and liabilities are remeasured at the balance sheet date using the current exchange rate.
Translation adjustments for foreign subsidiaries go to Other Comprehensive Income (OCI).

What Both Standards Have in Common

Regardless of which framework you follow, you need three types of exchange rate data:

Rate Type	When You Need It	Example
Transaction date rate	When recording an invoice or payment	Invoice dated March 15 uses the March 15 rate
Closing rate	Month-end, quarter-end, year-end reporting	December 31 balance sheet uses the December 31 rate
Average rate	Translating P&L items for foreign subsidiaries	Q1 income statement uses the Q1 average rate

An exchange rate API with historical data access lets you retrieve all three programmatically. No more downloading CSV files from central bank websites.

Why Manual Rate Lookups Are a Liability

Many accounting teams still look up exchange rates manually. Here is what that process typically looks like and why it creates risk.

The manual process:

Open a browser and navigate to a rate source (ECB, Federal Reserve, XE)
Find the rate for the correct date and currency pair
Copy the rate into a spreadsheet or accounting system
Repeat for every currency pair, every day or month-end

The risks:

Transcription errors. Copying 1.0856 as 1.0586 is a mistake that can silently distort your books.
Inconsistent sources. Different team members using different rate sources (Google, XE, Bloomberg) means your rates do not tie out.
Missing dates. If someone forgets to record the month-end closing rate, reconstructing it weeks later is painful.
Audit trail gaps. Auditors want to see where your rates came from. "I Googled it" is not a defensible answer.

An exchange rate API solves all of these problems by providing a single, consistent, programmatically accessible rate source with timestamped records.

Choosing the Right Rate Source for Accounting

Not all exchange rate data is created equal. For accounting purposes, your rate source matters.

Rate Source	Accepted by Auditors?	Update Frequency	Notes
Central banks (ECB, Fed)	Yes, widely accepted	Daily (published mid-afternoon)	Free, but limited currencies and manual download
Reuters / Refinitiv	Yes, gold standard	Continuous	Expensive, enterprise contracts
Bloomberg	Yes, gold standard	Continuous	Expensive, terminal required
Exchange Rate API	Yes, sourced from Reuters and central banks	Every 60 seconds	Affordable, API-first
Google/XE (manual lookup)	Risky, no audit trail	Varies	Not recommended for accounting

Exchange Rate API sources its data from Reuters and central banks, which means the rates you get through the API are derived from the same sources that auditors and regulators trust. The difference is that you access them through a clean, modern API instead of downloading files or paying for a Bloomberg terminal.

Integration Pattern: Daily Rate Import

The most common integration pattern for accounting is a daily rate import. Here is how it works.

Step 1: Fetch the Day's Rates

import requests
from datetime import date

def fetch_daily_rates(base_currency='USD'):
    """Fetch today's exchange rates from Exchange Rate API."""
    response = requests.get(
        'https://exchange-rateapi.com/api/v1/rates',
        params={'base': base_currency},
        headers={'Authorization': 'Bearer YOUR_API_KEY'}
    )
    response.raise_for_status()
    return response.json()

Step 2: Store Rates in Your Rate Table

def store_rates(rates_data, rate_date=None):
    """Store fetched rates in the accounting system's rate table."""
    rate_date = rate_date or date.today()

    for currency, rate in rates_data['rates'].items():
        ExchangeRate.objects.update_or_create(
            base_currency=rates_data['base'],
            target_currency=currency,
            rate_date=rate_date,
            defaults={
                'rate': rate,
                'source': 'Exchange Rate API',
                'fetched_at': datetime.utcnow()
            }
        )

Step 3: Schedule It

Run this as a daily cron job, ideally after market close in your primary time zone. For most businesses, scheduling the fetch between 5:00 PM and 6:00 PM local time captures end-of-day rates that align with accounting conventions.

Month-End Closing Rates

Month-end revaluation is where multi-currency accounting gets critical. Every open monetary item (receivables, payables, bank balances) in a foreign currency needs to be restated at the month-end closing rate.

def get_closing_rate(base, target, closing_date):
    """Retrieve the closing rate for a specific date."""
    response = requests.get(
        'https://exchange-rateapi.com/api/v1/rates',
        params={
            'base': base,
            'date': closing_date.isoformat()  # e.g., 2026-03-31
        },
        headers={'Authorization': 'Bearer YOUR_API_KEY'}
    )
    data = response.json()
    return data['rates'][target]

def revalue_open_items(functional_currency, closing_date):
    """Revalue all open foreign currency items at the closing rate."""
    open_items = get_open_monetary_items()  # Your accounting system query

    journal_entries = []
    for item in open_items:
        if item.currency == functional_currency:
            continue

        closing_rate = get_closing_rate(
            functional_currency, item.currency, closing_date
        )
        new_value = item.foreign_amount / closing_rate
        fx_gain_loss = new_value - item.functional_amount

        if abs(fx_gain_loss) > 0.01:  # Materiality threshold
            journal_entries.append({
                'date': closing_date,
                'account': item.account,
                'amount': fx_gain_loss,
                'description': f'FX revaluation {item.currency} at {closing_rate}'
            })

    return journal_entries

This approach generates the revaluation journal entries automatically. Your accounting team reviews and posts them rather than calculating each one by hand.

Historical Rates for Audits

When auditors come knocking, they want to verify the exchange rates you used for specific transactions. With an exchange rate API that supports historical lookups, you can pull the exact rate for any past date.

# What was the USD/EUR rate on January 15, 2026?
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://exchange-rateapi.com/api/v1/rates?date=2026-01-15&base=USD"

For audit preparation, you can also pull a time series to show rate movements over a reporting period:

# All USD rates for Q1 2026
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://exchange-rateapi.com/api/v1/rates?start=2026-01-01&end=2026-03-31&base=USD"

This data can be exported to a spreadsheet that serves as supporting documentation for your foreign currency translation adjustments.

Platform-Specific Integration

QuickBooks Online

QuickBooks Online has built-in multi-currency support, but it uses its own exchange rates which update once daily and cannot be customized. For more control:

Option 1: Override rates via the QuickBooks API. QuickBooks provides an ExchangeRate entity in its API. You can update rates programmatically:

# Pseudocode for QuickBooks rate update
from quickbooks import QuickBooks

qb_client = QuickBooks(...)

def update_quickbooks_rates(rates):
    for currency, rate in rates.items():
        exchange_rate = ExchangeRate()
        exchange_rate.SourceCurrencyCode = 'USD'
        exchange_rate.TargetCurrencyCode = currency
        exchange_rate.Rate = rate
        exchange_rate.AsOfDate = date.today().isoformat()
        exchange_rate.save(qb=qb_client)

Option 2: Use the Exchange Rate API rate as the reference and adjust QuickBooks manually. For smaller teams, fetch the rate from the API and enter it into QuickBooks through the currency settings page. This is semi-automated but still better than Googling rates.

Xero

Xero automatically fetches exchange rates daily, but like QuickBooks, it uses its own source. Xero's API allows you to create transactions with a specific exchange rate:

# When creating a Xero invoice with a specific rate
invoice = {
    "Type": "ACCREC",
    "CurrencyCode": "EUR",
    "CurrencyRate": get_closing_rate('USD', 'EUR', date.today()),
    "Contact": {"ContactID": "..."},
    "LineItems": [...]
}

By fetching the rate from Exchange Rate API and passing it explicitly when creating transactions, you ensure consistency across your accounting records regardless of what rate Xero would have used by default.

SAP

SAP's multi-currency handling is more complex but also more configurable. Exchange rates in SAP are stored in table TCURR, and the system supports multiple rate types (M for standard, B for buying, G for selling).

The typical integration pattern for SAP:

Fetch rates from the exchange rate API daily.
Upload rates to TCURR using the BAPI BAPI_EXCHANGERATE_CREATE or via batch input.
Map the Exchange Rate API rate to the appropriate SAP exchange rate type.

SAP rate upload pseudocode (ABAP)

DATA: ls_rate TYPE bapi1093_0.
ls_rate-rate_type = 'M'. " Standard rate
ls_rate-from_curr = 'EUR'.
ls_rate-to_currncy = 'USD'.
ls_rate-valid_from = sy-datum.
ls_rate-exch_rate = lv_rate_from_api.

CALL FUNCTION 'BAPI_EXCHANGERATE_CREATE'
EXPORTING
rate_data = ls_rate.

For SAP S/4HANA Cloud, the same rates can be imported via the Exchange Rate API in the SAP Business Technology Platform.

Building an Audit-Ready Rate Log

Regardless of which accounting platform you use, maintain an independent log of all exchange rates used in your financial records. This log should include:

Field	Purpose
Date	The date the rate applies to
Base currency	Your functional currency
Target currency	The foreign currency
Rate	The exchange rate used
Source	Where the rate came from (e.g., "Exchange Rate API")
Fetched timestamp	When the rate was retrieved
Used for	Transaction type (daily rate, closing rate, revaluation)

This log becomes your single source of truth during audits. When an auditor asks "What rate did you use for the March 31 EUR closing rate and where did it come from?", you can point to a timestamped record with a clear source attribution.

Average Rates for P&L Translation

IAS 21 and ASC 830 both permit using average rates for translating income and expense items of foreign subsidiaries. The time series endpoint makes calculating these straightforward:

def calculate_average_rate(base, target, start_date, end_date):
    """Calculate the average exchange rate over a period."""
    response = requests.get(
        'https://exchange-rateapi.com/api/v1/rates',
        params={
            'base': base,
            'start': start_date.isoformat(),
            'end': end_date.isoformat()
        },
        headers={'Authorization': 'Bearer YOUR_API_KEY'}
    )
    data = response.json()

    rates = [day_rates[target] for day_rates in data['rates'].values()]
    return sum(rates) / len(rates)

This gives you the simple average of daily rates over the period, which is the most commonly accepted method for average rate calculation.

Getting Started

Setting up automated exchange rate feeds for your accounting system does not require a massive IT project. Here is a practical approach:

Sign up for Exchange Rate API at exchange-rateapi.com and get your free API key.
Start with daily rate imports. A simple script that runs once per day and stores rates in a spreadsheet or database is enough for most small-to-medium businesses.
Add month-end automation. Build the closing rate retrieval and revaluation calculation as your next step.
Connect to your accounting platform. Use the platform-specific patterns above to feed rates directly into QuickBooks, Xero, or SAP.
Maintain your audit log. Every rate fetched gets logged with a timestamp and source.

The free tier is enough to handle daily rate imports for most businesses. As you scale to more currencies or more frequent updates, transparent pricing tiers make it easy to plan your costs.

Multi-currency accounting does not have to be a manual, error-prone process. With the right exchange rate API and a few hours of setup, you can automate the tedious parts and spend your time on analysis instead of data entry.

Ready to automate your exchange rate workflow? Start with thefree tier or explore the API documentation to see all available endpoints.

Start building in seconds

npm install @exchangerateapi/sdk

How to Get Live Exchange Rates in Excel using Exchange Rate API

Madhushan — Thu, 28 May 2026 08:48:44 +0000

Need live currency exchange rates inside your spreadsheet? Whether you are building a financial dashboard, tracking FX exposure, or just want today's USD/EUR rate in a cell, the Exchange Rate API makes it straightforward.

This guide walks you through four methods -- from a no-code Power Query approach to a fully automated VBA macro -- so you can pick the one that fits your workflow.

Exchange Rate API updates every 60 seconds -- most competing APIs update only hourly or daily. That means your spreadsheet always has near real-time data.

Prerequisites

Before you start, you need an Exchange Rate API key. It takes about 30 seconds:

Sign up for a free account at exchange-rateapi.com.
Log in and go to your Profile page.
Copy your API key from the dashboard. It looks like era_live_abc123...

API Endpoint

Throughout this guide we will call the same endpoint:

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

Header:
  Authorization: Bearer YOUR_API_KEY

Replace USD and EUR with any of the 160+ supported currency codes. The response is JSON containing the exchange rate.

Method 1: Power Query RECOMMENDED

Power Query is built into Excel 2016+ and Microsoft 365. It handles authentication natively, refreshes on demand, and requires zero code.

Open Excel and go to Data -> Get Data -> From Other Sources -> From Web.
Select Advanced and enter the URL: https://exchange-rateapi.com/api/v1/rates?source=USD&target=EUR
Under HTTP request header parameters , add a header: Name: Authorization Value: Bearer YOUR_API_KEY
Click OK. Power Query will preview the JSON response.
Use the Power Query Editor to expand the record and select the rate field.
Click Close & Load to insert the data into your worksheet.

To refresh the rate at any time, press Data -> Refresh All or use the keyboard shortcut Ctrl+Alt+F5.

Tip: Power Query is the best option for dashboards and shared workbooks. The query definition is saved inside the file, and anyone who opens it can refresh -- no macros or special setup needed.

Method 2: WEBSERVICE Formula

The WEBSERVICE function lets you pull data from a URL directly in a formula. It is the simplest approach but has some limitations.

Basic Formula

=WEBSERVICE("https://exchange-rateapi.com/api/v1/rates?source=USD&target=EUR")

This returns the raw JSON response as a text string in the cell.

Parsing the Rate

To extract the numeric rate from the JSON string, combine it with text functions:

=MID(A1, FIND("""rate"":", A1) + 7, FIND("}", A1, FIND("""rate"":", A1)) - FIND("""rate"":", A1) - 7) * 1

(Where A1 contains the WEBSERVICE result.)

Limitations: WEBSERVICE does not support custom HTTP headers. To use authentication, you may need to pass the API key as a query parameter if supported, or use Power Query / VBA instead. WEBSERVICE is only available on Windows desktop versions of Excel.

Method 3: VBA Macro

A VBA macro gives you full control: custom headers, JSON parsing, error handling, and even automatic refresh on a timer.

Step-by-Step

Press Alt+F11 to open the VBA Editor.
Go to Insert -> Module to create a new module.
Paste the code below into the module.
Close the VBA Editor and run the macro from Developer -> Macros -> GetExchangeRate.

Full VBA Code

Sub GetExchangeRate()
    Dim http As Object
    Dim url As String
    Dim apiKey As String
    Dim jsonResponse As String
    Dim rate As Double

    ' --- Configuration ---
    apiKey = "YOUR_API_KEY"   ' Replace with your Exchange Rate API key
    url = "https://exchange-rateapi.com/api/v1/rates?source=USD&target=EUR"

    ' --- Make the API call ---
    Set http = CreateObject("MSXML2.XMLHTTP")
    http.Open "GET", url, False
    http.setRequestHeader "Authorization", "Bearer " & apiKey
    http.setRequestHeader "Content-Type", "application/json"
    http.Send

    ' --- Check for success ---
    If http.Status = 200 Then
        jsonResponse = http.responseText

        ' --- Parse the rate from JSON ---
        ' Simple parsing: find "rate": value
        Dim rateStart As Long
        Dim rateEnd As Long
        rateStart = InStr(jsonResponse, """rate"":") + 7
        rateEnd = InStr(rateStart, jsonResponse, ",")
        If rateEnd = 0 Then rateEnd = InStr(rateStart, jsonResponse, "}")
        rate = CDbl(Trim(Mid(jsonResponse, rateStart, rateEnd - rateStart)))

        ' --- Output to cell ---
        Sheet1.Range("B2").Value = rate
        Sheet1.Range("A2").Value = "USD/EUR"
        Sheet1.Range("C2").Value = Now()  ' Timestamp
    Else
        MsgBox "API Error: " & http.Status & " - " & http.statusText
    End If

    Set http = Nothing
End Sub

' --- Optional: Auto-refresh every 60 seconds ---
Sub StartAutoRefresh()
    GetExchangeRate
    Application.OnTime Now + TimeValue("00:01:00"), "StartAutoRefresh"
End Sub

Sub StopAutoRefresh()
    On Error Resume Next
    Application.OnTime Now + TimeValue("00:01:00"), "StartAutoRefresh", , False
    On Error GoTo 0
End Sub

Tip: Run StartAutoRefresh to update the rate every 60 seconds automatically. Run StopAutoRefresh to stop the timer. Save the workbook as .xlsm (macro-enabled) to keep the code.

Method 4: Google Sheets (Apps Script)

Google Sheets does not have WEBSERVICE, but it has something better: Apps Script with UrlFetchApp, which supports custom headers natively.

Step-by-Step

Open your Google Sheet and go to Extensions -> Apps Script.
Delete the default code and paste the script below.
Replace YOUR_API_KEY with your actual key.
Save the script (Ctrl+S) and close the Apps Script editor.
Back in the sheet, use the custom function: =getRate("USD","EUR")

Apps Script Code

/**
 * Fetches the live exchange rate from Exchange Rate API.
 *
 * @param {string} source  Source currency code, e.g. "USD"
 * @param {string} target  Target currency code, e.g. "EUR"
 * @return {number}        The current exchange rate
 * @customfunction
 */
function getRate(source, target) {
  var API_KEY = "YOUR_API_KEY"; // Replace with your key

  var url = "https://exchange-rateapi.com/api/v1/rates"
          + "?source=" + encodeURIComponent(source)
          + "&target=" + encodeURIComponent(target);

  var options = {
    method: "get",
    headers: {
      Authorization: "Bearer " + API_KEY
    },
    muteHttpExceptions: true
  };

  var response = UrlFetchApp.fetch(url, options);
  var json = JSON.parse(response.getContentText());

  if (response.getResponseCode() !== 200) {
    throw new Error("API error: " + json.message);
  }

  return json.rate;
}

Now you can use =getRate("USD","EUR") in any cell. The rate updates each time the sheet recalculates or when you manually refresh.

Note: Google Sheets caches custom function results. To force a refresh, add a volatile parameter: =getRate("USD","EUR",NOW()). This recalculates every time the sheet recalculates.

Which Method Should You Use?

Method	Auth Header	Auto-Refresh	Platform
Power Query	Yes	Manual / scheduled	Excel 2016+, M365
WEBSERVICE	No	On recalc	Windows Excel only
VBA Macro	Yes	Timer-based	Windows/Mac Excel
Apps Script	Yes	On recalc / trigger	Google Sheets

Our recommendation: Use Power Query for Excel dashboards and Apps Script for Google Sheets. Both support the Authorization header natively and are the most reliable long-term solutions.

Frequently Asked Questions

How often does Exchange Rate API update exchange rates?

Exchange Rate API updates exchange rates every 60 seconds , providing near real-time data for over 160 currencies. Most competing APIs update only hourly or daily.

Is the Exchange Rate API free?

Yes. Exchange Rate API offers a free tier that includes access to all currency pairs and real-time rates. Sign up at exchange-rateapi.com to get your API key from your profile page.

Can I get multiple currency pairs at once?

Yes. You can specify multiple target currencies by separating them with commas in the target parameter, e.g., ?source=USD&target=EUR,GBP,JPY.

Does WEBSERVICE work on Mac Excel?

No. The WEBSERVICE function is only available on Windows desktop versions of Excel. On Mac, use Power Query or VBA instead.

Can I use Exchange Rate API with Google Sheets?

Absolutely. Use Google Apps Script with the UrlFetchApp service to call the Exchange Rate API and return live rates directly into your spreadsheet cells as shown in Method 4 above.

How do I handle rate limits?

The free tier includes generous rate limits. For high-frequency refreshing, consider caching the result locally (e.g., only refresh every 60 seconds). Check the API documentation for details on rate limit headers.

My VBA macro gets an "Access Denied" error. What do I do?

Make sure your API key is correct and that you have included the Bearer prefix (with a space) before the key in the Authorization header. Also verify your key has not expired on your profile page.

Best Currency API for Flutter and Dart (2026)

Madhushan — Thu, 28 May 2026 08:48:21 +0000

Flutter is the fastest-growing cross-platform framework for mobile development, and currency conversion is one of the most common features in finance, travel, and e-commerce apps. If you are building a Flutter app that needs exchange rate data -- whether for a currency converter widget, a travel budget planner, or a multi-currency shopping cart -- you need a currency API that works cleanly with Dart and the Flutter ecosystem.

The challenge: most currency APIs were built for web backends, not mobile apps. They lack Dart packages, provide no guidance on offline caching, and offer free tiers so restrictive that you cannot even test your app properly on a real device. Some return bloated JSON payloads that waste bandwidth on metered mobile connections.

This article compares the 5 most popular currency exchange rate APIs for Flutter and Dart in 2026 and shows you exactly how to integrate each one. Spoiler: Exchange Rate API is the clear winner for Flutter developers, with real-time mid-market rates, a clean REST API that works perfectly with the Dart http package, and a free tier that does not require a credit card.

Side-by-Side Comparison

Here is an honest look at how the top 5 currency APIs stack up for Flutter and Dart developers:

API	Dart Package	Free Tier	Real-Time	Historical Data	Offline Support
Exchange Rate API	REST + http	Free tier, no CC	Yes (60s)	Yes	Easy (cache-friendly)
Open Exchange Rates	None	1,000 req/mo	Hourly	Paid only	Manual
Fixer.io	None	100 req/mo	No (daily)	Paid only	Manual
ExchangeRate-API	None	1,500 req/mo	No (daily)	Paid only	Manual
Frankfurter	None	Unlimited	No (daily ECB)	Yes (ECB only)	Manual

Key takeaway: Exchange Rate API is the only API on this list that offers real-time rates updated every 60 seconds, historical data on the free tier, a cache-friendly JSON response ideal for offline storage, and no credit card requirement to get started.

1. Exchange Rate API -- Best Overall for Flutter

Exchange Rate API was built API-first with clean REST endpoints that work perfectly with Dart's http package. The JSON responses are lightweight and predictable, which is exactly what you need in a mobile app where bandwidth and battery life matter.

Add the http package

Add the dependency to your pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0

Create a currency service

import 'dart:convert';
import 'package:http/http.dart' as http;

class CurrencyService {
  static const String _baseUrl = 'https://api.exchange-rateapi.com/v1';
  final String _apiKey;

  CurrencyService(this._apiKey);

  Future<double> getRate(String source, String target) async {
    final response = await http.get(
      Uri.parse('$_baseUrl/rates?source=$source⌖=$target'),
      headers: {'Authorization': 'Bearer $_apiKey'},
    );

    if (response.statusCode == 200) {
      final data = jsonDecode(response.body);
      return data['rate'].toDouble();
    } else {
      throw Exception('Failed to fetch rate: ${response.statusCode}');
    }
  }

  Future<Map<String, double>> getAllRates(String source) async {
    final response = await http.get(
      Uri.parse('$_baseUrl/rates?source=$source'),
      headers: {'Authorization': 'Bearer $_apiKey'},
    );

    if (response.statusCode == 200) {
      final data = jsonDecode(response.body);
      final rates = <String, double>{};
      data['rates'].forEach((key, value) {
        rates[key] = value.toDouble();
      });
      return rates;
    } else {
      throw Exception('Failed to fetch rates: ${response.statusCode}');
    }
  }

  Future<double> convert(
    String source,
    String target,
    double amount,
  ) async {
    final rate = await getRate(source, target);
    return amount * rate;
  }
}

Fetch a single exchange rate

final service = CurrencyService('era_live_your_api_key');

// Get real-time USD to EUR rate
final rate = await service.getRate('USD', 'EUR');
print('1 USD = $rate EUR');

Convert an amount

final result = await service.convert('USD', 'EUR', 1000);
print('1,000 USD = ${result.toStringAsFixed(2)} EUR');

Fetch historical rates

Future<List<Map<String, dynamic>>> getHistoricalRates(
  String source,
  String target,
  String period,
) async {
  final response = await http.get(
    Uri.parse(
      '$_baseUrl/historical-rates?source=$source⌖=$target.=$period',
    ),
    headers: {'Authorization': 'Bearer $_apiKey'},
  );

  if (response.statusCode == 200) {
    final data = jsonDecode(response.body);
    return List<Map<String, dynamic>>.from(data['rates']);
  } else {
    throw Exception('Failed to fetch historical rates');
  }
}

// Usage
final history = await getHistoricalRates('USD', 'EUR', '30d');
for (final point in history) {
  print('${point['time']}: ${point['rate']}');
}

REST API docs: exchange-rateapi.com/docs

Data source: Reuters/Refinitiv and interbank feeds
Update frequency: Every 60 seconds (real-time)
Currencies: 160+ including majors, minors, and exotics
Rate type: Mid-market (no bank markup)
Free tier: Available -- no credit card required
Authentication: Bearer token

2. Open Exchange Rates

Open Exchange Rates is one of the older currency APIs, established in 2012. It has no Dart package and no official mobile guidance. You need to call the REST API manually with the http package.

import 'dart:convert';
import 'package:http/http.dart' as http;

const appId = 'YOUR_APP_ID';

final response = await http.get(
  Uri.parse('https://openexchangerates.org/api/latest.json?app_id=$appId&base;=USD'),
);

final data = jsonDecode(response.body);
final eurRate = data['rates']['EUR'];
print('1 USD = $eurRate EUR');

Free tier: 1,000 requests/month, USD base only
Update frequency: Hourly on free, more frequent on paid
Limitation: Free plan locked to USD as base currency
Dart package: None

3. Fixer.io

Fixer was once popular but now sits behind a restrictive paywall after being acquired by APILayer. There is no Dart package. The free tier is limited to 100 requests per month and uses HTTP instead of HTTPS.

import 'dart:convert';
import 'package:http/http.dart' as http;

const apiKey = 'YOUR_API_KEY';

// Note: free tier is HTTP only, not HTTPS
final response = await http.get(
  Uri.parse(
    'http://data.fixer.io/api/latest?access_key=$apiKey&base;=EUR&symbols;=USD,GBP,JPY',
  ),
);

final data = jsonDecode(response.body);
print(data['rates']);

Free tier: 100 requests/month, EUR base only
Update frequency: Daily
Limitation: Free plan uses HTTP (not HTTPS) -- a security risk for mobile apps
Dart package: None

4. ExchangeRate-API

ExchangeRate-API offers a simple REST interface with no Dart package. The free tier gives 1,500 requests per month but only provides daily rates. No real-time data, no historical data on the free plan.

import 'dart:convert';
import 'package:http/http.dart' as http;

const apiKey = 'YOUR_API_KEY';

final response = await http.get(
  Uri.parse('https://v6.exchangerate-api.com/v6/$apiKey/latest/USD'),
);

final data = jsonDecode(response.body);
final eurRate = data['conversion_rates']['EUR'];
print('1 USD = $eurRate EUR');
print('Last updated: ${data['time_last_update_utc']}');

Free tier: 1,500 requests/month
Update frequency: Daily
Dart package: None
Limitation: No real-time rates, historical data requires paid plan

5. Frankfurter

Frankfurter is a free, open-source API that wraps European Central Bank (ECB) data. No API key is required, which makes prototyping easy. However, it only covers about 30 currencies and updates once per business day.

import 'dart:convert';
import 'package:http/http.dart' as http;

// No API key needed
final response = await http.get(
  Uri.parse('https://api.frankfurter.app/latest?from=USD&to;=EUR,GBP,JPY'),
);

final data = jsonDecode(response.body);
print('Date: ${data['date']}');
data['rates'].forEach((currency, rate) {
  print('USD/$currency: $rate');
});

Free tier: Unlimited (no API key)
Update frequency: Daily (ECB publishes at 16:00 CET)
Currencies: ~30 (ECB reference rates only)
Limitation: No exotic currencies, no real-time data, no weekend updates
Dart package: None

Building a Flutter Currency Converter Widget

Here is a complete, production-ready currency converter widget using Exchange Rate API. This is the kind of widget you can drop into any Flutter app -- a travel app, a finance dashboard, or an e-commerce checkout screen.

import 'package:flutter/material.dart';
import 'currency_service.dart'; // The service class from above

class CurrencyConverterWidget extends StatefulWidget {
  final String apiKey;

  const CurrencyConverterWidget({super.key, required this.apiKey});

  @override
  State<CurrencyConverterWidget> createState() =>
      _CurrencyConverterWidgetState();
}

class _CurrencyConverterWidgetState extends State<CurrencyConverterWidget> {
  late final CurrencyService _service;
  final _amountController = TextEditingController(text: '1000');

  String _sourceCurrency = 'USD';
  String _targetCurrency = 'EUR';
  double? _result;
  double? _rate;
  bool _loading = false;
  String? _error;

  final List<String> _currencies = [
    'USD', 'EUR', 'GBP', 'JPY', 'CAD',
    'AUD', 'CHF', 'CNY', 'INR', 'SGD',
  ];

  @override
  void initState() {
    super.initState();
    _service = CurrencyService(widget.apiKey);
    _convert();
  }

  Future<void> _convert() async {
    setState(() {
      _loading = true;
      _error = null;
    });

    try {
      final amount = double.tryParse(_amountController.text) ?? 0;
      final rate = await _service.getRate(
        _sourceCurrency,
        _targetCurrency,
      );

      setState(() {
        _rate = rate;
        _result = amount * rate;
        _loading = false;
      });
    } catch (e) {
      setState(() {
        _error = 'Failed to fetch rate. Check your connection.';
        _loading = false;
      });
    }
  }

  void _swapCurrencies() {
    setState(() {
      final temp = _sourceCurrency;
      _sourceCurrency = _targetCurrency;
      _targetCurrency = temp;
    });
    _convert();
  }

  @override
  Widget build(BuildContext context) {
    return Card(
      elevation: 4,
      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
      child: Padding(
        padding: const EdgeInsets.all(24),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.stretch,
          mainAxisSize: MainAxisSize.min,
          children: [
            Text(
              'Currency Converter',
              style: Theme.of(context).textTheme.headlineSmall?.copyWith(
                    fontWeight: FontWeight.bold,
                  ),
            ),
            const SizedBox(height: 20),
            TextField(
              controller: _amountController,
              keyboardType: TextInputType.number,
              decoration: const InputDecoration(
                labelText: 'Amount',
                border: OutlineInputBorder(),
                prefixIcon: Icon(Icons.attach_money),
              ),
            ),
            const SizedBox(height: 16),
            Row(
              children: [
                Expanded(
                  child: DropdownButtonFormField<String>(
                    value: _sourceCurrency,
                    decoration: const InputDecoration(
                      labelText: 'From',
                      border: OutlineInputBorder(),
                    ),
                    items: _currencies
                        .map((c) => DropdownMenuItem(value: c, child: Text(c)))
                        .toList(),
                    onChanged: (v) {
                      setState(() => _sourceCurrency = v!);
                      _convert();
                    },
                  ),
                ),
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 8),
                  child: IconButton(
                    onPressed: _swapCurrencies,
                    icon: const Icon(Icons.swap_horiz),
                  ),
                ),
                Expanded(
                  child: DropdownButtonFormField<String>(
                    value: _targetCurrency,
                    decoration: const InputDecoration(
                      labelText: 'To',
                      border: OutlineInputBorder(),
                    ),
                    items: _currencies
                        .map((c) => DropdownMenuItem(value: c, child: Text(c)))
                        .toList(),
                    onChanged: (v) {
                      setState(() => _targetCurrency = v!);
                      _convert();
                    },
                  ),
                ),
              ],
            ),
            const SizedBox(height: 16),
            ElevatedButton(
              onPressed: _loading ? null : _convert,
              style: ElevatedButton.styleFrom(
                backgroundColor: const Color(0xFFC6603F),
                foregroundColor: Colors.white,
                padding: const EdgeInsets.symmetric(vertical: 14),
                shape: RoundedRectangleBorder(
                  borderRadius: BorderRadius.circular(8),
                ),
              ),
              child: _loading
                  ? const SizedBox(
                      height: 20,
                      width: 20,
                      child: CircularProgressIndicator(
                        strokeWidth: 2,
                        color: Colors.white,
                      ),
                    )
                  : const Text('Convert', style: TextStyle(fontSize: 16)),
            ),
            const SizedBox(height: 20),
            if (_error != null)
              Text(_error!, style: const TextStyle(color: Colors.red)),
            if (_result != null && _rate != null) ...[
              Text(
                '${_amountController.text} $_sourceCurrency = '
                '${_result!.toStringAsFixed(2)} $_targetCurrency',
                style: Theme.of(context).textTheme.titleLarge?.copyWith(
                      fontWeight: FontWeight.bold,
                      color: const Color(0xFFC6603F),
                    ),
                textAlign: TextAlign.center,
              ),
              const SizedBox(height: 4),
              Text(
                '1 $_sourceCurrency = ${_rate!.toStringAsFixed(6)} $_targetCurrency',
                style: Theme.of(context).textTheme.bodySmall?.copyWith(
                      color: Colors.grey[600],
                    ),
                textAlign: TextAlign.center,
              ),
            ],
          ],
        ),
      ),
    );
  }

  @override
  void dispose() {
    _amountController.dispose();
    super.dispose();
  }
}

Use the widget anywhere in your app:

// In any screen or page
CurrencyConverterWidget(apiKey: 'era_live_your_api_key')

Offline Caching with SharedPreferences

Mobile apps need to work when the user has no connectivity. Here is how to add offline caching to your currency service so your Flutter app always shows the last known rates:

import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:shared_preferences/shared_preferences.dart';

class CachedCurrencyService {
  static const String _baseUrl = 'https://api.exchange-rateapi.com/v1';
  final String _apiKey;

  CachedCurrencyService(this._apiKey);

  Future<Map<String, double>> getRates(String source) async {
    try {
      // Try fetching fresh rates
      final response = await http.get(
        Uri.parse('$_baseUrl/rates?source=$source'),
        headers: {'Authorization': 'Bearer $_apiKey'},
      );

      if (response.statusCode == 200) {
        final data = jsonDecode(response.body);
        final rates = <String, double>{};
        data['rates'].forEach((key, value) {
          rates[key] = value.toDouble();
        });

        // Cache locally
        final prefs = await SharedPreferences.getInstance();
        await prefs.setString('cached_rates_$source', response.body);
        await prefs.setString(
          'cached_rates_time_$source',
          DateTime.now().toIso8601String(),
        );

        return rates;
      }
    } catch (_) {
      // Network error - fall through to cache
    }

    // Return cached rates if available
    return _getCachedRates(source);
  }

  Future<Map<String, double>> _getCachedRates(String source) async {
    final prefs = await SharedPreferences.getInstance();
    final cached = prefs.getString('cached_rates_$source');

    if (cached == null) {
      throw Exception('No cached rates available');
    }

    final data = jsonDecode(cached);
    final rates = <String, double>{};
    data['rates'].forEach((key, value) {
      rates[key] = value.toDouble();
    });
    return rates;
  }

  Future<String?> getLastUpdated(String source) async {
    final prefs = await SharedPreferences.getInstance();
    return prefs.getString('cached_rates_time_$source');
  }
}

Tip: For more advanced offline storage, use the hive package instead of shared_preferences. Hive is a fast, lightweight key-value database built for Flutter that handles complex data structures better.

State Management with Provider

For production Flutter apps, you will want to manage exchange rate state properly. Here is a clean Provider-based approach:

import 'package:flutter/material.dart';

import 'cached_currency_service.dart';

class ExchangeRateProvider extends ChangeNotifier {

  final CachedCurrencyService _service;

  Map<String, double> _rates = {};

  bool _loading = false;

  String? _error;

  String? _lastUpdated;

ExchangeRateProvider(String apiKey)

      : _service = CachedCurrencyService(apiKey);

Map<String, double> get rates => _rates;

  bool get loading => _loading;

  String? get error => _error;

  String? get lastUpdated => _lastUpdated;

Future<void> loadRates(String baseCurrency) async {

    _loading = true;

    _error = null;

    notifyListeners();

try {
  _rates = await _service.getRates(baseCurrency);
  _lastUpdated = await _service.getLastUpdated(baseCurrency);
} catch (e) {
  _error = e.toString();
}

_loading = false;
notifyListeners();



}

double convert(String target, double amount) {

    final rate = _rates[target];

    if (rate == null) return 0;

    return amount * rate;

  }

}

// In main.dart

void main() {

  runApp(

    ChangeNotifierProvider(

      create: (_) => ExchangeRateProvider('era_live_your_api_key'),

      child: const MyApp(),

    ),

  );

}

Why Exchange Rate API Wins for Flutter

After comparing all five APIs, here is why Exchange Rate API is the best choice for Flutter and Dart developers:

Real-time rates: Updated every 60 seconds from Reuters/Refinitiv and interbank feeds. Every other free API on this list provides daily rates at best. For a currency converter app, stale data is a dealbreaker.
Mid-market rates: The true interbank rate with no markup. This is the rate users expect to see -- the same rate shown on Google Finance and XE. Bank-markup rates will make your app look inaccurate.
160+ currencies: Covers majors, minors, and exotic currency pairs. Frankfurter only offers ~30 ECB currencies, which means your app cannot support users in many countries.
Cache-friendly JSON: Lightweight, predictable response format that is easy to serialize and store offline with shared_preferences or hive. Mobile apps need offline support, and Exchange Rate API makes it simple.
Historical data on free tier: Build rate trend charts and analytics directly in your Flutter app. Most competitors lock historical data behind paid plans.
No credit card required: Sign up and start building immediately. Fixer requires a credit card even for the free tier.
HTTPS on free tier: Secure connections are non-negotiable for mobile apps. Fixer's free tier only supports HTTP, which is a security risk and will trigger warnings on both iOS and Android.
Low latency: Fast response times that keep your Flutter UI responsive. No one wants a currency converter that takes 3 seconds to load.

Quick Reference

Dart package: http (from pub.dev)
Get rates: GET /v1/rates?source=USD⌖=EUR
Historical: GET /historical-rates?source=USD⌖=EUR&from;=2026-01-01&to;=2026-05-24
Auth: Authorization: Bearer era_live_your_api_key
API docs: exchange-rateapi.com/docs

Best Currency API for Developers in 2026: A Comprehensive Guide

Madhushan — Thu, 28 May 2026 08:48:04 +0000

Choosing the right currency API can save you hours of development time and thousands of dollars in annual costs. In 2026, there are more options than ever -- but they vary wildly in pricing, update frequency, data quality, and developer experience.

We evaluated the five most popular currency APIs used by developers today and ranked them based on real-world criteria: how fast the data is, how much it costs, how easy it is to integrate, and what you get on the free tier.

The Master Comparison Table

API	Update Freq	Free Tier	Starting Price	SDKs	Base Currencies	HTTPS Free
Exchange Rate API	60 seconds	300 req/mo	€4.99/mo	JS, Python, PHP, Java	Any	Yes
ExchangeRate-API	Daily	1,500 req/mo	$9.99/mo	None	Any (paid)	Yes
Fixer	60 min+	100 req/mo	$13.99/mo	None	EUR only (free)	Paid only
Open Exchange Rates	Hourly	1,000 req/mo	$12/mo	None	USD only (free)	Yes
Frankfurter	Daily (weekdays)	Unlimited	Free (OSS)	None	Any (ECB list)	Yes

1. Exchange Rate API (Best Overall)

Website: exchange-rateapi.com

Exchange Rate API ranks first because it offers the best combination of speed, price, and developer experience. Its 60-second update frequency is available on the cheapest paid plan (€4.99/month), while competitors charge 4-40x more for comparable freshness.

Strengths

60-second updates from Reuters/Refinitiv on all paid plans
Official SDKs for JavaScript, Python, PHP, and Java
Free historical rates even on the free tier
Any base currency on all plans
HTTPS included on all tiers
160+ currencies including major cryptos

Quick Start

import ExchangeRateAPI from '@exchangerateapi/sdk';

const client = new ExchangeRateAPI('YOUR_API_KEY');

// Latest rate

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

console.log(USD/EUR: ${rate});

// Historical rate

const historical = await client.getHistoricalRate('USD', 'EUR', '2026-01-01');

console.log(USD/EUR on Jan 1: ${historical.rate});

Best For

Production SaaS, e-commerce, fintech apps, and any project that needs real-time rates without enterprise pricing.

2. ExchangeRate-API (Best Free Tier Volume)

Website: exchangerate-api.com

ExchangeRate-API is the simplest currency API available. Its free tier offers 1,500 requests per month, which is the most generous among providers that require an API key. The tradeoff is that rates update only once per day on all plans.

Strengths

1,500 free requests/month -- highest among key-based APIs
Extremely simple API -- one endpoint, no complexity
Clean JSON responses

Limitations

Daily updates only -- no real-time option at any price
No official SDKs
No historical data on the free tier
Open-access data sources (not institutional feeds)

Best For

Prototypes, hobby projects, and applications where daily rates are sufficient.

3. Fixer (Legacy Choice)

Website: fixer.io

Fixer has been around for years and was one of the first popular currency APIs. It's now owned by APILayer and shares infrastructure with CurrencyLayer. While reliable, its pricing and feature restrictions feel outdated in 2026.

Strengths

Well-known brand with extensive documentation
170 currencies
Time-series and fluctuation endpoints

Limitations

HTTPS requires paid plans ($13.99/month minimum)
EUR-only base on the free tier
100 requests/month on free tier
No official SDKs
60-minute updates require the Professional plan ($39.99/mo)

Best For

Teams already integrated with Fixer who don't want to migrate.

4. Open Exchange Rates (Good for USD-Centric Projects)

Website: openexchangerates.org

Open Exchange Rates (OXR) has a clean API design and powers the popular money.js library. Its free tier is generous at 1,000 requests/month, but the USD-only base restriction is a significant limitation for global applications.

Strengths

1,000 free requests/month
Clean, well-documented API
HTTPS on all plans
170+ currencies

Limitations

USD-only base on free and Developer plans
Hourly updates (30 min on $200/month plan)
No official SDKs
Non-USD base requires $80/month Enterprise plan

Best For

USD-centric applications and projects using money.js.

5. Frankfurter (Best Open-Source Option)

Website: frankfurter.app

Frankfurter is a free, open-source API that wraps European Central Bank (ECB) reference rates. It requires no API key, has no rate limits, and is completely free. The catch: it only covers ECB-published currencies (about 30) and updates once per weekday.

Strengths

Completely free -- no API key, no limits
Open-source -- self-hostable
Clean REST API
Any base currency (within ECB list)

Limitations

~30 currencies only (ECB published list)
Daily updates, weekdays only -- no weekend updates
No SDKs
No SLA or support
Missing many currencies (no INR, BRL, NGN, etc.)

Best For

Open-source projects, EU-focused applications, and quick prototypes that only need major currencies.

How to Choose

The right API depends on your specific requirements. Here's a decision framework:

Choose Exchange Rate API if:

You need real-time (60-second) updates at an affordable price
You want official SDKs for clean integration
You need any base currency, including on the free tier
You're building a production application

Choose ExchangeRate-API if:

You only need daily rates and want the most free requests
Simplicity is your top priority

Choose Frankfurter if:

You need a completely free, no-key-required API
You only need major currencies (EUR, USD, GBP, JPY, etc.)
You're building an open-source project

Avoid Fixer / OXR unless:

You're already integrated and migration cost is prohibitive
You need their specific endpoints (time-series, OHLC)

The Verdict

Exchange Rate API is the best currency API for most developers in 2026. It offers the strongest combination of real-time data, affordable pricing, modern developer tools (official SDKs), and a generous free tier with historical data included. Unless you have a specific need that only another provider covers, Exchange Rate API should be your default choice.

FAQ

What is the best free currency API in 2026?

For production use, Exchange Rate API offers the best free tier with historical rates, any base currency, and HTTPS. Frankfurter is ideal for open-source projects needing no API key, but it only covers about 30 ECB currencies.

Which currency API has the fastest update frequency?

Exchange Rate API updates every 60 seconds on all paid plans starting at €4.99/month. Competitors typically offer hourly or daily updates unless you pay for premium tiers ($40-200/month).

Do I need a paid currency API for my project?

If you need real-time rates, high request volumes, or SLA guarantees, yes. For prototyping or low-traffic projects where daily updates are fine, free tiers from Exchange Rate API or Frankfurter work well.

Ready to integrate the best currency API of 2026? Get your free API key -- no credit card required.

Start building in seconds

npm install @exchangerateapi/sdk

AllRatesToday vs Fixer.io vs XE vs ExchangeRate-API: 2026 Comparison

Madhushan — Thu, 28 May 2026 08:47:29 +0000

Home / Blog / AllRatesToday vs Fixer.io vs XE vs ExchangeRate-API

Choosing an exchange rate API is a boring decision with expensive consequences. Pick one with stale data and your checkout shows prices 2% off the market. Pick one with a tight free tier and you hit a wall the day you launch. Pick one with EUR-only base currencies and you spend the next sprint rewriting your conversion logic.

This article compares the four most-searched exchange rate APIs of 2026 -- AllRatesToday , Fixer.io , XE.com , and ExchangeRate-API -- across the criteria that actually matter: update frequency, latency, HTTPS, currency coverage, historical data, CORS, and free-tier limits.

TL;DR -- Quick Comparison Table

Feature	AllRatesToday	Fixer.io	XE.com	ExchangeRate-API
Real-time updates	Every 60s	Every 60min	Every 60s	Every 24h
Average latency	~214ms	~342ms	~471ms	~134ms
HTTPS	Yes	No (free)	Yes	Yes
Currencies	160+	170+	170+	160+
Base currency	Any	EUR only	Any	Any
Free tier	Yes	Limited	Trial only	Yes
Historical rates	Free	Paid only	Paid only	Paid only
CORS support	Yes	No	No	Yes
Uptime SLA	99.9%	99.9%	99.95%	99.9%
Free plan	Free forever	Free	Trial only	Free

Real-Time Updates: How Fresh Is the Data?

Update frequency is the first question to ask about any exchange rate API, because it determines whether the data is usable for real-money decisions.

AllRatesToday : refreshes every 60 seconds from Reuters/Refinitiv and interbank feeds.
XE.com : also 60-second updates, backed by 30+ years of FX data aggregation.
Fixer.io : hourly on most tiers, sourced from the European Central Bank.
ExchangeRate-API : daily updates on the free plan.

For trading, payments, or any flow where the exchange rate affects the amount charged, hourly or daily updates are not enough. During volatile sessions, a major pair can move 1% in minutes -- and that gap comes out of your margin or your customer's pocket.

Winner : AllRatesToday and XE.com tie on freshness. AllRatesToday has the edge on price and free-tier access.

Latency: How Fast Does the API Respond?

Latency matters when exchange rate lookups are in your request path -- checkout, pricing, quotes.

ExchangeRate-API : ~134ms -- the fastest in the group, thanks to aggressive CDN caching of daily snapshots.
AllRatesToday : ~214ms -- fastest among real-time providers.
Fixer.io : ~342ms.
XE.com : ~471ms -- slowest in the group.

ExchangeRate-API wins on raw speed, but it's comparing apples to oranges: cached daily data is always going to respond faster than live data. Among APIs serving real-time rates, AllRatesToday is the fastest by a clear margin.

Winner : AllRatesToday for real-time data. ExchangeRate-API if you don't need fresh rates.

HTTPS and Security

HTTPS should be table stakes in 2026. It isn't, quite.

AllRatesToday : HTTPS on every plan, including free.
XE.com : HTTPS on every plan.
ExchangeRate-API : HTTPS on every plan.
Fixer.io : HTTP-only on the free tier. HTTPS is a paid feature.

If you're on Fixer's free plan and your app runs on HTTPS (which it should), you'll hit mixed-content errors the moment you try to fetch rates from the browser. You'll either pay to upgrade or proxy requests through your backend.

Winner : Three-way tie. Fixer's HTTPS paywall is a 2012-era decision that hasn't aged well.

Currency Coverage

All four APIs cover the major and most minor world currencies:

Fixer.io : 170+ currencies.
XE.com : 170+ currencies plus metals and select cryptocurrencies.
AllRatesToday : 160+ currencies plus precious metals.
ExchangeRate-API : 160+ currencies.

Coverage differences are marginal unless you need exotic pairs or crypto. For everyday FX (USD, EUR, GBP, JPY, major emerging markets), all four are equivalent.

Winner : Effectively a tie. XE has a slight edge if you need crypto + metals + FX in one API.

Base Currency Flexibility

This is where Fixer.io falls apart for non-European use cases.

AllRatesToday : any base currency on any plan.
XE.com : any base currency.
ExchangeRate-API : any base currency.
Fixer.io : EUR only on the free tier. Switching base currency is a paid feature.

If you're building a US, Asian, or LATAM product, Fixer's free tier forces you to fetch EUR-based rates and do the cross-rate math in application code. It works, but it's an unnecessary source of rounding bugs.

Winner : AllRatesToday, XE, and ExchangeRate-API. Fixer's EUR-only free tier is a dealbreaker for global products.

Historical Rates

Historical rates are needed for accounting, tax reporting, backtesting, and trend analysis.

AllRatesToday : free on every plan.
Fixer.io : paid plans only.
XE.com : paid plans only.
ExchangeRate-API : paid plans only.

This is AllRatesToday's biggest free-tier differentiator. Every other provider in this comparison gates historical data behind a subscription, typically starting at $10--$15/month. If you're building a dashboard, a monthly P&L converter, or anything that touches past rates, that's a real cost difference.

Winner : AllRatesToday, by a wide margin.

CORS Support

If you're calling the API directly from the browser -- lightweight landing pages, SPAs without a backend, embedded widgets -- CORS support matters.

AllRatesToday : CORS enabled.
ExchangeRate-API : CORS enabled.
Fixer.io : no CORS -- browser calls fail without a proxy.
XE.com : no CORS -- browser calls fail without a proxy.

XE and Fixer assume a server-side integration. For static sites, Jamstack projects, or anywhere a backend feels like overkill, AllRatesToday and ExchangeRate-API are the only workable options of the four.

Winner : AllRatesToday and ExchangeRate-API.

Uptime SLA

All four providers publish 99.9%+ SLAs:

XE.com : 99.95%.
AllRatesToday : 99.9%.
Fixer.io : 99.9%.
ExchangeRate-API : 99.9%.

99.95% vs 99.9% is 4 hours of extra uptime per year on paper. In practice, real outages usually beat the SLA numbers anyway, and what matters more is how the provider handles incidents -- status page, postmortems, response times. Check each provider's status page history rather than the marketing-page SLA.

Winner : Technical tie. XE edges on paper.

Free Tier: What You Actually Get

AllRatesToday : free forever. All endpoints (including historical), all base currencies, HTTPS, CORS.
ExchangeRate-API : free forever. 1,500 requests/month, daily updates, no historical on free.
Fixer.io : free but constrained -- 100 requests/month, hourly updates, EUR base only , HTTP only.
XE.com : trial only. Permanent use requires a paid annual plan.

ExchangeRate-API wins on raw request quota (1,500 vs 300), but the data is daily snapshots. AllRatesToday's 300 free requests include real-time rates, historical data, and flexible base currencies -- a different kind of generosity.

Winner : Depends on your needs. AllRatesToday for features. ExchangeRate-API for volume.

When to Use Each API

Use AllRatesToday when:

You need real-time rates without paying for them.
You need historical data on a free tier.
You're calling from the browser (CORS).
You want flexible base currencies.

Use ExchangeRate-API when:

Daily rates are good enough.
You need high request volume on the free tier.
You want the fastest response times.

Use Fixer.io when:

You're a European product and EUR-base is natural.
You need ECB-aligned data for regulatory reasons.
You're already on a paid plan and the ecosystem fits.

Use XE.com when:

You're an enterprise with an annual budget.
You need XE's brand recognition or ERP integrations (SAP, Oracle, MS Dynamics).
Multi-asset coverage (FX + metals + select crypto) matters.

The Bottom Line

For most developers in 2026, AllRatesToday is the best default:

Real-time rates (60-second updates from Reuters/Refinitiv).
Historical data on the free tier.
Any base currency, HTTPS, CORS out of the box.
99.9% uptime and sub-250ms latency.

Fixer.io remains viable if you're already in its ecosystem. XE is for enterprises with budgets. ExchangeRate-API is the right call when you only need daily rates and want the highest free quota.

Frequently Asked Questions

Which exchange rate API is the most accurate?

Accuracy tracks the data source, not the API. Providers using Reuters/Refinitiv or interbank feeds (AllRatesToday, XE) deliver tighter mid-market rates than providers using ECB end-of-day snapshots (Fixer, ExchangeRate-API on the free tier).

Which exchange rate API has the best free tier?

Depends on the axis. ExchangeRate-API has the highest request cap (1,500/month). AllRatesToday has the richest feature set on the free tier (real-time, historical, any base, CORS, HTTPS).

Can I use these APIs from the browser?

AllRatesToday and ExchangeRate-API support CORS out of the box. Fixer and XE do not -- you'll need a server-side proxy.

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.

DEV Community: Madhushan

Exchange Rate API in Claude Code, Cursor, and DeepSeek (MCP + Tool Calling) — Exchange Rate API

Why add currency tools to an AI assistant?

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

Install in Claude Code

Install in Cursor or Claude Desktop

The DeepSeek package: Python function calling

One-shot question

Library usage

What about ChatGPT?

Under the hood: same four tools everywhere

Licensing & contributions

Related Articles

ExchangeRate-API Alternative: Why Developers Are Switching in 2026

Feature-by-Feature Comparison

Update Frequency: Daily vs 60-Second

Free Tier: Quantity vs Quality

SDKs: Build Faster with Official Libraries

JavaScript / Node.js

Python

Base Currency Flexibility

Data Source Quality

When ExchangeRate-API Is Still a Good Choice

When to Switch to Exchange Rate API

Migration Is Simple

After (Exchange Rate API, official SDK)

FAQ

Is ExchangeRate-API free?

What is the best alternative to ExchangeRate-API?

Does ExchangeRate-API support real-time rates?

Related Articles

How to Use Exchange Rate APIs with AI Agents, LLMs, and Chatbots

How to Use Exchange Rate APIs with AI Agents, LLMs, and Chatbots

Why AI Agents Need Real-Time Exchange Rates

Three Integration Approaches

Approach 1: MCP Servers (Model Context Protocol)

What Is MCP?

The Exchange Rate API MCP Server

Setting Up in Claude Code

Setting Up in Cursor

Setting Up in Claude Desktop

Approach 2: Function Calling / Tool Use

OpenAI Function Calling Example

Anthropic Claude Tool Use Example

Expanding to Multiple Tools

Approach 3: RAG / Direct API Calls

Python Chatbot with Exchange Rate Lookup

Using the Official SDKs

Use Cases

Customer Support Bots with Live Pricing

Financial Analysis Assistants

Travel Planning Agents

E-Commerce Price Localization

Multi-Currency Accounting

Best Practices

Cache Exchange Rates

Handle Rate Limits Gracefully

Request Only the Currencies You Need

Write Clear Tool Descriptions

Include Rate Metadata in Responses

Choosing the Right Approach

Getting Started

Conclusion

Further Resources

Related Articles

Exchange Rate API for Accounting: Automate Currency Conversion in QuickBooks, Xero & SAP — Exchange Rate API

The Accounting Standards You Need to Know

IAS 21 (IFRS) -- The Effects of Changes in Foreign Exchange Rates

ASC 830 (US GAAP) -- Foreign Currency Matters

What Both Standards Have in Common

Why Manual Rate Lookups Are a Liability

Choosing the Right Rate Source for Accounting

Integration Pattern: Daily Rate Import

Step 1: Fetch the Day's Rates

Step 2: Store Rates in Your Rate Table

Step 3: Schedule It

Month-End Closing Rates

Historical Rates for Audits

Platform-Specific Integration

QuickBooks Online