What Are Nostro and Vostro Accounts? A Developer's Guide to Correspondent Banking

If you have ever built a payments feature and wondered how money actually crosses a border, the answer almost always involves two accounts with strange Latin names: nostro and vostro. They are the plumbing behind every international wire, remittance, and multi-currency payout. Most explanations of nostro and vostro accounts stop at a dictionary definition. This guide goes further: it explains the concept in plain language, walks through a worked double-entry example, and then shows you how to model, value, and reconcile these balances in code using a currency exchange rate API. If you build fintech, treasury, or accounting software, this is the mental model you need.

What Are Nostro and Vostro Accounts?

Nostro and vostro come from Italian (via Latin): nostro means "ours" and vostro means "yours." They are two labels for the same account, seen from opposite sides of a banking relationship.

• A nostro account is "our money held with you." It is an account a bank holds at a foreign bank, denominated in the foreign currency. From the home bank's books, it is an asset.
• A vostro account is "your money held with us." It is the exact same account viewed by the bank that holds the funds. On that bank's books, it is a liability.

The critical insight for a developer: nostro and vostro are not two different accounts — they are one account described from two perspectives. What Bank A calls its USD nostro at Bank B, Bank B calls its vostro for Bank A. Same balance, same transactions, two ledgers, opposite signs.

Here is the canonical example. A German bank needs to make US-dollar payments for its customers, but it has no branch in the United States and no direct access to US dollar clearing. So it opens a USD account at a US correspondent bank and keeps dollars there.

• To the German bank, that USD account is a nostro ("our dollars, sitting over there").
• To the US bank, that same account is a vostro ("the Germans' dollars, sitting here with us").

Nostro vs Vostro: The Key Difference

The distinction is entirely about point of view. This table captures it:

Where the Loro Account Fits In

You will occasionally see a third term, loro ("theirs"). A loro account is not a new kind of account — it is a reference one bank uses when talking about an account that belongs to two other banks. If Bank A discusses the account that Bank B holds for Bank C, Bank A calls it a loro account. It matters mostly for SWIFT message clarity in multi-bank payment chains; you rarely need to model it directly.

Why These Accounts Exist: Correspondent Banking

No bank has a branch in every country, and no bank has direct membership in every country's domestic clearing system. Correspondent banking solves this. A smaller "respondent" bank partners with a larger "correspondent" bank that does have local access, and pre-funds a nostro account there. Now the respondent can offer payments in that currency without ever setting up local infrastructure.

A single large bank may maintain dozens of nostro accounts around the world — one per currency it needs to settle in — each a pre-funded pool of liquidity. On the other side, a major correspondent runs hundreds of vostro accounts for respondent banks globally. The instructions that move balances between these accounts travel over the SWIFT network as standardized messages (increasingly in the ISO 20022 format).

This is why a "simple" cross-border payment can touch three or four banks, take one to three days, and lose a slice to fees and FX spread along the way. Every hop is a debit and credit against a nostro or vostro balance somewhere.

A Worked Example: Double-Entry Across a Nostro/Vostro Pair

Concepts get concrete fast when you follow the money. Suppose FNBA (a bank in Australia) holds a USD nostro at CMB (a US bank). FNBA sells AUD 1,000,000 to a customer, C, in exchange for USD 2,000,000 at an agreed rate.

On FNBA's ledger (its nostro is an asset in USD):

Dr  USD Nostro @ CMB          2,000,000 USD
    Cr  FX Trading (USD)          2,000,000 USD

Dr  FX Trading (AUD)          1,000,000 AUD
    Cr  Customer C (AUD)          1,000,000 AUD

On CMB's ledger, the very same USD account is a vostro (a liability it owes FNBA):

Dr  Customer C (USD)          2,000,000 USD
    Cr  FNBA Vostro (USD)         2,000,000 USD

Notice the mirror: FNBA debits its nostro to record more dollars it owns; CMB credits the identical vostro to record more dollars it owes. Sum both banks' views of the account and, by design, they reconcile to zero. That mirroring is the whole point — and it is exactly what your reconciliation code will exploit.

Modeling Nostro/Vostro Balances as a Developer

If you are building treasury, ledger, or payments software, you do not need to be a bank to use this model. Any system that holds balances in multiple currencies on behalf of others — a multi-currency wallet, a marketplace payout engine, a neobank ledger — faces the same problem: you hold real balances in several currencies and must report their combined value in one home currency.

Start with a minimal schema. Each nostro-style balance is just a currency, an amount, and the counterparty holding it:

CREATE TABLE nostro_balances (
    id            BIGSERIAL PRIMARY KEY,
    correspondent TEXT NOT NULL,        -- who holds the funds
    currency      CHAR(3) NOT NULL,     -- ISO 4217 code, e.g. 'USD'
    balance       NUMERIC(20,4) NOT NULL DEFAULT 0,
    updated_at    TIMESTAMPTZ NOT NULL DEFAULT now()
);

The moment you hold more than one currency, a reporting question appears: what is the total worth in our home currency right now? You cannot add USD, EUR, and JPY together — you must first value each balance at the current exchange rate. That is where a currency API earns its place. Here is a Python function that values a set of nostro balances in a chosen home currency:

import requests

FINEXLY_KEY = "YOUR_API_KEY"

def value_nostros(balances, home="EUR"):
    """balances: dict of {currency: amount}. Returns total in `home`."""
    symbols = ",".join(c for c in balances if c != home)
    resp = requests.get(
        "https://api.finexly.com/v1/latest",
        params={"base": home, "symbols": symbols},
        headers={"Authorization": f"Bearer {FINEXLY_KEY}"},
        timeout=5,
    )
    resp.raise_for_status()
    rates = resp.json()["rates"]   # e.g. {"USD": 1.0842, "JPY": 161.4}

    total = 0.0
    for currency, amount in balances.items():
        if currency == home:
            total += amount
        else:
            # rates[X] = units of X per 1 home unit, so divide to convert back
            total += amount / rates[currency]
    return round(total, 2)

nostros = {"USD": 2_000_000, "JPY": 500_000_000, "GBP": 750_000}
print(value_nostros(nostros, home="EUR"))

The API call returns a clean rates object — {"base": "EUR", "date": "2026-08-08", "rates": {"USD": 1.0842, ...}} — so converting each foreign balance back into the home currency is a single division. For a full breakdown of the endpoint and its parameters, see the exchange rate API documentation, and if you are new to it, the free currency API tier is enough to prototype the whole thing.

Nostro Reconciliation and FX Gain/Loss

Two problems dominate real nostro operations, and both are squarely a developer's job.

1. Reconciliation. Because a nostro and its mirror vostro must agree, reconciliation means matching your internal record of the account against the statement the correspondent sends (today, typically a SWIFT MT940/camt.053 statement). Every entry on your books should have a corresponding entry on theirs. Breaks — an entry on one side but not the other — signal a missing, duplicated, or delayed transaction that needs investigating before it becomes a liquidity or compliance problem. The mirror property from the worked example above is what makes automated matching possible.

2. FX revaluation. A nostro balance is held in a foreign currency, but you report in your home currency. Because exchange rates move, the home-currency value of a static foreign balance changes every day. That difference is an unrealized FX gain or loss, and accounting standards require you to recognize it. The pattern: snapshot the rate when the balance was established, compare it to today's rate, and book the difference.

const FINEXLY_KEY = "YOUR_API_KEY";

async function fxGainLoss(currency, amount, rateAtBooking, home = "EUR") {
  const url = `https://api.finexly.com/v1/latest?base=${home}&symbols=${currency}`;
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${FINEXLY_KEY}` },
  });
  const { rates } = await res.json();
  const currentRate = rates[currency];        // currency units per 1 home unit

  const valueAtBooking = amount / rateAtBooking;
  const valueNow = amount / currentRate;
  return {
    home,
    valueAtBooking: +valueAtBooking.toFixed(2),
    valueNow: +valueNow.toFixed(2),
    unrealizedPnl: +(valueNow - valueAtBooking).toFixed(2),
  };
}

// 2,000,000 USD booked at 1.0800, revalued at today's rate
fxGainLoss("USD", 2_000_000, 1.08).then(console.log);

For period-end reporting and audit trails you will also want historical rates, not just live ones — pulling the exact closing rate for a past date. That is what a historical exchange rates endpoint is for, and it is essential for reproducing a month-end revaluation months later. As your balance count and reconciliation frequency grow, check the pricing plans to size your request volume; a treasury dashboard refreshing dozens of currencies every few minutes adds up quickly.

If you want to expose live conversions to end users on top of these balances — say, letting a customer see a payout quoted in their own currency — a hosted currency converter or the same latest endpoint powers it directly.

Modern Alternatives: Where Nostro/Vostro Is Heading

The nostro/vostro model is centuries old and still runs the majority of cross-border value, but the friction — pre-funded liquidity trapped in dozens of accounts, multi-day settlement, opaque fees — has pushed the industry toward alternatives:

1. SWIFT gpi adds end-to-end tracking and same-day settlement on top of the existing correspondent rails, without replacing the accounts.
2. Stablecoins and tokenized deposits let institutions settle in minutes without pre-funding a nostro in every currency, though regulatory clarity is still catching up.
3. CBDCs and wholesale settlement pilots (several central banks are testing cross-border corridors) aim to shorten the chain of intermediaries entirely.

For most software you will build in the next few years, though, the accounts — and the reconciliation and revaluation logic above — are not going anywhere. Understanding them is a durable skill.

Frequently Asked Questions

What is the difference between a nostro and a vostro account? They are the same account seen from two sides. A nostro is "our money held with you" (an asset, in foreign currency) from the owning bank's view; a vostro is "your money held with us" (a liability, in local currency) from the holding bank's view.

Is a nostro account an asset or a liability? A nostro account is an asset on the owning bank's balance sheet — it represents its own funds parked at a correspondent. The mirror vostro is a liability for the bank holding those funds.

Why do banks need nostro and vostro accounts? Because no bank has branches or direct clearing access in every country. Correspondent relationships backed by nostro/vostro balances let a bank make and receive payments in currencies where it has no local presence.

How do you reconcile a nostro account? Match your internal ledger of the account against the correspondent's statement (e.g. a SWIFT camt.053). Every entry should appear on both sides; unmatched entries ("breaks") are investigated. Because the nostro and vostro mirror each other, the two records should net to zero.

How does a currency API help with nostro/vostro accounting? Balances sit in multiple foreign currencies, but you report in one home currency. A currency API supplies the live and historical rates needed to value each balance, compute unrealized FX gain/loss, and produce consistent multi-currency reports.

Try It Yourself

Ready to value and reconcile multi-currency balances with real exchange rates? Get your free Finexly API key — no credit card required. Start with 1,000 free requests per month, pull live and historical rates for 170+ currencies, and upgrade as your treasury logic grows.