# exchangerate.host FX Rates Scraper (`parseforge/exchangerate-host-scraper`) Actor

Scrape currency exchange rates from exchangerate.host. Latest, historical, time-series for 170+ currencies. Convert any amount between any pair. No API key required.

- **URL**: https://apify.com/parseforge/exchangerate-host-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.38 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💱 Open ER-API FX Rates Scraper

> 🚀 **Export currency exchange rates for 165+ currencies in seconds.** Pull live or historical FX rates against any base currency, with auto-computed inverse rates and update timestamps. No API key, no signup, no rate-limit guesswork.

> 🕒 **Last updated:** 2026-05-13 · **📊 8 fields** per record · **💱 165+ currencies** · **📅 Latest and historical modes**

The **Open ER-API FX Rates Scraper** queries the open.er-api.com public exchange-rate API and returns **8 fields per record**, including the rate date, base currency, target currency, rate, inverse rate, and the publisher's last-update and next-update timestamps. The underlying feed is a community-funded open exchange-rate service that aggregates rates from central banks and forex providers, refreshed daily.

The catalog covers **165+ ISO 4217 currencies**, from majors like USD, EUR, and JPY through emerging-market currencies, pegged currencies, and exotic pairs. This Actor produces one record per target currency, which makes the output ready to drop into a database, spreadsheet, or dashboard. Export it as CSV, Excel, JSON, or XML in under a minute.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Finance teams, e-commerce platforms, ERP integrators, travel apps, billing systems, journalists, currency dashboards | Multi-currency invoicing, FX revaluation, historical analysis, dashboard widgets, accounting integrations, travel-cost estimates |

---

### 📋 What the FX Rates Scraper does

Two filtering workflows in a single run:

- 💱 **Latest mode.** Pull the most recent daily rates for any base currency against all 165+ targets.
- 📅 **Historical mode.** Pull rates for a specific past date (YYYY-MM-DD format).
- 🎯 **Target filter.** Restrict the output to a specific list of target currencies, or leave empty for all.
- 🔢 **Cap with maxItems.** Take the top N rows when you only need a handful.

Each record includes the rate date, base currency, target currency, the rate itself (how many target units per one base unit), the auto-computed inverse rate (how many base units per one target unit), and the publisher's `time_last_update_utc` and `time_next_update_utc` so you know exactly when the feed refreshed.

> 💡 **Why it matters:** running an e-commerce checkout, an ERP revaluation, or a travel app means knowing today's USD-to-EUR (or USD-to-NGN, or USD-to-VND) rate without paying for a commercial FX API. open.er-api.com is free to use and updated daily. This Actor structures the response into one record per target currency, with inverse rates already computed.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>string</td><td><code>"latest"</code></td><td><code>latest</code> for live rates, <code>historical</code> for a single past date.</td></tr>
<tr><td><code>baseCurrency</code></td><td>string</td><td><code>"USD"</code></td><td>ISO 4217 code of the base currency.</td></tr>
<tr><td><code>targetCurrencies</code></td><td>string[]</td><td><code>[]</code></td><td>Optional list to restrict output. Empty = return all targets.</td></tr>
<tr><td><code>date</code></td><td>string</td><td><code>null</code></td><td>YYYY-MM-DD (required in historical mode).</td></tr>
</tbody>
</table>

**Example: latest USD rates against every currency.**

```json
{
    "maxItems": 200,
    "mode": "latest",
    "baseCurrency": "USD"
}
````

**Example: historical EUR rates for a specific date, restricted to majors.**

```json
{
    "maxItems": 10,
    "mode": "historical",
    "baseCurrency": "EUR",
    "targetCurrencies": ["USD", "GBP", "JPY", "CHF", "AUD"],
    "date": "2025-12-31"
}
```

> ⚠️ **Good to Know:** the underlying feed refreshes once per day on UTC. Intraday FX moves are not reflected. For sub-daily pricing, use a paid commercial FX provider. The Actor returns the publisher's `time_last_update_utc` and `time_next_update_utc` so you always know how fresh each rate is.

***

### 📊 Output

Each rate record contains **8 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📅 `date` | string (YYYY-MM-DD) | `"2026-05-13"` |
| 🪙 `baseCurrency` | string | `"USD"` |
| 🎯 `targetCurrency` | string | `"EUR"` |
| 💱 `rate` | number | `0.851881` |
| 🔁 `inverseRate` | number | `1.17387` |
| 🕒 `timeLastUpdate` | string | null | `"Wed, 13 May 2026 00:02:31 +0000"` |
| ⏭️ `timeNextUpdate` | string | null | `"Thu, 14 May 2026 00:02:31 +0000"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-13T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>💶 USD to EUR</strong></summary>

```json
{
    "date": "2026-05-13",
    "baseCurrency": "USD",
    "targetCurrency": "EUR",
    "rate": 0.851881,
    "inverseRate": 1.17387,
    "timeLastUpdate": "Wed, 13 May 2026 00:02:31 +0000",
    "timeNextUpdate": "Thu, 14 May 2026 00:02:31 +0000",
    "scrapedAt": "2026-05-13T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>💴 USD to JPY</strong></summary>

```json
{
    "date": "2026-05-13",
    "baseCurrency": "USD",
    "targetCurrency": "JPY",
    "rate": 157.585576,
    "inverseRate": 0.006346,
    "timeLastUpdate": "Wed, 13 May 2026 00:02:31 +0000",
    "timeNextUpdate": "Thu, 14 May 2026 00:02:31 +0000",
    "scrapedAt": "2026-05-13T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>💷 USD to GBP</strong></summary>

```json
{
    "date": "2026-05-13",
    "baseCurrency": "USD",
    "targetCurrency": "GBP",
    "rate": 0.738805,
    "inverseRate": 1.35354,
    "timeLastUpdate": "Wed, 13 May 2026 00:02:31 +0000",
    "timeNextUpdate": "Thu, 14 May 2026 00:02:31 +0000",
    "scrapedAt": "2026-05-13T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌐 | **Wide currency coverage.** 165+ ISO 4217 currencies, from majors to exotics. |
| 📅 | **Latest and historical.** Either today's rates or any past date in a single Actor. |
| 🔁 | **Inverse rates included.** No need to compute `1/rate` downstream. |
| 🕒 | **Publisher freshness.** Each record carries the source's last-update and next-update timestamps. |
| ⚡ | **Fast.** Latest mode finishes in under 5 seconds. |
| 🚫 | **No authentication.** Public open data feed, no API key required. |
| 💵 | **Free upstream.** open.er-api.com is community-funded and free to query. |

> 📊 Clean, structured FX feeds are the backbone of every multi-currency invoice, expense report, and global checkout.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | History | Setup |
|---|---|---|---|---|
| **⭐ Open ER-API FX Rates Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **165+** currencies | ✅ Any past date | ⚡ 2 min |
| Raw open.er-api.com | Free | All currencies | Yes | 🐢 You build the pipeline |
| Commercial FX APIs (Fixer, OpenExchangeRates) | $10-$100/month | 170+ | Yes | ⏳ Account setup |
| Central bank reference rates | Free | Limited | Yes | 🕒 One-by-one parsing |

Pick this Actor when you want a clean, structured FX feed with no infra, no key management, and one record per target currency.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Open ER-API FX Rates Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a base currency, choose latest or historical, and optionally restrict to specific targets.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the rates.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛒 E-commerce and multi-currency checkout

- Daily FX feed for product pricing
- Multi-currency cart totals at checkout
- Localized invoices with same-day rates
- Display reference rates next to product prices

</td>
<td width="50%" valign="top">

#### 📚 ERP, billing, and accounting

- Daily FX revaluation of foreign-denominated balances
- Vendor-invoice translation to base currency
- Month-end reporting in functional currency
- Cross-rate computation from inverse pairs

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🌍 Travel, payments, and fintech

- Travel-cost estimators with daily refresh
- Remittance-quote engines
- Card-conversion preview screens
- Currency-converter widgets

</td>
<td width="50%" valign="top">

#### 📰 Journalism and research

- Historical rate series for economic analysis
- Pegged-currency monitoring (HKD, BHD, JOD)
- Cross-rate calculations between any two currencies
- Datasets for finance and trade research

</td>
</tr>
</table>

***

### 🔌 Automating FX Rates Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A daily run aligned with the source's UTC refresh keeps your FX table in lockstep with the publisher.

***

### 🌟 Beyond business use cases

Currency data powers more than commercial workflows. The same structured records support research, education, and personal projects.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Long-run FX series for economics papers
- Course datasets for finance and international trade
- Pegged-currency stability studies
- Cross-rate exercises for quantitative methods classes

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal travel-budget trackers
- Hobbyist currency converters and watchlists
- Side-project pricing engines
- Crypto vs fiat dashboards using the inverse rate

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Donation accounting for international NGOs
- Field-budget translation for relief workers
- Investigative journalism on currency-controlled regimes
- Open-data exercises for civic-tech groups

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on multi-decade FX series
- Prototype expense-report tools that auto-revalue
- Test alerting agents that fire on threshold moves
- Validate localization mockups with live rates

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Open%20ER-API%20FX%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Open%20ER-API%20FX%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Open%20ER-API%20FX%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Open%20ER-API%20FX%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a base currency and mode, click Start, and the Actor calls the open.er-api.com REST endpoint, parses the rates dictionary, applies optional target filtering, computes inverse rates, and emits one record per target currency.

#### 📏 How accurate is the data?

The source aggregates rates from central banks and major forex providers and refreshes once per day on UTC. For business reporting and most consumer use cases, the precision is plenty. For sub-daily or tick-by-tick trading, use a streaming commercial FX API.

#### 🔁 How often is the dataset refreshed?

The upstream feed refreshes once per day. Every Actor run pulls the latest snapshot, so a daily schedule aligned with the source's UTC refresh keeps your data current.

#### 📅 Can I pull historical rates?

Yes. Set `mode: "historical"` and provide a `date` in YYYY-MM-DD format. The Actor returns the rate dictionary as of that day.

#### 🪙 Which currencies are supported?

165+ ISO 4217 currencies, including all majors (USD, EUR, JPY, GBP, CHF, AUD, CAD), pegged currencies (HKD, BHD, JOD, AED), emerging markets (INR, BRL, ZAR, TRY, MXN), and many smaller currencies.

#### 🔁 Why is `inverseRate` precomputed?

To save you from doing `1 / rate` everywhere downstream. The inverse is the rate from target back to base, useful for two-way conversion utilities.

#### ⏰ Can I schedule regular runs?

Yes. Apify Schedules supports any cron interval. A common pattern is one daily run at 00:30 UTC, shortly after the source publishes.

#### ⚖️ Is this data legal to use?

Yes. The source publishes under an open-data license that permits free use including for commercial purposes. Review the source's terms for redistribution.

#### 💼 Can I use this data commercially?

Yes. FX reference rates from open data sources are widely used in commercial products including e-commerce, ERP, and travel.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and unlocks scheduling.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

FX Rates Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Push rate alerts into channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe FX data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh rates into your ERP, or alert your team when a currency moves past a threshold.

***

### 🔗 Recommended Actors

- [**📈 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker and adviser registration records
- [**💼 Pitchbook Investors Scraper**](https://apify.com/parseforge/pitchbook-investors-scraper) - Private-market investor profiles
- [**💼 Pitchbook Funds Scraper**](https://apify.com/parseforge/pitchbook-funds-scraper) - PE and VC fund records
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Corporate and market press releases
- [**🏪 Stripe Marketplace Scraper**](https://apify.com/parseforge/stripe-marketplace-scraper) - Fintech app marketplace catalog

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more financial and reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by open.er-api.com, openexchangerates.org, or any rate publisher. All trademarks mentioned are the property of their respective owners. Only publicly available open exchange-rate data is collected.

# Actor input Schema

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

Latest live rates or historical for a specific date

## `baseCurrency` (type: `string`):

ISO 4217 code (e.g. USD, EUR, GBP). 165+ supported.

## `targetCurrencies` (type: `array`):

Filter to specific targets. Leave empty to return all 165+ rates.

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

YYYY-MM-DD (only used in historical mode)

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "mode": "latest",
  "baseCurrency": "USD",
  "targetCurrencies": [],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "mode": "latest",
    "baseCurrency": "USD",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/exchangerate-host-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 = {
    "mode": "latest",
    "baseCurrency": "USD",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/exchangerate-host-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "latest",
  "baseCurrency": "USD",
  "maxItems": 10
}' |
apify call parseforge/exchangerate-host-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/exchangerate-host-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "exchangerate.host FX Rates Scraper",
        "description": "Scrape currency exchange rates from exchangerate.host. Latest, historical, time-series for 170+ currencies. Convert any amount between any pair. No API key required.",
        "version": "0.0",
        "x-build-id": "RxybKsM6nhXe1PvVZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~exchangerate-host-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-exchangerate-host-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~exchangerate-host-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-exchangerate-host-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~exchangerate-host-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-exchangerate-host-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "latest",
                            "historical"
                        ],
                        "type": "string",
                        "description": "Latest live rates or historical for a specific date",
                        "default": "latest"
                    },
                    "baseCurrency": {
                        "title": "Base currency",
                        "type": "string",
                        "description": "ISO 4217 code (e.g. USD, EUR, GBP). 165+ supported.",
                        "default": "USD"
                    },
                    "targetCurrencies": {
                        "title": "Target currencies (optional)",
                        "type": "array",
                        "description": "Filter to specific targets. Leave empty to return all 165+ rates.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "date": {
                        "title": "Date (for historical mode)",
                        "type": "string",
                        "description": "YYYY-MM-DD (only used in historical mode)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
