Free Exchange Rate API Python
Guide with Working Code

Free exchange rate API Python: the practical path

How to choose a free currency exchange rate API

“Free” can mean an open public endpoint or a limited free plan. Before using any provider, verify whether an API key is required, how often rates refresh, which currencies and dates are available, and whether the terms permit your intended use.

Free exchange rate API without an API key

A no-key endpoint is convenient for a prototype, but it still needs timeouts, caching, respectful request volume, and a fallback plan. Frankfurter documents a public, open-source API with no API key and daily central-bank-derived rates.

Public API, free tier, or paid market feed?

Choose a public reference-rate API for prototypes, reporting, analytics, and low-frequency price localization. A registered free tier may offer broader currency coverage or more frequent updates, but introduces key rotation and quota monitoring. Trading, settlement, compliance, or customer-facing quotes may require a licensed market-data feed with explicit service levels.

Questions to answer before integration

• Does the source publish reference, mid-market, buy, sell, or executable rates?
• Which timezone defines the response date, and how are weekends handled?
• Can the base currency change, or must cross-rates be calculated locally?
• Are attribution, caching, redistribution, or commercial-use restrictions present?

Get live exchange rates in Python with requests

The example uses a documented single-pair endpoint. “Latest” means the provider's latest published reference rate; inspect the returned date and provider information instead of assuming tick-by-tick market data.

from dataclasses import dataclass
from datetime import date
from decimal import Decimal, InvalidOperation

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry


@dataclass(frozen=True)
class RateObservation:
    observed_on: date
    base: str
    quote: str
    rate: Decimal


def build_session() -> requests.Session:
    retry = Retry(
        total=4,
        connect=3,
        read=3,
        status=3,
        backoff_factor=0.5,
        status_forcelist=(429, 500, 502, 503, 504),
        allowed_methods=frozenset({"GET"}),
        respect_retry_after_header=True,
        raise_on_status=False,
    )
    session = requests.Session()
    session.mount("https://", HTTPAdapter(max_retries=retry))
    return session


def get_rate(
    session: requests.Session,
    base: str = "USD",
    quote: str = "EUR",
) -> RateObservation:
    base, quote = base.upper(), quote.upper()
    if not (len(base) == len(quote) == 3 and base.isalpha() and quote.isalpha()):
        raise ValueError("Currency codes must contain three letters")

    url = f"https://api.frankfurter.dev/v2/rate/{base}/{quote}"
    response = session.get(url, timeout=(3.05, 10))
    response.raise_for_status()
    data = response.json()

    required = {"date", "base", "quote", "rate"}
    if not required <= data.keys():
        raise ValueError("Unexpected exchange-rate response")
    if data["base"] != base or data["quote"] != quote:
        raise ValueError("Provider returned a different currency pair")

    try:
        observed_on = date.fromisoformat(data["date"])
        value = Decimal(str(data["rate"]))
    except (TypeError, ValueError, InvalidOperation) as exc:
        raise ValueError("Invalid date or exchange rate") from exc
    if not value.is_finite() or value <= 0:
        raise ValueError("Exchange rate must be a positive finite number")

    return RateObservation(observed_on, base, quote, value)


session = build_session()
rate = get_rate(session, "USD", "EUR")
print(rate.observed_on, rate.rate)

Handle timeouts, HTTP errors, and malformed JSON

Catch requests.Timeout, requests.HTTPError, and requests.JSONDecodeError separately. Log the provider, pair, status, and timestamp without exposing credentials. Retry only transient failures with backoff.

Convert currency amounts in Python

For a single-pair response, multiply the amount by the returned rate and use Decimal with an explicit rounding rule when money is displayed or stored. Keep the original rate, timestamp, and source for auditability.

from decimal import Decimal, ROUND_HALF_UP

def convert_amount(amount, rate, minor_units=2):
    value = Decimal(str(amount)) * Decimal(str(rate))
    quantum = Decimal("1").scaleb(-minor_units)
    return value.quantize(quantum, rounding=ROUND_HALF_UP)

converted = convert_amount("125.50", rate.rate)
print(f"125.50 USD = {converted} EUR")

Use a session, retry only transient failures

The shared requests.Session reuses connections. Its adapter retries connection and read failures, HTTP 429, and selected 5xx responses with bounded exponential backoff, while respect_retry_after_header=True follows server-supplied waiting guidance. Invalid currency codes and other deterministic 4xx responses are not retried. Keep attempts bounded so a dependency problem cannot consume every application worker.

Exchange-rate direction, cross rates, and money rounding

Define every rate as units of quote currency per one unit of base currency. If USD/EUR = 0.92, one U.S. dollar converts to 0.92 euros; the inverse EUR/USD is 1 / 0.92, not 0.92. Preserve the provider's stated pair and never infer direction from a field name such as rate alone.

Fetch historical exchange rates with Python

Historical endpoints commonly accept a date or date range. Validate ISO currency codes and dates before the request, then decide how weekends, holidays, missing observations, and provider revisions should be represented in your application.

Cache rates without serving stale data silently

Store the source date next to the value, set cache expiry from the provider's publication cadence, and surface stale status to callers. For production, monitor failures and keep a last-known-good value with a clear age.

Build a time series without hidden gaps

Keep the provider date as the observation key rather than replacing it with the request time. Store missing dates explicitly or document forward-fill rules. When comparing providers, normalize base currency, timezone, decimal precision, and holiday calendars before calculating returns or averages.

Production checklist for a Python exchange rate integration

A successful HTTP 200 response is only the first check. Production code should verify schema, currency pair, source date, numeric range, cache age, and provider identity before a rate reaches pricing or reporting logic.

Test cases worth automating

• Valid latest and historical responses with fixed fixtures.
• Timeout, connection reset, 429, 500, malformed JSON, and missing fields.
• Unsupported currency codes, same-currency conversion, zero and negative amounts.
• Weekend dates, stale cache, provider date changes, and rounding for different minor units.

How QVeris helps Python apps find exchange rate capabilities

• Discover exchange-rate and currency-data capabilities by task.
• Inspect inputs and outputs before integrating a provider.
• Keep provider claims separate from application-level reliability checks.

Free exchange rate API Python FAQ

Authoritative references