Currency Exchange Rate Tracker

What does Currency Exchange Rate Tracker do?

Currency Exchange Rate Tracker is an Apify actor that retrieves live foreign exchange rates for over 160 world currencies using the open ExchangeRate-API. It fetches the latest rates for any base currency you choose, computes both the direct and inverse rate for every currency pair, and optionally converts a specified monetary amount across all target currencies in a single run. The actor outputs one clean JSON record per currency pair, ready for spreadsheets, dashboards, financial models, or downstream automation.

The architecture is deliberately simple: a single HTTP request to the ExchangeRate-API returns all 160+ currency rates at once, and the actor filters, enriches, and formats the response into structured records. There are no pagination loops, no API keys, and no authentication of any kind. The result is an actor that completes in under 10 seconds, uses minimal compute, and delivers precise exchange rate data for immediate consumption.

Whether you need to monitor the USD/EUR rate on a daily schedule, track a basket of 10 currencies for international payroll processing, convert invoice amounts across multiple currencies simultaneously, or feed live rates into a financial dashboard, this actor handles it with zero configuration overhead.

Why use Currency Exchange Rate Tracker on Apify?

Building your own exchange rate pipeline means dealing with HTTP client setup, error handling, data normalization, scheduling infrastructure, and result storage. This actor eliminates all of that overhead:

• Zero configuration. No API keys, no account registration, no authentication tokens. Provide a base currency and the actor delivers results immediately.
• Scheduled monitoring. Use Apify's built-in scheduler to run the actor every hour, every day, or on any custom cron schedule. Each run creates a timestamped dataset, giving you a persistent historical record of rate movements without writing any infrastructure code.
• Instant integrations. Push results directly to Google Sheets, Slack, webhooks, Zapier, Make (Integromat), or any REST endpoint using Apify's native integrations. No middleware required.
• Structured output. Every run produces a clean JSON dataset with consistent field names and precise numeric values, ready for programmatic consumption without any parsing or transformation.
• Scalable and reliable. Runs on Apify's cloud infrastructure with automatic monitoring and dataset versioning. You never miss a data point, and you can access any historical run at any time.

Key features

• 160+ currencies supported -- All major, minor, and exotic currency codes including USD, EUR, GBP, JPY, CNY, CHF, CAD, AUD, INR, BRL, KRW, ZAR, MXN, and many more.
• Flexible base currency -- Set any supported currency as your base. Track rates from USD, EUR, GBP, JPY, or any other perspective.
• Target currency filtering -- Specify a comma-separated list of target currencies to retrieve only the pairs you care about, or leave the field blank to retrieve all 160+ rates in a single run.
• Amount conversion -- Provide a monetary amount and the actor calculates the exact converted value for every target currency, rounded to 2 decimal places. Ideal for payroll, invoicing, or travel budgets.
• Inverse rates included -- Every result record includes both the direct rate (1 base = X target) and the inverse rate (1 target = X base), so you always have both directions of the conversion without any manual calculation.
• 6-decimal-place precision -- Exchange rates are rounded to 6 decimal places for high-precision financial calculations.
• Timestamped results -- Each record includes the rate date, the full API update timestamp, and an extraction timestamp for complete auditability.
• No API key required -- Uses the open (free) tier of the ExchangeRate-API at open.er-api.com, which requires no registration or credentials.
• Lightweight and fast -- Runs with only 256 MB of memory and typically completes in 3-10 seconds with a single HTTP request.

Use cases

• International payroll and HR teams calculating salary conversions across multiple countries in a single run. Set the base to your company's reporting currency, list the target currencies for each office location, and provide the payroll amount for instant multi-currency breakdowns.
• E-commerce businesses monitoring cross-border pricing to ensure product prices remain competitive in different markets. Schedule daily runs to track how currency fluctuations affect your international margins.
• Financial analysts and treasury teams building currency dashboards and risk models that require daily snapshots of major and emerging-market exchange rates. Export to Google Sheets or pandas for charting and analysis.
• Travel agencies and corporate travel departments computing budget estimates in destination currencies. Provide the trip budget as the amount and get instant conversions for all relevant currencies.
• Freelancers and remote workers billing in one currency and receiving payment in another. Track the rate between your invoice currency and bank currency to time conversions favorably.
• Developers building fintech applications who need a reliable, structured exchange rate feed without managing API keys, rate limits, or infrastructure. Call the Apify API to trigger runs and retrieve results programmatically.
• Academic researchers studying currency correlations, purchasing power parity, or international trade dynamics. Combine scheduled runs over time with the Historical Exchange Rate Data actor for comprehensive time-series datasets.
• Accounting and compliance teams needing daily reference rates for multi-currency financial reporting, month-end close processes, or tax calculations that require documented exchange rate sources.

How to use Currency Exchange Rate Tracker

1. Go to the actor page -- Navigate to Currency Exchange Rate Tracker on the Apify Store and click Try for free to open it in Apify Console.
2. Set your base currency -- Enter a three-letter ISO 4217 currency code (e.g., USD, EUR, GBP). Defaults to USD if left empty.
3. Optionally filter target currencies -- Enter a comma-separated list such as EUR,GBP,JPY,CNY,CHF to limit results to specific pairs. Leave empty to get all available currencies.
4. Optionally enter an amount -- Provide a number (e.g., 1000) to calculate converted values for each target currency in the output.
5. Click Start and wait a few seconds for results.
6. Download or export the dataset in JSON, CSV, Excel, or connect it to an integration.

Using the Apify API

You can run the actor programmatically via the Apify API:

curl -X POST "https://api.apify.com/v2/acts/ryanclinton~exchange-rate-tracker/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"baseCurrency": "EUR", "targetCurrencies": "USD,GBP,JPY,CHF", "amount": 5000}'

Scheduling

To track rates over time, set up an Apify schedule to run the actor at your desired interval (e.g., every hour, every day at 9:00 AM UTC). Each run creates a new dataset, giving you a complete historical record of exchange rate movements.

Input parameters

Parameter	Type	Required	Default	Description
baseCurrency	String	No	USD	The base currency code (ISO 4217). Examples: USD, EUR, GBP, JPY, CNY. All returned rates express how many units of the target currency equal 1 unit of this base.
targetCurrencies	String	No	All currencies	Comma-separated list of target currency codes to retrieve. Leave empty to return all 160+ currencies. Example: EUR,GBP,JPY,CNY,CHF,CAD,AUD,KRW,INR,BRL.
amount	Number	No	None	An amount in the base currency to convert. When provided, each result includes the calculated convertedAmount field rounded to 2 decimal places.

Example input configurations

Major currency pairs from USD with amount conversion:

{
    "baseCurrency": "USD",
    "targetCurrencies": "EUR,GBP,JPY,CNY,CHF,CAD,AUD",
    "amount": 10000
}

All currencies from EUR base (no filtering):

{
    "baseCurrency": "EUR"
}

Emerging market currencies from GBP:

{
    "baseCurrency": "GBP",
    "targetCurrencies": "INR,BRL,ZAR,TRY,MXN,THB,IDR,PHP",
    "amount": 5000
}

Output example

Each run produces a dataset with one record per currency pair. Below is a realistic example of the JSON output when running with baseCurrency: "USD", targetCurrencies: "EUR,GBP,JPY,CHF,CAD", and amount: 1000:

[
  {
    "baseCurrency": "USD",
    "targetCurrency": "EUR",
    "rate": 0.924132,
    "inverseRate": 1.082089,
    "convertedAmount": 924.13,
    "date": "17 Feb 2026",
    "lastUpdated": "Mon, 17 Feb 2026 00:02:31 +0000",
    "extractedAt": "2026-02-17T14:23:45.123Z"
  },
  {
    "baseCurrency": "USD",
    "targetCurrency": "GBP",
    "rate": 0.792541,
    "inverseRate": 1.261761,
    "convertedAmount": 792.54,
    "date": "17 Feb 2026",
    "lastUpdated": "Mon, 17 Feb 2026 00:02:31 +0000",
    "extractedAt": "2026-02-17T14:23:45.124Z"
  },
  {
    "baseCurrency": "USD",
    "targetCurrency": "JPY",
    "rate": 151.874302,
    "inverseRate": 0.006584,
    "convertedAmount": 151874.30,
    "date": "17 Feb 2026",
    "lastUpdated": "Mon, 17 Feb 2026 00:02:31 +0000",
    "extractedAt": "2026-02-17T14:23:45.125Z"
  },
  {
    "baseCurrency": "USD",
    "targetCurrency": "CHF",
    "rate": 0.903214,
    "inverseRate": 1.107162,
    "convertedAmount": 903.21,
    "date": "17 Feb 2026",
    "lastUpdated": "Mon, 17 Feb 2026 00:02:31 +0000",
    "extractedAt": "2026-02-17T14:23:45.126Z"
  },
  {
    "baseCurrency": "USD",
    "targetCurrency": "CAD",
    "rate": 1.357892,
    "inverseRate": 0.736433,
    "convertedAmount": 1357.89,
    "date": "17 Feb 2026",
    "lastUpdated": "Mon, 17 Feb 2026 00:02:31 +0000",
    "extractedAt": "2026-02-17T14:23:45.127Z"
  }
]

Output fields explained

Field	Type	Description
baseCurrency	String	The base currency code used for the query (e.g., USD, EUR).
targetCurrency	String	The target currency code for this rate pair (e.g., GBP, JPY).
rate	Number	The direct exchange rate: 1 unit of base = this many units of target. Rounded to 6 decimal places.
inverseRate	Number	The inverse exchange rate: 1 unit of target = this many units of base. Rounded to 6 decimal places.
convertedAmount	Number or null	The converted amount if an amount was provided in the input. Rounded to 2 decimal places. null if no amount was specified.
date	String	The date of the exchange rate in human-readable format (e.g., 17 Feb 2026).
lastUpdated	String	Full UTC timestamp of when the exchange rate data was last updated by the API provider.
extractedAt	String	ISO 8601 timestamp of when the actor extracted and processed the data.

Data source

This actor retrieves exchange rate data from the ExchangeRate-API (open.er-api.com), a widely used open exchange rate service. Key characteristics of this data source:

• Update frequency: Rates are refreshed approximately once every 24 hours, typically around midnight UTC.
• Currency coverage: Over 160 currencies are available, significantly more than institutional sources like the ECB (approximately 30 currencies).
• Base currency flexibility: Any supported currency can be used as the base, unlike the ECB which only supports EUR as base.
• Data origins: The ExchangeRate-API aggregates data from central banks and commercial sources to provide representative mid-market rates.
• Access model: The open tier requires no API key, no registration, and no authentication. It is rate-limited but generous enough for typical Apify actor usage patterns.
• Reliability: The service has been operational since 2010 and serves millions of requests. However, since it is a free tier, it does not carry the same SLA guarantees as paid commercial forex data providers.

For compliance-grade rates that carry official institutional backing, consider using the ECB Exchange Rates actor instead, which sources directly from the European Central Bank.

Technical details

Understanding the actor's internal architecture can help you use it more effectively and interpret the output correctly.

Single-request architecture

The actor makes exactly one HTTP GET request to open.er-api.com/v6/latest/{BASE} per run. This endpoint returns exchange rates for all 160+ currencies in a single JSON response. There is no pagination, no batching, and no retry loop needed. This is the simplest possible architecture for an exchange rate actor, which is why runs complete in under 10 seconds regardless of how many currencies you request.

Rate precision

All exchange rates are rounded to 6 decimal places using the formula Math.round(rate * 1000000) / 1000000. This avoids floating-point artifacts while preserving sufficient precision for financial calculations. For example, a raw rate of 0.9241323456789 becomes 0.924132.

Inverse rate computation

Every output record includes both the direct rate and its mathematical inverse. The inverse rate is computed as Math.round((1 / rate) * 1000000) / 1000000, giving you both directions of the conversion without a separate API call. For example, if USD/EUR is 0.924132, the inverse EUR/USD is 1.082089.

Amount conversion

When you provide an amount input parameter, the actor computes Math.round(amount * rate * 100) / 100 for each currency pair. The result is rounded to 2 decimal places, matching standard monetary precision. If no amount is provided, the convertedAmount field is set to null.

Target filtering

If you specify targetCurrencies, the actor splits the string by commas, converts each code to uppercase, trims whitespace, and validates each code against the available rates. Invalid codes produce a warning in the logs and are skipped. If targetCurrencies is left empty, the actor outputs every available currency except the base currency itself, sorted alphabetically.

Date extraction

The rate date is extracted from the API response's time_last_update_utc field. If that field is missing for any reason, the actor falls back to computing the date from time_last_update_unix * 1000. The lastUpdated field preserves the full UTC timestamp string, while the date field extracts just the human-readable date portion.

Major currency codes reference

Below is a reference table of the most commonly used ISO 4217 currency codes. The actor supports all of these plus 130+ additional currencies.

Code	Currency	Region
USD	United States Dollar	North America
EUR	Euro	Eurozone
GBP	British Pound Sterling	United Kingdom
JPY	Japanese Yen	Japan
CNY	Chinese Yuan Renminbi	China
CHF	Swiss Franc	Switzerland
CAD	Canadian Dollar	Canada
AUD	Australian Dollar	Australia
NZD	New Zealand Dollar	New Zealand
HKD	Hong Kong Dollar	Hong Kong
SGD	Singapore Dollar	Singapore
KRW	South Korean Won	South Korea
INR	Indian Rupee	India
BRL	Brazilian Real	Brazil
MXN	Mexican Peso	Mexico
ZAR	South African Rand	South Africa
TRY	Turkish Lira	Turkey
SEK	Swedish Krona	Sweden
NOK	Norwegian Krone	Norway
DKK	Danish Krone	Denmark
PLN	Polish Zloty	Poland
THB	Thai Baht	Thailand
IDR	Indonesian Rupiah	Indonesia
MYR	Malaysian Ringgit	Malaysia
PHP	Philippine Peso	Philippines
RUB	Russian Ruble	Russia
SAR	Saudi Riyal	Saudi Arabia
AED	UAE Dirham	United Arab Emirates
TWD	New Taiwan Dollar	Taiwan
CLP	Chilean Peso	Chile

How much does it cost to use?

Currency Exchange Rate Tracker is extremely lightweight and inexpensive to run on the Apify platform:

• Memory: 256 MB (the minimum allocation)
• Typical run time: 3-10 seconds
• Compute units per run: Approximately 0.001 CU

Usage Scenario	Runs/Month	Estimated Cost	Free Tier Coverage
Daily rate check (1 run/day)	30	~$0.03	Fully covered
Hourly monitoring (24 runs/day)	720	~$0.72	Fully covered
Multiple base currencies (3x daily)	90	~$0.09	Fully covered
Burst usage (10 runs/hour, business hours)	~2,000	~$2.00	Mostly covered

Apify Free Tier: New Apify accounts receive $5 of free platform credits each month. That is more than enough to run this actor thousands of times at no cost. You can track exchange rates hourly for an entire month without spending anything.

There are no additional costs from the data source. The ExchangeRate-API open tier is completely free and requires no API key.

Tips for best results

• Use specific target currencies when you only need a few pairs. This keeps your dataset clean and focused rather than dumping all 160+ currencies into every run. A focused dataset is easier to work with in spreadsheets and downstream integrations.
• Schedule daily or hourly runs to build a historical dataset of rate movements over time. Each run creates a new timestamped dataset that you can compare across runs to analyze trends.
• Combine with amount conversion by setting the amount field. This is especially useful for calculating payroll in multiple currencies, converting invoice totals, or computing travel budgets across several destinations simultaneously.
• Use uppercase ISO 4217 codes for all currencies. The actor automatically uppercases your input, but using standard codes like USD, EUR, GBP from the start avoids confusion.
• Export to CSV or Excel for quick analysis in a spreadsheet. Apify datasets support one-click export in JSON, CSV, Excel, and XML formats.
• Set up webhooks to trigger notifications or downstream processing whenever new rate data is available. For example, alert a Slack channel when the USD/EUR rate moves beyond a threshold.
• Remember that rates update once per day. The underlying ExchangeRate-API updates rates approximately once every 24 hours around midnight UTC. Running the actor more frequently than daily will return the same rates until the next API update. Hourly scheduling is still useful for ensuring you capture the update as soon as it happens.
• Pair with Historical Exchange Rate Data for time series analysis. Use this actor for current rates and the companion actor for past dates and historical trends.

FAQ

What currencies are supported? Over 160 currencies are supported, including all major world currencies (USD, EUR, GBP, JPY, CNY, CHF, AUD, CAD), regional currencies (INR, BRL, KRW, MXN, ZAR, TRY), and many exotic currencies. The full list depends on the upstream ExchangeRate-API, which sources its data from a blend of central bank and commercial exchange rate feeds.

How often are the rates updated? The underlying ExchangeRate-API updates rates approximately once per day, typically around midnight UTC. The lastUpdated field in each output record shows the exact update time so you always know how fresh the data is.

Do I need an API key? No. This actor uses the open (free) tier of the ExchangeRate-API at open.er-api.com, which requires no registration, no API key, and no authentication of any kind.

Can I use any currency as the base? Yes. Any of the 160+ supported currency codes can be used as the base currency. Simply enter the three-letter ISO 4217 code in the baseCurrency field. The API adjusts all rates relative to your chosen base.

What happens if I enter an invalid currency code? If a target currency code is not recognized, the actor logs a warning and skips that code. The remaining valid codes are still processed normally. If the base currency code is invalid, the API returns an error and the actor reports it clearly in the logs.

Can I convert a specific amount? Yes. Set the amount input parameter to any number and the actor calculates the converted value for every target currency pair. For example, setting baseCurrency: "USD" and amount: 5000 will show you exactly how much 5,000 USD is worth in each target currency.

What is the rate precision? Exchange rates are rounded to 6 decimal places for high-precision calculations. Converted amounts are rounded to 2 decimal places, matching standard monetary formatting.

What is the difference between rate and inverseRate? The rate field tells you how many units of the target currency you get for 1 unit of the base currency (e.g., 1 USD = 0.924 EUR). The inverseRate tells you the reverse: how many units of the base currency you get for 1 unit of the target currency (e.g., 1 EUR = 1.082 USD). Both are provided in every record so you never need to calculate the reverse direction manually.

Can I track rate changes over time? Yes. Schedule the actor to run at regular intervals and each run stores a timestamped dataset. You can then compare datasets across runs to analyze rate trends, detect volatility, or trigger alerts when rates cross a threshold.

How does this differ from the ECB Exchange Rates actor? This actor uses the ExchangeRate-API and supports 160+ currencies with any base currency. The ECB Exchange Rates actor uses the European Central Bank's SDMX API and supports approximately 30 currencies with EUR as the only base. Use this actor when you need broader currency coverage or a non-EUR base currency. Use the ECB actor when you need official EU reference rates for compliance, accounting, or regulatory purposes.

How does this differ from the Historical Exchange Rate Data actor? This actor fetches only the latest (current) exchange rates. The Historical Exchange Rate Data actor supports three modes: latest rates, rates for a specific past date, and full time series across a date range. If you need to look up what the USD/EUR rate was on a specific date in the past, or generate a daily rate series for the last year, use the historical actor. If you just need today's rates, this actor is the simpler and faster choice.

Are these rates suitable for financial transactions? These rates are mid-market reference rates suitable for informational purposes, budgeting, analytics, and approximate conversions. They are not real-time interbank rates and should not be used as the sole basis for actual financial transactions. Banks and payment processors apply their own spreads and fees on top of mid-market rates.

What happens if the API is temporarily unavailable? If the ExchangeRate-API returns an error or is unreachable, the actor throws a descriptive error with the HTTP status code and response body. The run will fail, and you can configure Apify to retry automatically or alert you via webhook.

Integrations

Currency Exchange Rate Tracker works seamlessly with Apify's built-in integrations and third-party automation tools:

• Apify API -- Trigger runs programmatically using the Apify API from Python, Node.js, or any language. Retrieve datasets as JSON, CSV, or XML for automated pipelines.
• Google Sheets -- Automatically export exchange rates to a spreadsheet for dashboards, pivot tables, or portfolio tracking. Use the Apify Google Sheets integration to update a sheet after each run.
• Zapier -- Connect exchange rate data to 5,000+ apps. Build workflows that check rates on a schedule, compare against thresholds, and send notifications to Slack, email, or SMS.
• Make (Integromat) -- Build multi-step workflows that pull exchange rate data, filter by rate movement, and route results to Google Sheets, Airtable, Notion, or CRM systems.
• Webhooks -- Configure Apify webhooks to fire when a run completes. Send the full dataset to any HTTP endpoint for real-time processing, database ingestion, or triggering downstream systems.
• Python and Jupyter -- Use the apify-client Python package to pull exchange rate datasets into pandas DataFrames for analysis, charting, or integration with financial models.

Related actors

• Historical Exchange Rate Data -- Retrieves exchange rates for specific past dates and generates full time series across date ranges using the Frankfurter API. The ideal companion when you need historical trends, not just today's rates.
• ECB Exchange Rates -- Official euro foreign exchange reference rates from the European Central Bank. Best for compliance, regulatory reporting, and EU-sourced reference rates with daily, monthly, or annual frequency.
• CoinGecko Crypto Data -- Cryptocurrency prices, market cap, volume, and historical data from CoinGecko covering 15,000+ coins. Use alongside this actor for a complete fiat + crypto rate monitoring setup.
• Finnhub Stock Market Data -- Real-time stock quotes, historical candles, company profiles, and financial metrics. Combine with exchange rate data for cross-currency portfolio valuation and international equity analysis.