Forem: viraj geeth

Building a Simple Exchange Rate MCP Server using FastMCP and AllRatesToday

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

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

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

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

What really is the point of MCP?

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

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

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

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

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

Let's build our Exchange Rate MCP Server!

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

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

Step 1 — Get your API key

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

Step 2 — Create the project folder and virtual environment

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

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

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

uv venv  # This creates the virtual environment

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

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

code .  # This opens our project folder in VSCode

# If you use Cursor:
cursor .

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

uv add fastmcp dotenv httpx

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

Step 3 — Write the MCP server

Open main.py and paste the following:

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

load_dotenv()

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

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

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


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

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

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

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

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

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


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

A quick walkthrough of what the code does:

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

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

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

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

Step 4 — Set up your environment variable

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

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

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

Step 5 — Wire it into Claude Desktop

Open the Claude Desktop config file:

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

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

Add the server under mcpServers:

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

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

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

Step 6 — Try it out

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

"What's 250 USD in JPY today?"

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

Try a more open-ended one:

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

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

Conclusion

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

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

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

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

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

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

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

Until next time, happy hacking. 🚀

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

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

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

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

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

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

TL;DR — Best Exchange Rate Website by Use Case

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

Why Exchange Rates Differ Between Websites

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

1. Mid-market vs Retail Rate

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

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

2. Data Source

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

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

3. Update Frequency

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

The Best Exchange Rate Websites in 2026

1. AllRatesToday — Best for Developers and Apps

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

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

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

2. Google Finance — Best for Quick Lookups

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

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

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

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

3. XE.com — Best Consumer Brand

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

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

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

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

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

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

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

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

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

5. European Central Bank (ECB) Reference Rates

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

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

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

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

6. Reuters / Refinitiv — Best for Institutional Trading

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

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

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

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

7. Bloomberg — Institutional Alternative to Reuters

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

8. Your Bank's Online Portal

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

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

How to Choose the Right Exchange Rate Website

Match the tool to the job:

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

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

Frequently Asked Questions

What is the most accurate exchange rate website?

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

Why does Google show a different rate than my bank?

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

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

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

Which website is best for historical exchange rates?

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

Can I trust a free exchange rate website?

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

Bottom Line

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

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

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