ECB Exchange Rates

Retrieve official euro foreign exchange reference rates published by the European Central Bank (ECB). This Apify actor connects directly to the ECB Statistical Data Warehouse via the SDMX API and returns clean, structured JSON output for approximately 30 currencies quoted against EUR. Query specific currencies by ISO 4217 code, filter by date range, choose daily, monthly, or annual frequency, and fetch either the latest snapshot or a full historical time series -- all without managing any infrastructure or API integration yourself.

---

Why use ECB Exchange Rates?

The European Central Bank publishes reference rates once per day at approximately 16:00 CET. These rates are used by financial institutions, businesses, and governments across Europe as an official benchmark for currency conversion, invoicing, and regulatory compliance. Accessing this data manually through the ECB website or building a custom SDMX integration is time-consuming and brittle.

This actor wraps the ECB SDMX API into a simple, configurable tool that runs on Apify's serverless cloud. You provide currency codes, a frequency, and an optional date range -- the actor handles the SDMX key construction, CSV parsing, and data normalization automatically. The output is a clean dataset ready for export as JSON, CSV, or Excel.

By running on Apify, you gain access to built-in scheduling, webhook notifications, and native integrations with tools like Google Sheets, Zapier, and Make. Set up a daily schedule and build a continuously updated exchange rate database without writing a single line of glue code.

Whether you are a finance team tracking FX exposure, a developer building a currency conversion feature, or a researcher analyzing long-term monetary trends, this actor delivers authoritative ECB data in a format that slots directly into your workflow.

---

Key features

• Official ECB data source -- rates come directly from the European Central Bank Statistical Data Warehouse, not a third-party aggregator
• ~30 currencies supported -- USD, GBP, JPY, CHF, CAD, AUD, CNY, SEK, NOK, DKK, HKD, SGD, KRW, TRY, BRL, INR, ZAR, MXN, and more
• Three frequency options -- daily (D), monthly (M), or annual (A) rate observations to match your analysis granularity
• Flexible currency selection -- request specific currencies as comma-separated ISO 4217 codes or leave blank to fetch all available rates
• Date range filtering -- set startDate and endDate in YYYY-MM-DD format to retrieve historical time series back to January 1999
• Latest-only mode -- enable latestOnly to fetch just the most recent observation for each currency in a single request
• Configurable result limits -- return between 1 and 5,000 records per run to control output size and cost
• No API key required -- the ECB SDMX API is publicly accessible with no authentication needed
• Clean structured output -- each record includes currency code, rate, observation date, frequency label, base currency (EUR), and extraction timestamp
• Lightweight execution -- typically completes in under 10 seconds using minimal compute resources

---

How to use

Using the Apify Console

1. Go to the ECB Exchange Rates actor page on Apify.
2. Click Try for free to open the actor in your Apify Console.
3. In the Currency Codes field, enter one or more ISO 4217 codes separated by commas (e.g., USD,GBP,JPY). Leave blank for all currencies.
4. Select the Frequency -- Daily, Monthly, or Annual.
5. Optionally fill in Start Date and End Date in YYYY-MM-DD format to define a date range.
6. Toggle Latest Only if you only need the most recent rate for each currency.
7. Set Max Results to control how many records are returned (default is 100, maximum is 5,000).
8. Click Start to run the actor.
9. When the run finishes, open the Dataset tab to view, download, or export results as JSON, CSV, or Excel.

Using the API

curl "https://api.apify.com/v2/acts/ryanclinton~ecb-exchange-rates/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "currencies": "USD,GBP,JPY,CHF",
    "frequency": "D",
    "startDate": "2025-01-01",
    "endDate": "2025-01-31",
    "latestOnly": false,
    "maxResults": 500
  }'

Replace YOUR_API_TOKEN with your Apify API token. The response includes a defaultDatasetId you can use to retrieve results.

---

Input parameters

Name	Type	Required	Default	Description
currencies	String	No	All currencies	Comma-separated ISO 4217 currency codes (e.g., USD,GBP,JPY,CHF). Leave empty to retrieve rates for all ~30 available currencies.
frequency	String	No	D	Rate observation frequency. D = Daily, M = Monthly, A = Annual.
startDate	String	No	None	Start of the date range in YYYY-MM-DD format (e.g., 2024-01-01). Omit for no lower bound.
endDate	String	No	None	End of the date range in YYYY-MM-DD format (e.g., 2024-12-31). Omit for no upper bound.
latestOnly	Boolean	No	false	When true, fetches only the most recent observation for each requested currency using the SDMX lastNObservations=1 parameter.
maxResults	Integer	No	100	Maximum number of exchange rate records to return. Accepts values from 1 to 5,000.

Example input JSON:

{
    "currencies": "USD,GBP,JPY,CHF,CAD,AUD",
    "frequency": "D",
    "startDate": "2025-01-01",
    "endDate": "2025-01-31",
    "latestOnly": false,
    "maxResults": 200
}

• Use the latestOnly flag when you just need a current snapshot -- it reduces response size significantly compared to an unbounded date query.
• For historical time series analysis spanning multiple years, increase maxResults to 5,000 and use monthly (M) or annual (A) frequency to keep the dataset manageable.
• Currency codes are case-insensitive in the input. The actor normalizes them to uppercase before constructing the SDMX key.

---

Output

Each run produces a dataset of exchange rate records. Below is a realistic example:

[
    {
        "currency": "USD",
        "rate": 1.0842,
        "date": "2025-01-15",
        "frequency": "Daily",
        "baseCurrency": "EUR",
        "extractedAt": "2025-01-16T08:30:12.456Z"
    },
    {
        "currency": "GBP",
        "rate": 0.8436,
        "date": "2025-01-15",
        "frequency": "Daily",
        "baseCurrency": "EUR",
        "extractedAt": "2025-01-16T08:30:12.456Z"
    },
    {
        "currency": "JPY",
        "rate": 161.52,
        "date": "2025-01-15",
        "frequency": "Daily",
        "baseCurrency": "EUR",
        "extractedAt": "2025-01-16T08:30:12.456Z"
    },
    {
        "currency": "CHF",
        "rate": 0.9401,
        "date": "2025-01-15",
        "frequency": "Daily",
        "baseCurrency": "EUR",
        "extractedAt": "2025-01-16T08:30:12.456Z"
    }
]

Field	Type	Description
currency	String	ISO 4217 currency code of the quoted currency (e.g., USD, GBP, JPY)
rate	Number	Exchange rate -- units of the quoted currency per 1 EUR (e.g., 1.0842 means 1 EUR = 1.0842 USD)
date	String	Observation date or period. Format varies by frequency: 2025-01-15 for daily, 2025-01 for monthly, 2025 for annual
frequency	String	Human-readable frequency label: Daily, Monthly, or Annual
baseCurrency	String	Always EUR -- all ECB reference rates are quoted against the euro
extractedAt	String	ISO 8601 timestamp recording when the actor extracted the data

---

Use cases

• FX exposure tracking -- retrieve daily rates for the currencies your business transacts in and feed them into treasury dashboards or ERP systems
• Invoice currency conversion -- automate EUR-to-local-currency conversion for international invoicing using the official ECB reference rate
• Historical trend analysis -- download years of daily, monthly, or annual rate data to study currency trends, volatility, and macro-economic cycles
• Regulatory compliance -- use official ECB rates for financial reporting where regulators require a recognized benchmark source
• Cross-rate calculation -- fetch EUR-based rates for two currencies and compute cross-rates (e.g., USD/JPY = EUR/JPY / EUR/USD) for pairs the ECB does not publish directly
• Academic research -- build time series datasets for econometric studies on purchasing power parity, interest rate differentials, or monetary policy effects
• Portfolio valuation -- convert foreign asset values to EUR using the authoritative ECB daily fixing rate for end-of-day portfolio snapshots
• Automated reporting -- schedule daily runs and push results to Google Sheets or a database to power recurring FX reports without manual data entry
• Travel budgeting tools -- integrate current ECB rates into travel planning applications to show users approximate conversion values

---

API & integration

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "currencies": "USD,GBP,JPY,CHF",
    "frequency": "D",
    "latestOnly": True,
    "maxResults": 100,
}

run = client.actor("ryanclinton/ecb-exchange-rates").call(run_input=run_input)

dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
for item in dataset_items:
    print(f"{item['currency']}: {item['rate']} (as of {item['date']})")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/ecb-exchange-rates").call({
    currencies: "USD,GBP,JPY,CHF",
    frequency: "D",
    latestOnly: true,
    maxResults: 100,
});

const { items } = await client
    .dataset(run.defaultDatasetId)
    .listItems();

items.forEach((item) => {
    console.log(`${item.currency}: ${item.rate} (as of ${item.date})`);
});

cURL

# Start a run and get the run ID
curl "https://api.apify.com/v2/acts/ryanclinton~ecb-exchange-rates/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "currencies": "USD,GBP,JPY",
    "frequency": "D",
    "latestOnly": true,
    "maxResults": 50
  }'

# Fetch results from the dataset (replace DATASET_ID with defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

Beyond direct API calls, this actor integrates with the broader Apify ecosystem and third-party automation platforms:

• Zapier -- trigger workflows when a run completes, sending exchange rate data to CRMs, databases, or notification channels
• Make (Integromat) -- build multi-step automations that combine ECB rates with other data sources
• Google Sheets -- export dataset results directly to a spreadsheet for dashboarding and ad-hoc analysis
• Slack -- send daily FX rate summaries to a team channel using Apify webhooks
• GitHub Actions -- trigger actor runs as part of CI/CD pipelines or scheduled data refresh workflows

---

How it works

1. Input parsing -- the actor reads your input parameters: currency codes, frequency, date range, latestOnly flag, and maxResults limit.
2. SDMX key construction -- currency codes are split by comma, uppercased, and joined with + to form the currency dimension. The full SDMX key follows the format {frequency}.{currencies}.EUR.SP00.A (e.g., D.USD+GBP+JPY.EUR.SP00.A).
3. API request -- the actor sends a single HTTP GET request to https://data-api.ecb.europa.eu/service/data/EXR/{key} with query parameters for CSV format, date bounds (startPeriod/endPeriod), and optionally lastNObservations=1 for latest-only mode.
4. CSV parsing -- the ECB returns data in CSV format. The actor parses the response using a custom CSV parser that handles quoted fields correctly, extracting headers and row values into structured objects.
5. Data transformation -- each row is mapped to a clean output record containing currency (from CURRENCY column), rate (from OBS_VALUE), date (from TIME_PERIOD), frequency (human-readable label derived from FREQ), baseCurrency (always EUR), and extractedAt (current timestamp). Rows with invalid or missing rate values are skipped.
6. Result limiting -- records are collected up to the maxResults cap (default 100, maximum 5,000).
7. Dataset output -- the final array of records is pushed to the Apify dataset for download, export, or API consumption.

+-------------------+     +---------------------+     +-------------------+
|   Input Config    | --> | Build SDMX Key      | --> | ECB SDMX API      |
| currencies, freq, |     | D.USD+GBP.EUR.SP00.A|     | data-api.ecb.     |
| dates, latestOnly |     +---------------------+     | europa.eu         |
+-------------------+                                  +--------+----------+
                                                                |
                                                          CSV Response
                                                                |
                                                       +--------v----------+
                                                       | Parse CSV Rows    |
                                                       | Extract headers,  |
                                                       | map to records    |
                                                       +--------+----------+
                                                                |
                                                       +--------v----------+
                                                       | Transform & Limit |
                                                       | Normalize fields, |
                                                       | cap at maxResults |
                                                       +--------+----------+
                                                                |
                                                       +--------v----------+
                                                       | Apify Dataset     |
                                                       | JSON / CSV / XLSX |
                                                       +-------------------+

---

Performance & cost

Metric	Details
Average run time	Under 10 seconds for typical queries (latest rates for a few currencies)
Memory usage	256 MB -- minimal footprint since only a single HTTP request and CSV parse are performed
API calls per run	Exactly 1 -- the actor constructs a single SDMX request regardless of how many currencies or dates are requested
Cost per run	Approximately $0.001 or less in Apify platform credits for a standard query
Monthly cost (daily schedule)	Roughly $0.03 per month running once per day
Maximum output	5,000 records per run -- sufficient for multi-year daily histories of several currencies

---

Limitations

• EUR base only -- the ECB exclusively publishes rates with EUR as the base currency. To get rates for other base currencies, you must calculate cross-rates from the EUR-based data.
• Not real-time -- ECB reference rates are published once per business day at approximately 16:00 CET. They are not suitable for intraday trading or real-time pricing.
• No weekend or holiday data -- the ECB does not publish rates on weekends or EU public holidays. Queries for those dates may return no data or the last available business day rate.
• ~30 currencies only -- the ECB covers major global currencies but does not include every ISO 4217 currency. Less commonly traded currencies may not be available.
• 5,000 record cap -- the actor limits output to 5,000 records per run. For very large historical extractions (e.g., all currencies daily since 1999), you may need multiple runs with different date ranges.
• SDMX API availability -- the actor depends on the ECB Statistical Data Warehouse API being accessible. Maintenance windows or outages on the ECB side will cause run failures.
• Date format requirement -- start and end dates must follow the YYYY-MM-DD format exactly. Other date formats will produce errors or unexpected results from the SDMX API.

---

Responsible use

• Respect ECB terms of service -- the ECB SDMX API is a public service. Avoid excessive request volumes that could burden the infrastructure. Running this actor a few times per day is appropriate.
• Attribute data correctly -- when publishing or redistributing ECB exchange rate data, credit the European Central Bank as the original source in compliance with ECB data usage policies.
• Do not misrepresent rates -- ECB reference rates are indicative benchmarks, not transactional rates. Do not present them as live market prices or guaranteed conversion rates in financial applications.
• Use for lawful purposes -- exchange rate data should be used for legitimate financial analysis, reporting, research, and business operations. Do not use this data to facilitate fraud, market manipulation, or sanctions evasion.
• Understand the data lag -- ECB rates reflect conditions at the time of publication, not the current moment. Account for this lag in any application where timing matters.

---

FAQ

Q: What currencies does the ECB provide exchange rates for? A: The ECB publishes reference rates for approximately 30 currencies including USD, GBP, JPY, CHF, CAD, AUD, NZD, CNY, SEK, NOK, DKK, HKD, SGD, KRW, TRY, BRL, INR, ZAR, MXN, IDR, MYR, PHP, THB, PLN, CZK, HUF, RON, BGN, ISK, and HRK. The exact list is maintained by the ECB and may change over time.

Q: Are the rates updated in real time? A: No. ECB reference rates are published once per business day at approximately 16:00 CET. They represent a daily fixing, not a live market feed. For real-time FX data, use a market data provider.

Q: Can I get rates with a base currency other than EUR? A: The ECB only publishes EUR-based rates. To compute a cross-rate such as USD/JPY, divide the EUR/JPY rate by the EUR/USD rate. For example, if EUR/USD = 1.0842 and EUR/JPY = 161.52, then USD/JPY = 161.52 / 1.0842 = 148.97.

Q: How far back does the historical data go? A: Daily ECB reference rates are available from January 4, 1999 -- the date the euro was introduced. Monthly and annual averages are available from the same starting point.

Q: What happens if I leave all input fields empty? A: The actor fetches the most recent daily rates for all available currencies, limited to 100 records by default. This is a good starting point for exploration.

Q: Why does my query return no data? A: Common reasons include: the date range falls entirely on weekends or holidays, the currency code is misspelled or not in the ECB's list, or the date format does not match YYYY-MM-DD. Check the actor log for specific error messages from the ECB API.

Q: What is the SDMX key format used by the actor? A: The actor constructs keys in the format {frequency}.{currencies}.EUR.SP00.A. For example, requesting daily USD and GBP rates produces the key D.USD+GBP.EUR.SP00.A. Multiple currencies are joined with + in the currency dimension.

Q: Is there a rate limit on the ECB API? A: The ECB SDMX API is publicly available without authentication. There are no published rate limits, but the ECB may throttle excessive requests. Running this actor several times per day is well within acceptable usage.

Q: Can I schedule automatic daily runs? A: Yes. In Apify Console, go to the actor's Schedules tab and create a schedule (e.g., daily at 17:00 CET, shortly after the ECB publishes new rates). Results are stored in Apify datasets and can be automatically forwarded via integrations.

Q: What date format should I use for monthly or annual queries? A: For monthly frequency, you can use YYYY-MM (e.g., 2024-01) or YYYY-MM-DD. For annual frequency, you can use YYYY (e.g., 2024). The ECB SDMX API accepts these period formats in the startPeriod and endPeriod parameters.

Q: How do I export results to CSV or Excel? A: After a run completes, open the Dataset tab in Apify Console and click the download button. Choose JSON, CSV, Excel, XML, or HTML format. You can also retrieve data programmatically via the Apify dataset API endpoint with a format query parameter.

Q: Does the actor require an API key for the ECB? A: No. The ECB Statistical Data Warehouse API is completely free and open. No API key, registration, or authentication is required.

---

Related actors

Actor	Description	Link
Currency Exchange Rate Tracker	Exchange rates from ExchangeRate-API with broader currency coverage and non-EUR base currency support	Currency Exchange Rate Tracker
Historical Exchange Rate Data	Historical exchange rate lookups for past dates and time series analysis across multiple providers	Historical Exchange Rate Data
World Bank Development Indicators	Macroeconomic indicators including GDP, inflation, and trade data -- useful for combining with FX rates	World Bank Development Indicators
FRED Economic Data Search	US Federal Reserve economic data including interest rates and monetary aggregates that influence exchange rates	FRED Economic Data Search
IMF Economic Data	International Monetary Fund datasets covering balance of payments, exchange rate arrangements, and global financial stability	IMF Economic Data