How a Currency Strength Meter Works (With a Few Lines of JavaScript)

A currency strength meter answers a question a single chart cannot: when EUR/USD goes up, is the euro strong, is the dollar weak, or both? The math behind it is small enough to fit in one function. Here is how we compute it, with code you can run.

This post is from the Vunelix team. We use this method on our own currency strength page, but nothing below depends on our data.

The idea

Take the eight major currencies: USD, EUR, GBP, JPY, CHF, AUD, CAD and NZD. Every pair of them is a currency pair, which gives 8 × 7 / 2 = 28 pairs. For each pair you know the percentage change over some period (today, one week, one month).

A pair's change belongs to both of its currencies, with opposite signs. If EUR/USD rose 0.4%, that is +0.4 for EUR and -0.4 for USD. Do this for all 28 pairs and every currency collects seven numbers, one against each of the others. Their average is the currency's strength score.

The code

// changes: percentage change per pair over the same period, keyed "BASE/QUOTE"
function currencyStrength(changes) {
  const scores = {};
  const counts = {};

  for (const [pair, pct] of Object.entries(changes)) {
    const [base, quote] = pair.split('/');
    scores[base] = (scores[base] || 0) + pct;   // base gains when the pair rises
    scores[quote] = (scores[quote] || 0) - pct; // quote loses by the same amount
    counts[base] = (counts[base] || 0) + 1;
    counts[quote] = (counts[quote] || 0) + 1;
  }

  return Object.keys(scores)
    .map(ccy => ({ ccy, score: scores[ccy] / counts[ccy] }))
    .sort((a, b) => b.score - a.score);
}

A small example with three currencies:

currencyStrength({
  'EUR/USD': 0.40,
  'USD/JPY': -0.60,
  'EUR/JPY': -0.20,
});
// [ { ccy: 'JPY', score: 0.4 },
//   { ccy: 'EUR', score: 0.1 },
//   { ccy: 'USD', score: -0.5 } ]

The yen gained against both others, the dollar lost against both, and the euro sits in between. You can check it by hand: USD gets -0.40 from EUR/USD and -0.60 from USD/JPY, an average of -0.50.

Where the percentage changes come from

Compute each change from two prices of the same pair: (close - open) / open * 100, where "open" is the price at the start of your period. Two rules matter more than the formula:

1. Use the same time window for every pair. If one pair's "today" starts at midnight UTC and another's at the New York close, the scores are meaningless.
2. Use quotes from one source. Mixing feeds adds noise that looks like strength.

You do not need all 28 pairs from a feed. You can derive crosses from USD pairs (for example EUR/JPY = EUR/USD × USD/JPY), but deriving them from pairs that were quoted at slightly different moments adds small errors. If your source has the crosses, use them directly.

Things that are easy to get wrong

• Inverted quotes. Some feeds quote USD/EUR instead of EUR/USD. Normalize every pair to one direction before you sum, or the signs flip.
• One period is not enough. A currency that leads today but lags over a month is more likely bouncing than trending. Compute the scores for two or three periods and compare the rankings.
• Scores are relative. If every currency fell against gold, the meter will not show it, because it only compares the eight with each other.

Turning it into a heatmap

The same 28 numbers can be shown as an 8 × 8 matrix: rows are base currencies, columns are quote currencies, each cell is the pair's change, and the diagonal is empty. A row that is mostly green belongs to a strong currency. That is exactly what our currency heatmap draws, and the strength meter above is the same matrix collapsed into one number per row.

If you build your own, start with the function above and the two rules about time windows and sources. That is most of the work.