# Currency Strength Monitor: Which Currencies Are Moving (`precious_bathmat/currency-strength-monitor`) Actor

Which currencies are actually strengthening, measured against the whole basket rather than one pair. Strength ranking, change over several periods, annualised volatility and a correlation matrix, from official ECB reference rates. No API key.

- **URL**: https://apify.com/precious\_bathmat/currency-strength-monitor.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 currency reports

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

## Currency Strength Monitor: Which Currencies Are Moving

Not exchange rates. **Which currencies are actually strengthening**, and by how much.

Every other currency Actor returns rates. A rate is a fact about a *pair*, and a pair tells you nothing about which side moved. EUR/USD falling could be a weak euro or a strong dollar, and those call for opposite decisions. This Actor answers that question directly: one row per **currency**, measured against the whole basket, ranked strongest to weakest.

### What does this do?

It reads the European Central Bank's official daily reference rates, then derives what nobody else on the Store publishes:

```
 #  cur   strength%    1d%     1m%    vol%   trend            best pair
 1  USD       0.669   0.131   1.887   5.16   strengthening 1  USD/JPY
 2  CHF       0.496   0.409  -0.943   4.26   strengthening 3  CHF/JPY
 3  AUD       0.422  -0.308   0.947   4.44   weakening 2      AUD/JPY
 4  NZD       0.134   0.044  -3.082   5.28   strengthening 2  NZD/JPY
 5  EUR      -0.088  -0.138  -0.459   2.00   weakening 2      EUR/JPY
 6  CAD      -0.351  -0.195  -0.635   2.93   weakening 2      CAD/JPY
 7  GBP      -0.354  -0.138  -0.605   3.00   weakening 1      GBP/JPY
 8  JPY      -0.918   0.198   3.015   8.11   strengthening 2  JPY/GBP
```

One read of that table tells you the week was about **yen weakness** — every other currency's best pair is against the yen — and that the yen is also the most volatile thing in the basket at 8.11% annualised. No amount of staring at EUR/USD gives you that.

### Who is it for?

- **Traders** — a strength meter as data rather than a web widget, so it can drive a screen or a backtest
- **Treasury and finance teams** — annualised volatility per currency, which is the number that sizes a hedge
- **Anyone holding several positions** — the correlation matrix shows when two trades are really one bet
- **Analysts and researchers** — clean daily series from the central bank itself, no key, no scraping

### What data do you get?

One row per currency:

| Field | What it tells you |
|---|---|
| `strengthRank`, `strengthPercent` | Where it sits in the basket, and by how much it moved |
| `change1DPercent` … `change1YPercent` | One column per period you asked for |
| `annualisedVolatilityPercent` | Volatility from daily log returns, annualised over 252 trading days |
| `trendDirection`, `consecutiveDays` | Direction, and how many days it has run that way |
| `bestPair`, `worstPair` (+ their % change) | Where this currency gained and lost most |
| `strongestCorrelation`, `weakestCorrelation` | Its closest and most opposed partner |
| `ratePerEur` | The published ECB reference rate |

The run summary carries the **full correlation matrix**. Switching on cross rates writes every pair in the basket to a second dataset.

### How strength is calculated, and why it is done this way

A currency's value against the basket is the **geometric mean of its cross rates**, and strength is the change in that value over the period.

Geometric, not arithmetic, and that is not a detail. Averaging ratios arithmetically invents movement: a currency that halved against one and doubled against another would average `(0.5 + 2.0) / 2 = 1.25` and appear 25% stronger having gone nowhere. The geometric mean gives exactly 1.

**A worked example of why the basket matters.** Suppose the dollar and the pound both rise 10% against the euro on the same day. A euro-denominated view reports the dollar down 9.09%. But the dollar did not move against the pound at all. Measured against the basket, the dollar is down **4.65%** — the geometric average of a 9.09% fall and no change. That is the honest number, and it is the one in the table.

This also means **the euro itself can be measured**, even though every ECB rate is quoted against it. The euro is just another member of the basket.

### Example: the majors, September 2026

| Measured | Result |
|---|---|
| Currencies | 8 |
| Business days read | 80, from 3 June to 22 September 2026 |
| Run time | **4.5 s, 52 MB** |
| Failures | none |

A useful check on the arithmetic: strength is relative, so the scores should very nearly cancel. In the run above they sum to **+0.01**.

### What it refuses to do

- **No signals.** No buy, sell, or "strong buy". These are measurements of what has already happened, and nothing here forecasts.
- **No intraday data**, and none implied. See below.
- **No invented precision.** A currency with fewer than three usable observations gets `null` volatility rather than a number, and a single day's move is reported as a run of one, never as a trend.

### A limit worth knowing

**The ECB publishes one rate per currency per business day**, at about 16:00 CET. So:

- This is **daily analysis, not a live feed**. If you need ticks, this is the wrong tool and the README says so before you spend anything.
- **No weekend data.** Weekends and TARGET holidays are absent, which is why periods are counted in *trading days*: a month is 22 observations, not 30 calendar days.
- **Only dates where every currency in the basket has a rate are used**, because a basket value from a partial basket is a different measurement. One thinly published currency therefore limits the whole set, and the run summary says how many days survived.
- **Every rate is quoted against the euro**, so cross rates are derived. The arithmetic is exact, but the euro is the measurement base even when it is not in your basket.
- **One currency is deliberately not offered: the Bulgarian lev.** Bulgaria adopted the euro on 1 January 2026, so the ECB's last lev reference rate is 31 December 2025. A series that has ended can never share a usable date with a live one, so including it could only ever fail a run. Every other currency listed was checked and was current.
- **Strength is relative to the basket you chose.** Change the basket and every score changes, because a currency is only ever strong compared to something.

### Popular currency reports

Ready-made runs you can open and start, or copy as a starting point:

- [Currency Strength Meter](https://apify.com/precious_bathmat/currency-strength-monitor/examples/currency-strength-meter)
- [Daily Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/daily-currency-strength)
- [Currency Volatility Ranking](https://apify.com/precious_bathmat/currency-strength-monitor/examples/currency-volatility-ranking)
- [Currency Correlation Matrix](https://apify.com/precious_bathmat/currency-strength-monitor/examples/currency-correlation-matrix)
- [US Dollar Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/us-dollar-strength)
- [Euro Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/euro-strength)
- [British Pound Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/british-pound-strength)
- [Japanese Yen Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/japanese-yen-strength)
- [Commodity Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/commodity-currency-strength)
- [Emerging Market Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/emerging-market-currency-strength)
- [Asian Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/asian-currency-strength)
- [Nordic Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/nordic-currency-strength)
- [Central European Currency Strength](https://apify.com/precious_bathmat/currency-strength-monitor/examples/central-european-currency-strength)
- [Currency Cross Rates](https://apify.com/precious_bathmat/currency-strength-monitor/examples/currency-cross-rates)
- [One Year Currency Performance](https://apify.com/precious_bathmat/currency-strength-monitor/examples/one-year-currency-performance)

### Pricing

**$0.01 per currency** and **$0.0005 per cross rate** (only when cross rates are switched on).

The eight-currency run above costs **$0.08**, or about **$0.11** with all 56 cross rates.

### Input

| Field | Meaning |
|---|---|
| **Currencies** | The basket, from the 31 the ECB publishes. At least two |
| **Periods to measure** | One change column each, in trading days |
| **Rank strength over** | Which period drives the score and ranking |
| **Volatility window** | Business days of returns for volatility and correlation |
| **Include the correlation matrix** | Adds the matrix and each currency's closest partner |
| **Also output every cross rate** | Writes all pairs to a second dataset |

### Integrations

Results export to JSON, CSV, Excel and Google Sheets, or go straight into a sheet, a dashboard or a model through the Apify API, webhooks, Make, Zapier and n8n.

# Actor input Schema

## `currencies` (type: `array`):

The basket to compare. Strength is measured against these currencies and nothing else, so changing the basket changes every score. At least two are needed.

## `periods` (type: `array`):

Each one adds a change column. Measured in trading days, because the ECB publishes on business days only: a month is 22 observations, not 30 calendar days.

## `primaryPeriod` (type: `string`):

Which period the strength score and the ranking use. Must be one of the periods above. Defaults to the shortest one selected.

## `volatilityWindowDays` (type: `integer`):

How many business days of returns to use for annualised volatility and for the correlation matrix. 30 is about six calendar weeks.

## `includeCorrelations` (type: `boolean`):

Adds a full correlation matrix to the run summary, and each currency's most and least correlated partner to its row. Useful for spotting when two positions are really one bet.

## `includeCrossRates` (type: `boolean`):

Writes every pair in the basket to a second dataset with its rate and change. Each pair costs $0.0005.

## Actor input object example

```json
{
  "currencies": [
    "EUR",
    "USD",
    "GBP",
    "JPY",
    "CHF",
    "AUD",
    "CAD",
    "NZD"
  ],
  "periods": [
    "1d",
    "1w",
    "1m",
    "3m"
  ],
  "primaryPeriod": "1w",
  "volatilityWindowDays": 30,
  "includeCorrelations": true,
  "includeCrossRates": false
}
```

# Actor output Schema

## `currencies` (type: `string`):

Every currency in the basket, ranked strongest to weakest over the chosen period.

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

The correlation matrix, the dates read, and what the figures do and do not mean.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("precious_bathmat/currency-strength-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("precious_bathmat/currency-strength-monitor").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 '{}' |
apify call precious_bathmat/currency-strength-monitor --silent --output-dataset

```

## MCP server setup

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

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/qXJ7qQ75DP8olFKY9/builds/TGt3MlnVcAcHti75i/openapi.json
