DEV Community

Sukriti Vohra
Sukriti Vohra

Posted on

How a boutique advisory maintains currency cross-rate tables for client hedging

By Pradyumna Ghosh, Ghosh Para Capital Advisors, Siliguri

Data stamp. Every exchange rate in this article, and every figure calculated from one, comes from a single CurrencyScoop snapshot pulled on 19 November 2026. The provider timestamp is 07:52:19 UTC (13:22:19 IST). These are reference rates, not dealing quotes, and they will have moved since. The client examples are hypothetical.

When a client asks what a euro payment will cost in rupees, the answer should be a number with a date and a set of rules attached. Our home currency is the Indian rupee (INR). Our hedging watchlist has five currencies: the US dollar, euro, pound sterling, Japanese yen and Swiss franc. Six currencies make 30 directional pairs. If those pairs come from different sources, or from the same source at different moments, the table quietly contradicts itself.

This post sets out the method we use to keep the table consistent: one snapshot, one pivot currency, written assumptions, and checks that run on every refresh. The Python at the end is short enough to copy.

1. Pull one snapshot, not thirty quotes

One call goes to the CurrencyScoop latest-rates endpoint with USD as the base and the other five currencies as symbols. A second call, with INR as the base, is used only as a cross-check.

Table 1. Raw snapshot, as delivered

Currency Units per 1 USD (primary pull) Units per 1 INR (cross-check pull) Pulled
INR 93.3255633 (base) 19 Nov 2026, 07:52:19 UTC
USD 1 (base) 0.01071518 19 Nov 2026, 07:52:19 UTC
EUR 0.91113841 0.00976301 19 Nov 2026, 07:52:19 UTC
GBP 0.76024816 0.00814619 19 Nov 2026, 07:52:19 UTC
JPY 159.69790609 1.71119145 19 Nov 2026, 07:52:19 UTC
CHF 0.84330414 0.00903615 19 Nov 2026, 07:52:19 UTC

Both responses carry the same provider timestamp. If they did not, we would pull again rather than compare numbers from two different moments.

2. The assumptions, stated before the numbers

  1. One source. All rates come from the CurrencyScoop (CurrencyBeacon) latest-rates API. Nothing is patched in from a bank screen or a website.
  2. One snapshot. Every figure comes from responses stamped 07:52:19 UTC on 19 November 2026. A table never mixes timestamps.
  3. USD is the pivot. USD is the provider's default base. Every cross is derived as (column currency per USD) ÷ (row currency per USD).
  4. One rate per currency, treated as a mid. The provider returns a single rate with no bid or offer. We treat it as a mid-market reference. It is not executable and includes no bank margin, forward points or value-date convention.
  5. Inverses are calculated, never sourced. GBP per EUR is exactly 1 ÷ (EUR per GBP), so the table cannot disagree with itself.
  6. Quotation. The home-currency view gives INR per unit of foreign currency. In the matrix, each row is a fixed amount of the row currency: 100 INR, 1 USD, 1 EUR, 1 GBP, 100 JPY, 1 CHF. Low-value currencies are quoted per 100 so that four decimals still carry enough precision.
  7. Precision. Provider values are read as exact decimals. Arithmetic uses Python's decimal module at 34 significant digits. Rounding happens only for display: four decimal places, round-half-even.
  8. Cross-check. The INR quotes are compared with reciprocals of the INR-base pull. Differences must fall inside that pull's precision floor (section 3).
  9. Freshness. A table is a valid reference for the Indian business day on which it was pulled. Its timestamp travels with every figure, including in client notes.
  10. Scope. No official fixings, pegs, forward points or forecasts are blended in.

3. The home-currency view: rupees per unit

Table 2. INR per unit of foreign currency

Currency Quote unit INR via USD pivot INR direct (cross-check) Difference Precision floor Pulled
US dollar 1 USD 93.3256 93.3255 +0.0021 bp ±0.0047 bp 19 Nov 2026, 07:52:19 UTC
Euro 1 EUR 102.4274 102.4274 < 0.0001 bp ±0.0051 bp 19 Nov 2026, 07:52:19 UTC
Pound sterling 1 GBP 122.7567 122.7568 −0.0051 bp ±0.0061 bp 19 Nov 2026, 07:52:19 UTC
Japanese yen 100 JPY 58.4388 58.4388 < 0.0001 bp < 0.0001 bp 19 Nov 2026, 07:52:19 UTC
Swiss franc 1 CHF 110.6666 110.6666 −0.0042 bp ±0.0055 bp 19 Nov 2026, 07:52:19 UTC

The largest gap is 0.0051 bp, for sterling (pulled 19 Nov 2026). That is inside the precision floor of the cross-check data. The INR-base quotes arrive with eight decimal places. For a number as small as 0.00814619 pounds per rupee, that leaves six significant figures, so its reciprocal is only good to about ±0.006 bp. The gaps are rounding noise, not a disagreement. A gap outside the floor would stop the table until someone explained it.

Look at the USD row. The two values agree to within 0.0021 bp, yet they display as 93.3256 and 93.3255 (pulled 19 Nov 2026). A check that compared displayed numbers would raise a false alarm, so comparisons always use unrounded values.

4. The full cross-rate matrix

Read across. Each row is a fixed amount of the row currency. Each cell shows how many units of the column currency that amount buys at the snapshot.

Table 3. Cross-rate matrix (units of column currency per row amount)

Row amount INR USD EUR GBP JPY CHF Pulled
100 INR — 1.0715 0.9763 0.8146 171.1191 0.9036 19 Nov 2026, 07:52:19 UTC
1 USD 93.3256 — 0.9111 0.7602 159.6979 0.8433 19 Nov 2026, 07:52:19 UTC
1 EUR 102.4274 1.0975 — 0.8344 175.2729 0.9255 19 Nov 2026, 07:52:19 UTC
1 GBP 122.7567 1.3154 1.1985 — 210.0602 1.1092 19 Nov 2026, 07:52:19 UTC
100 JPY 58.4388 0.6262 0.5705 0.4761 — 0.5281 19 Nov 2026, 07:52:19 UTC
1 CHF 110.6666 1.1858 1.0804 0.9015 189.3717 — 19 Nov 2026, 07:52:19 UTC

Each cell is: row amount × (column currency per USD) ÷ (row currency per USD), using the unrounded values in Table 1.

5. Checks that run on every refresh

  1. Same timestamp. Both pulls must carry the same provider timestamp. Passed: both read 07:52:19 UTC, 19 Nov 2026.
  2. Cross-check inside the precision floor. Passed: each gap sat inside its own floor; the largest, sterling's 0.0051 bp, against ±0.0061 bp (pulled 19 Nov 2026).
  3. Identities at full precision. A/B × B/A = 1 and A/B × B/C × C/A = 1 for every combination of the six currencies. The largest residuals on this snapshot were 4 × 10⁻³⁴ and 1 × 10⁻³³ (pulled 19 Nov 2026), which is zero at working precision. These identities hold by construction, so they test the process rather than the market. If anyone types a number into the table by hand, they fail.
  4. Move alert (illustrative setting). If any INR quote moves more than 1.5% from the previous business day's snapshot, check the data first. If the move is real, review the client hedges it affects.
  5. Stale label (illustrative setting). On weekends and Indian holidays the last snapshot stays in use, labelled "stale since …", until a new pull replaces it.

Why we never chain displayed numbers

Four-decimal figures are fine for reading and bad for calculating. Using the rounded values from Table 3:

  • EUR → GBP → EUR: 0.8344 × 1.1985 = 1.0000284, which is 0.28 bp too high (pulled 19 Nov 2026).
  • USD → GBP → CHF → USD: 0.7602 × 1.1092 × 1.1858 = 0.9998830, which is 1.17 bp too low (pulled 19 Nov 2026).
  • 1 INR at four decimals: 0.0107 USD, and 0.0107 × 93.3256 = 0.9985839, which is 14.16 bp too low. Quoting per 100 INR fixes this: 1.0715 × 93.3256 ÷ 100 = 0.9999838, only 0.16 bp low (pulled 19 Nov 2026).

A basis point looks trivial, but it scales with the notional, and it means two reports built from the same snapshot can disagree. Every published figure is recomputed from the raw snapshot, never from another rounded figure.

6. Using the table in a hedging conversation

Both examples are hypothetical. The arithmetic uses the unrounded rates pulled on 19 Nov 2026; displayed rates are rounded.

Example A: the rupee cost of a sterling payment. A family has a GBP 25,000 university instalment due in about 90 days.

  • At 122.7567 INR per GBP (pulled 19 Nov 2026), the payment costs INR 3,068,918 (about ₹30.69 lakh).
  • A 3% move in GBP/INR either way changes that by about INR 92,068, giving a range of INR 2,976,850 to INR 3,160,985 (at rates pulled 19 Nov 2026).
  • A forward contract would fix a rate that differs from this reference. The difference is the forward points, driven largely by the interest-rate gap between INR and GBP, plus the bank's margin. Neither is in the table. The table frames the size of the risk. The bank's quote at booking sets the price.

Example B: a cross exposure. A client earns US dollars and owes EUR 10,000.

  • At 1.0975 USD per EUR (pulled 19 Nov 2026), the payment needs USD 10,975.28.
  • The risk sits in EUR/USD, not in either currency against the rupee. Looking only at the INR column would make it look like two exposures when it is really one. That is why the table carries the crosses as well as the rupee column. Whether and how to hedge depends on the client's mandate and the instruments available to them. The table only makes the exposure visible.

7. What the table is not

  • Not a dealing rate. There is no bid or offer, bank margin or settlement convention.
  • Not a forward curve. There are no forward points or interest differentials.
  • Not an official fixing. Official reference rates and bank closing rates are taken at other times and can differ from this snapshot.
  • Not a forecast. It is a dated photograph.

8. The routine, end to end

  1. Pull both snapshots in the same minute: base USD with the five symbols, then base INR.
  2. Store the raw JSON with the request parameters, the provider timestamp and the retrieval time in an append-only log.
  3. Check that the timestamps match and that the INR cross-check sits inside the precision floor.
  4. Derive the INR view and the matrix from the raw USD-base values only. Never hand-edit a cell.
  5. Validate the identities, then apply the move alert and the stale label.
  6. Label every table and every quoted figure with the pull date and the provider timestamp.
  7. Use the table as a reference. Executable prices come from the bank at the time of booking.

The code

# Rebuild the cross-rate matrix from one CurrencyScoop snapshot.
# Needs: pip install requests; set CURRENCY_API_KEY in your environment.
import os
from decimal import Decimal, getcontext, ROUND_HALF_EVEN

import requests

getcontext().prec = 34
URL = "https://api.currencybeacon.com/v1/latest"  # CurrencyScoop / CurrencyBeacon; confirm in your account docs
CCY = ["INR", "USD", "EUR", "GBP", "JPY", "CHF"]
SCALE = {"INR": Decimal(100), "JPY": Decimal(100)}  # rows quoted per 100 units

resp = requests.get(URL, params={
    "api_key": os.environ["CURRENCY_API_KEY"],
    "base": "USD",
    "symbols": "INR,EUR,GBP,JPY,CHF",
}, timeout=10)
resp.raise_for_status()
snap = resp.json(parse_float=Decimal)["response"]  # numbers parsed straight to Decimal
stamp = snap["date"]                                # provider timestamp: label every figure with it
per_usd = dict(snap["rates"], USD=Decimal(1))

def cross(row, col):
    """Units of col per SCALE[row] units of row, triangulated through USD."""
    return SCALE.get(row, Decimal(1)) * per_usd[col] / per_usd[row]

for row in CCY:
    cells = ["-" if row == col
             else str(cross(row, col).quantize(Decimal("0.0001"), ROUND_HALF_EVEN))
             for col in CCY]
    print(f"{SCALE.get(row, 1)} {row}", *cells, f"pulled {stamp}", sep=" | ")
Enter fullscreen mode Exit fullscreen mode

Run against the 19 Nov 2026 snapshot (07:52:19 UTC), this prints the rows of Table 3.

Sources

  • Exchange rates: CurrencyScoop (CurrencyBeacon) latest-rates API (currencybeacon.com). Request 1: base USD, symbols INR,EUR,GBP,JPY,CHF. Request 2: base INR, symbols USD,EUR,GBP,JPY,CHF. Both pulled 19 Nov 2026; provider timestamp 2026-11-19T07:52:19Z. Usage subject to the provider's terms.

Further reading on Stack Exchange

Retrieved 19 Nov 2026. Community discussions, not house policy.

Cross rates and triangulation

Precision and data handling

Hedging practice

General information only, not investment advice or a recommendation to deal. The examples are hypothetical. Rates are reference data pulled on 19 Nov 2026 and will have moved.

Top comments (0)