# Currency Exchange Rate Tracker — Real-Time & Historical FX (`gochujang/currency-exchange-tracker`) Actor

Real-time and historical exchange rates for 170+ currencies via the Fawaz Ahmed Currency API (no API key). Supports latest snapshot, date-range history up to 30 days, and multi-base comparison. Outputs per-pair records with converted amounts and currency metadata. Free, no sign-up required.

- **URL**: https://apify.com/gochujang/currency-exchange-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Currency Exchange Tracker do?

**Currency Exchange Rate Tracker** is an Apify Actor that fetches **real-time and historical forex exchange rates** for 170+ currencies — including all major fiat currencies, leading cryptocurrencies, and exotic pairs. Powered by the [Fawaz Ahmed Currency API](https://github.com/fawazahmed0/exchange-api), a free CDN-backed dataset updated daily, this **forex rates API** requires no API key, no account, and no rate-limit workarounds. It supports three modes: a **latest snapshot** of any base currency, a **historical date-range** fetch (up to 30 days of daily rates), and a **multi-base comparison** for side-by-side currency analysis — all in a single Actor run.

### Why use Currency Exchange Tracker?

As a zero-config **real-time FX data** source covering 170+ pairs, this Actor removes the usual friction of currency data pipelines. Key business use cases:

- **E-commerce localization** — display product prices in your customer's local currency. Pull the latest USD → EUR, GBP, JPY, KRW rates on demand without paying for a premium FX API subscription.
- **Portfolio valuation** — convert multi-currency holdings into a single base currency daily. Use the `converted_amount` field directly in your P\&L calculation.
- **Travel and budget apps** — build trip cost calculators with daily-updated rates for all destination currencies, with automatic CDN failover for reliability.
- **Historical FX research** — download up to 30 days of daily rates per run for backtesting, regression analysis, or regulatory reporting. Chain multiple runs for longer date ranges.
- **Multi-currency comparison** — use `comparison` mode to benchmark how EUR, GBP, JPY, CNY, and KRW each perform against USD in a single structured output.

### How to use Currency Exchange Tracker

1. **Open the Actor** on Apify Store and click **Try for free**.
2. **Choose a mode** — `latest` for today's rates, `historical` for a date range, or `comparison` for multi-base analysis.
3. **Set the base currency** — enter a 3-letter ISO 4217 code (e.g. `USD`, `EUR`, `BTC`).
4. **Select target currencies** — list specific targets or leave empty to fetch all 170+ currencies.
5. **Set a convert amount** (optional) — enter a value and each record will include the `converted_amount` field pre-calculated.
6. **Run and export** — results appear in the dataset tab as flat JSON records, ready to download as JSON, CSV, or XLSX.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `latest` | `latest` (today's rates), `historical` (date range), or `comparison` (multi-base) |
| `baseCurrency` | string | `USD` | **Base currency** ISO 4217 code |
| `targetCurrencies` | string list | `[]` (all) | Target currency codes. Empty = all 170+ currencies |
| `convertAmount` | number | `1` | Amount in base currency; each record returns `converted_amount = convertAmount × rate` |
| `dateFrom` | string | — | Start date for `historical` mode (YYYY-MM-DD) |
| `dateTo` | string | — | End date for `historical` mode (YYYY-MM-DD, max 30 days from `dateFrom`) |
| `comparisonBases` | string list | — | Base currencies to compare in `comparison` mode |

**Example — latest USD rates for 4 major currencies, converting $1,000:**

```json
{
  "mode": "latest",
  "baseCurrency": "USD",
  "targetCurrencies": ["EUR", "GBP", "JPY", "KRW"],
  "convertAmount": 1000
}
```

**Example — 15 days of historical EUR/USD and EUR/JPY rates:**

```json
{
  "mode": "historical",
  "baseCurrency": "EUR",
  "targetCurrencies": ["USD", "JPY"],
  "dateFrom": "2026-08-01",
  "dateTo": "2026-08-15"
}
```

### Output

```json
[
  {
    "base": "USD",
    "target": "EUR",
    "rate": 0.9182,
    "converted_amount": 918.20,
    "base_name": "United States Dollar",
    "target_name": "Euro",
    "date": "2026-09-02",
    "fetched_at": "2026-09-02T08:00:00Z"
  },
  {
    "base": "USD",
    "target": "KRW",
    "rate": 1328.45,
    "converted_amount": 1328450.00,
    "base_name": "United States Dollar",
    "target_name": "South Korean Won",
    "date": "2026-09-02",
    "fetched_at": "2026-09-02T08:00:00Z"
  }
]
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `base` | string | Base currency code (ISO 4217) |
| `target` | string | Target currency code |
| `rate` | float | **Exchange rate** — 1 unit of base = N units of target |
| `converted_amount` | float | `convertAmount × rate` (ready for direct display) |
| `base_name` | string | Full name of the base currency |
| `target_name` | string | Full name of the target currency |
| `date` | string | Rate date (YYYY-MM-DD) |
| `fetched_at` | string | ISO 8601 UTC timestamp of the API call |

### Cost estimation

This Actor uses **Pay-Per-Event (PPE)** pricing — you pay only for the currency pairs actually returned.

| Event | Price | Notes |
|-------|-------|-------|
| Actor start | $0.005 | Charged once per run |
| Per rate fetched | $0.001 | Per currency pair record returned |

| Typical run | Pairs | Estimated cost |
|-------------|-------|----------------|
| Latest rates, 10 currencies | 10 | **~$0.015** |
| Latest rates, all 170 currencies | 170 | ~$0.175 |
| Historical, 10 currencies × 30 days | 300 | ~$0.305 |
| Comparison, 5 bases vs USD | 5 | ~$0.010 |
| Daily monitor, 20 pairs × 30 days | 600 | ~$0.61/month |

### FAQ

**Does this Actor require an API key or account registration?**
No. The [Fawaz Ahmed Currency API](https://github.com/fawazahmed0/exchange-api) is free, MIT-licensed, and CDN-hosted. No sign-up, no key, no rate limits. The Actor uses automatic CDN failover (jsDelivr → Cloudflare Pages) for reliability.

**How current is the exchange rate data?**
Rates are updated **daily**, typically by early UTC morning. For truly real-time tick data (sub-minute updates), you would need a paid FX data provider. For daily operations, reporting, and analytics, this source is sufficient.

**Can I fetch more than 30 days of historical data?**
The `historical` mode supports up to 30 days per run. To fetch longer date ranges, schedule multiple sequential runs with non-overlapping `dateFrom`/`dateTo` windows, then merge the datasets downstream.

***

*Disclaimer: Exchange rate data is sourced from the Fawaz Ahmed Currency API and is updated daily. Rates may differ from live interbank rates by a small margin. This data is for informational and analytical purposes only and does not constitute financial advice. Always verify rates with your bank or broker before executing transactions.*

***

### Related actors

- [BIS Central Bank Rates](https://apify.com/gochujang/bis-central-bank-data) — Broad Real EER (effective exchange rate) indices for 60+ economies to complement spot FX rates
- [CFTC COT Tracker](https://apify.com/gochujang/cftc-cot-tracker) — Speculator positioning in EUR, JPY, GBP futures that drives FX rate movements
- [Korea Exchange Pulse](https://apify.com/gochujang/korea-exchange-pulse) — KRW/USD rate data alongside Korean equity markets for Asian FX context

### Feedback

If this actor powers your forex research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/currency-exchange-tracker#reviews)

***

**Keywords:** currency exchange rates, forex exchange rate API, real-time exchange rates, historical exchange rates, 170 currencies tracker, USD EUR GBP converter, multi-currency comparison, no API key exchange rates, fiat currency tracker, base currency converter, forex historical data, daily exchange rate scraper, free currency API

# Actor input Schema

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

ISO 4217 base currency code (e.g. USD, EUR, GBP). Case-insensitive.

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

ISO 4217 target currency codes. Leave empty to return all 170+ currencies.

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

latest — current snapshot; historical — date-range rates; comparison — compare multiple base currencies vs one target.

## `dateFrom` (type: `string`):

Start date for historical mode. Required when mode=historical.

## `dateTo` (type: `string`):

End date for historical mode (inclusive). Defaults to today. Max 30 days range.

## `comparisonBases` (type: `array`):

Multiple base currencies for comparison mode (e.g. USD, EUR, GBP). Uses baseCurrency as single target.

## `includeMetadata` (type: `boolean`):

Include full currency name (e.g. 'Euro') in each record.

## `convertAmount` (type: `number`):

Base amount to convert. The converted_amount field will show this value in each target currency.

## Actor input object example

```json
{
  "baseCurrency": "USD",
  "targetCurrencies": [
    "EUR",
    "GBP",
    "JPY",
    "KRW",
    "CNY",
    "CAD",
    "AUD",
    "CHF",
    "SGD",
    "HKD"
  ],
  "mode": "latest",
  "dateFrom": "",
  "dateTo": "",
  "comparisonBases": [
    "USD",
    "EUR",
    "GBP",
    "JPY",
    "CNY"
  ],
  "includeMetadata": true,
  "convertAmount": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "baseCurrency": "USD",
    "targetCurrencies": [
        "EUR",
        "GBP",
        "JPY",
        "KRW",
        "CNY",
        "CAD",
        "AUD",
        "CHF",
        "SGD",
        "HKD"
    ],
    "comparisonBases": [
        "USD",
        "EUR",
        "GBP",
        "JPY",
        "CNY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/currency-exchange-tracker").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 = {
    "baseCurrency": "USD",
    "targetCurrencies": [
        "EUR",
        "GBP",
        "JPY",
        "KRW",
        "CNY",
        "CAD",
        "AUD",
        "CHF",
        "SGD",
        "HKD",
    ],
    "comparisonBases": [
        "USD",
        "EUR",
        "GBP",
        "JPY",
        "CNY",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/currency-exchange-tracker").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 '{
  "baseCurrency": "USD",
  "targetCurrencies": [
    "EUR",
    "GBP",
    "JPY",
    "KRW",
    "CNY",
    "CAD",
    "AUD",
    "CHF",
    "SGD",
    "HKD"
  ],
  "comparisonBases": [
    "USD",
    "EUR",
    "GBP",
    "JPY",
    "CNY"
  ]
}' |
apify call gochujang/currency-exchange-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/currency-exchange-tracker"
        }
    }
}
```

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/uy5NXvwtIlpz2aKjW/builds/dGnShp76XbJl69Z1G/openapi.json