# Exchange Rates Scraper — Live & Historical FX (ECB) (`hipersoft/frankfurter-fx-scraper`) Actor

Fetch live and historical foreign-exchange rates published by the European Central Bank: any base currency, any target symbols, plus full time series over a date range. Clean structured JSON, CSV or Excel for finance, invoicing, dashboards and n8n.

- **URL**: https://apify.com/hipersoft/frankfurter-fx-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00025 / rate scraped

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Exchange Rates Scraper — Live & Historical Currency Rates (ECB)

Get **live and historical foreign-exchange rates** as clean, structured **JSON, CSV, Excel or XML**. Pick any **base currency**, any set of **target currencies**, and pull the **latest** rates, the rates on a **single past date**, or a full **time series** across a date range. The rates are the official **European Central Bank (ECB) reference rates**, so they are the same numbers used across banking, accounting and reporting. One run returns a tidy row per currency, ready for finance apps, invoicing, dashboards, research and automation.

### What does the Exchange Rates Scraper do?

This actor turns currency data into a structured dataset. Choose a base currency (default **EUR**), list the target currencies you care about (or leave it empty for every available currency), and select a mode: **latest**, **historical** or **timeseries**. It returns a flat record per currency — base, currency, rate and date — that you can export in any format the Apify platform supports or fetch straight through the API.

### What data can you get?

| Field | Description |
| --- | --- |
| `base` | The base currency the rate is quoted against (e.g. EUR, USD). |
| `currency` | The target currency code (e.g. GBP, JPY). |
| `rate` | Value of one unit of the base currency in the target currency. |
| `date` | The reference date the rate applies to (YYYY-MM-DD). |

### Modes

- **Latest** — the most recent published rates for your base and symbols.
- **Historical** — the rates on one specific past date (`date`, YYYY-MM-DD).
- **Time series** — one row per working day between `startDate` and `endDate`, for every requested currency.

### Use cases

- **Invoicing & accounting** — convert invoices and expenses using the official reference rate for a given day.
- **Finance dashboards** — power an FX widget or treasury dashboard across many currency pairs at once.
- **Multi-currency pricing** — refresh product or subscription prices from a single scheduled run.
- **Backtesting & research** — pull a long time series of rates for analysis and modelling.
- **Reporting & audit** — capture the exact rate used on a specific date for compliant records.

### How to use the Exchange Rates Scraper

1. Add the actor to your Apify account and open its input.
2. Set the **base** currency and list any **target currencies** (leave empty for all).
3. Choose a **mode**: latest, historical (set **date**) or timeseries (set **startDate** and **endDate**).
4. Click **Run**.
5. Export the results as JSON, CSV, Excel or XML, or fetch them through the Apify API.

### Input

```json
{
  "base": "USD",
  "symbols": ["EUR", "GBP", "JPY"],
  "mode": "latest"
}
```

Time-series example:

```json
{
  "base": "EUR",
  "symbols": ["USD"],
  "mode": "timeseries",
  "startDate": "2026-01-01",
  "endDate": "2026-01-05"
}
```

| Field | Description |
| --- | --- |
| `base` | Base currency as a 3-letter ISO code (default `EUR`). |
| `symbols` | Target currency codes, one per line. Empty returns all available currencies. |
| `mode` | `latest`, `historical`, or `timeseries`. |
| `date` | Reference date for `historical` mode (YYYY-MM-DD). |
| `startDate` | First date of the range for `timeseries` mode (YYYY-MM-DD). |
| `endDate` | Last date of the range for `timeseries` mode (YYYY-MM-DD). |
| `proxyConfiguration` | Standard Apify proxy settings for the run (optional). |

### What you get

For **latest** and **historical** modes, one row per target currency:

```json
{ "base": "USD", "currency": "EUR", "rate": 0.86371, "date": "2026-09-02" }
```

For **timeseries** mode, one row per date × currency:

```json
{ "base": "EUR", "currency": "USD", "rate": 1.1721, "date": "2026-01-02" }
```

#### Output schema

| Field | Type | Description |
| --- | --- | --- |
| `base` | string | Base currency the rate is quoted against. |
| `currency` | string | Target currency code. |
| `rate` | number | Value of one unit of the base currency in the target currency. |
| `date` | string | Reference date the rate applies to (YYYY-MM-DD). |

### Related Actors

- [CoinGecko Scraper](https://apify.com/hipersoft/coingecko-scraper) — live cryptocurrency prices, market cap and volume.
- [Yahoo Finance Scraper](https://apify.com/hipersoft/yahoo-finance-scraper) — quotes and OHLCV history for stocks, ETFs and forex.
- [Weather Forecast Scraper](https://apify.com/hipersoft/open-meteo-weather-scraper) — global forecasts and history by place or coordinates.

### FAQ

**Which currencies are supported?**
The major world currencies published as ECB reference rates, including USD, EUR, GBP, JPY, CHF, AUD, CAD, CNY, SGD, HKD, INR and many more. Leave `symbols` empty to return the full set.

**Can I fetch many currency pairs in one run?**
Yes. Set one base currency and list as many target currencies as you like; each becomes its own row in the dataset.

**How far back does the history go?**
You can request historical rates and long time series across many years of published data. Rates are published on working days, so weekends and holidays are omitted.

**Are the rates official?**
They are the European Central Bank reference rates, the same figures widely used for accounting, invoicing and reporting.

**Can I connect this to n8n?**
Yes. Run the actor from n8n with the [Apify node](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/) (or an HTTP Request node against the Apify API), trigger it on a schedule, and pipe the structured exchange-rate rows straight into your workflow — currency conversion, invoicing, Slack alerts, spreadsheets, databases and more.

**Can I connect this to my other tools?**
Yes. It works with almost any cloud service or web app through [integrations on the Apify platform](https://apify.com/integrations) — [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**What export formats are available?**
JSON, CSV, Excel and XML, plus programmatic access through the Apify API.

### Notes

Original clean-room implementation. Returns public exchange-rate data; you are responsible for compliant use. All trademarks belong to their respective owners.

# Actor input Schema

## `base` (type: `string`):

The base currency that rates are quoted against, as a 3-letter ISO code (e.g. EUR, USD, GBP). Every returned rate is the value of 1 unit of this currency in each target currency.

## `symbols` (type: `array`):

Target currency codes to return, one per line (e.g. USD, GBP, JPY). Leave empty to return all available currencies.

## `mode` (type: `string`):

What to fetch: "latest" for the most recent rates, "historical" for the rates on a single past date, or "timeseries" for every working day between two dates.

## `date` (type: `string`):

The date to fetch rates for in "historical" mode, formatted YYYY-MM-DD (e.g. 2024-01-15). Ignored for other modes.

## `startDate` (type: `string`):

The first date of the range for "timeseries" mode, formatted YYYY-MM-DD. Ignored for other modes.

## `endDate` (type: `string`):

The last date of the range for "timeseries" mode, formatted YYYY-MM-DD. Ignored for other modes.

## `proxyConfiguration` (type: `object`):

Optional proxy settings for the run. Not required — the exchange-rate data is fetched over plain HTTP.

## Actor input object example

```json
{
  "base": "EUR",
  "symbols": [],
  "mode": "latest",
  "date": "",
  "startDate": "",
  "endDate": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

The results as dataset items.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "symbols": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/frankfurter-fx-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "symbols": [] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/frankfurter-fx-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "symbols": []
}' |
apify call hipersoft/frankfurter-fx-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/frankfurter-fx-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xy1woAV8NVKjGFHdM/builds/b40efZfPZN8X9d15b/openapi.json