How to Fetch Currency Exchange Rates with a Free API (Python Tutorial)

If you've ever built an app that handles money — even just showing prices in different currencies — you already know the pain. Exchange rates change constantly. Hardcoding them is a disaster waiting to happen. The good news? There are free APIs that give you live exchange rate data with zero setup and no credit card required.

Most developers assume currency data is locked behind expensive financial data providers. That used to be true. But today, APIs like the Frankfurter API give you real, up-to-date exchange rates for free — no API key, no rate limit headaches, just clean JSON data ready to use in your Python projects.

This free currency API tutorial walks you through exactly how to fetch live exchange rates, convert currencies in Python, handle errors properly, and build something actually useful. Whether you're working on a side project, a fintech tool, or just learning how APIs work, this is a solid place to start.

We'll use the Frankfurter API — a free, open-source exchange rate API backed by the European Central Bank. It's reliable, requires no authentication, and returns clean JSON. Perfect for beginners and production use alike.

What Is the Frankfurter Exchange Rate API?

Frankfurter is a free forex API example that pulls exchange rate data directly from the European Central Bank. It supports over 30 currencies and updates rates daily. The base URL is https://api.frankfurter.app, and you don't need an API key to use it.

Here's what it can do:

• Fetch the latest exchange rates for any supported currency
• Convert a specific amount between two currencies
• Return historical rates for a given date
• Return a time series of rates between two dates

The response format is straightforward JSON, which makes it easy to parse with Python's built-in tools. It's one of the cleanest live currency conversion APIs available at no cost.

Why Use a Free Currency API Instead of Hardcoding Rates?

Here's the thing — exchange rates fluctuate every single day. Sometimes multiple times a day. If you hardcode 1 USD = 0.92 EUR in your app, that number will be wrong within a week. Users will notice. Trust breaks fast when money is involved.

Using a live exchange rate API means:

• Your app always shows accurate, up-to-date rates
• You don't have to maintain a rates table manually
• You can support dozens of currencies without extra work
• Your code stays clean and separated from data concerns

And when the API is free? There's really no reason not to use it.

Step-by-Step Tutorial: Fetching Exchange Rates with Python

Let's build this from scratch. You'll need Python 3.x and the requests library. If you don't have it yet, install it with:

pip install requests

Step 1: Fetch Latest Exchange Rates

This is the simplest call. You ask for all latest rates relative to a base currency — USD in this case.

import requests

def get_latest_rates(base_currency="USD"):
    url = f"https://api.frankfurter.app/latest?from={base_currency}"
    
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        return data
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.ConnectionError:
        print("Connection error. Check your internet connection.")
    except requests.exceptions.Timeout:
        print("The request timed out. Try again.")
    except Exception as err:
        print(f"Something went wrong: {err}")
    
    return None

rates = get_latest_rates("USD")
if rates:
    print(f"Base: {rates['base']}")
    print(f"Date: {rates['date']}")
    print(f"Rates: {rates['rates']}")

Run this and you'll see something like:

Base: USD
Date: 2025-05-08
Rates: {'AUD': 1.548, 'BGN': 1.793, 'BRL': 5.671, 'CAD': 1.382, 'EUR': 0.921, ...}

Step 2: Convert a Specific Amount Between Two Currencies

Now let's make it practical. Say you want to convert 250 USD to EUR. The exchange rate API Python call looks like this:

import requests

def convert_currency(amount, from_currency, to_currency):
    url = "https://api.frankfurter.app/latest"
    params = {
        "amount": amount,
        "from": from_currency,
        "to": to_currency
    }
    
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        data = response.json()
        converted = data["rates"][to_currency]
        print(f"{amount} {from_currency} = {converted} {to_currency}")
        return converted
    except KeyError:
        print(f"Currency code '{to_currency}' not found in response.")
    except requests.exceptions.RequestException as e:
        print(f"API request failed: {e}")
    
    return None

convert_currency(250, "USD", "EUR")

Output:

250 USD = 230.25 EUR

Step 3: Fetch Historical Exchange Rates

Want to know what the rate was on a specific date? Just swap /latest with the date string.

import requests

def get_historical_rate(date, from_currency, to_currency):
    url = f"https://api.frankfurter.app/{date}"
    params = {
        "from": from_currency,
        "to": to_currency
    }
    
    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        data = response.json()
        rate = data["rates"][to_currency]
        print(f"On {date}: 1 {from_currency} = {rate} {to_currency}")
        return rate
    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
    except KeyError:
        print("Unexpected response format.")
    
    return None

get_historical_rate("2024-01-15", "GBP", "JPY")

Understanding the API Response

The Frankfurter API returns a consistent JSON structure. Here's what each field means:

• amount — The amount you passed in (defaults to 1 if not specified)
• base — The source currency you're converting from
• date — The date of the exchange rate data (ECB updates once daily)
• rates — A dictionary of target currencies and their converted values

One thing to note: the ECB doesn't publish rates on weekends or public holidays. If you request a date that falls on one of those days, Frankfurter automatically returns the most recent available rate. Your code doesn't need to handle that manually — it just works.

Error Handling You Actually Need

Skipping error handling is fine for quick tests. But for anything real, you want to cover these cases:

• Invalid currency code — The API returns a 422 error with a message in the body
• Network timeout — Always set a timeout value (10 seconds is reasonable)
• Server error — Use raise_for_status() to catch 4xx and 5xx responses
• Unexpected JSON shape — Use KeyError handling when accessing nested keys

Here's a tighter version that wraps everything into a reusable class:

import requests

class CurrencyConverter:
    BASE_URL = "https://api.frankfurter.app"
    
    def get_rate(self, from_currency, to_currency, amount=1):
        url = f"{self.BASE_URL}/latest"
        params = {"from": from_currency, "to": to_currency, "amount": amount}
        
        try:
            response = requests.get(url, params=params, timeout=10)
            response.raise_for_status()
            data = response.json()
            
            if "rates" not in data or to_currency not in data["rates"]:
                raise ValueError(f"Unexpected response structure: {data}")
            
            return data["rates"][to_currency]
        
        except requests.exceptions.Timeout:
            print("Request timed out. The API may be slow — try again.")
        except requests.exceptions.HTTPError as e:
            print(f"HTTP error {e.response.status_code}: Check your currency codes.")
        except requests.exceptions.RequestException as e:
            print(f"Network error: {e}")
        except ValueError as e:
            print(f"Data error: {e}")
        
        return None

converter = CurrencyConverter()
result = converter.get_rate("USD", "INR", 100)
if result:
    print(f"100 USD = {result} INR")

Real-World Use Cases

Once you've got live exchange rate data flowing in, you can do a lot with it. Here are some practical ways developers use a build currency converter API approach in real projects:

• E-commerce price localization — Show product prices in the customer's local currency automatically
• Personal finance dashboards — Track expenses across multiple currencies and normalize them to one base
• Travel budget tools — Let users plan trips by converting costs into their home currency
• Freelance invoice generators — Automatically convert USD invoices to a client's local currency
• Crypto/fiat bridges — Use fiat exchange rates as one leg of a multi-currency calculation
• Data analysis scripts — Normalize financial datasets that span multiple currencies

Each of these use cases has one thing in common: they need current data. Stale rates break trust fast in any money-related context.

Comparing Free Currency APIs

For most beginner projects and even some production tools, Frankfurter is the cleanest choice. No key management, no request counting, no surprise bills.

Frequently Asked Questions

Is the Frankfurter API really free with no limits?

Yes. Frankfurter is open-source and hosted publicly. It doesn't require an API key and doesn't publish a rate limit. That said, don't hammer it with thousands of requests per second — that's just bad practice with any public API. For normal use, you won't hit any wall.

How often do the exchange rates update?

Frankfurter pulls data from the European Central Bank, which publishes rates once per business day, usually around 16:00 CET. So the data is daily, not real-time. If you need tick-by-tick forex data, you'll need a paid provider.

Can I use this in a production application?

Yes, but cache the rates. Don't call the API every time a user loads a page. Store the latest rates in your database and refresh them once a day. That way you're not dependent on the API's uptime for every single request.

What currencies does Frankfurter support?

It supports 30+ currencies including USD, EUR, GBP, JPY, AUD, CAD, CHF, CNY, INR, and more. You can check the full list by calling https://api.frankfurter.app/currencies — it returns a clean JSON object of all supported codes.

What happens if I pass an invalid currency code?

Frankfurter returns an HTTP 422 error with a message explaining which code it didn't recognize. That's why raise_for_status() matters — it catches that before you try to parse the response.

Can I get historical exchange rate data for free?

Yes. You can query any date going back to 1999 using the format https://api.frankfurter.app/YYYY-MM-DD. That's a substantial dataset for free, which makes it great for financial analysis and backtesting strategies.

Conclusion

Fetching live currency data in Python doesn't have to be complicated or expensive. The Frankfurter API is free, reliable, and requires zero authentication setup. Once you've got the basics down — a GET request, a JSON parse, and some error handling — you can build real tools on top of it fast.

Start with the simple rate fetch. Then add the conversion function. Then think about caching. That's the natural path from beginner to a working production-grade currency feature.

You've got everything here to build a solid foundation. The free currency API tutorial pattern we covered works for any similar financial API too — once you understand the structure, switching providers is just a URL change.

Want to go further? Head over to Free API Hub and browse our full list of free finance APIs, including options for stock prices, crypto data, and economic indicators — all with working Python examples ready to copy and run.