Driehoeksarbitrage in forex uitgelegd: gids voor ontwikkelaars (2026)

Driehoeksarbitrage in forex is een van de meest elegante ideeën in de valutamarkt. Het zegt: als ik USD → EUR → GBP → USD kan converteren en eindig met meer dollars dan waarmee ik begon, is de markt verkeerd geprijsd en is het verschil risicovrije winst. In de praktijk duren die kansen milliseconden en zijn ze het domein van high-frequency desks — maar de onderliggende wiskunde is iets dat elke ontwikkelaar die met valutadata werkt moet begrijpen. Ze vertelt je of de kruiskoersen die je API teruggeeft intern consistent zijn, stelt je in staat slimmere multi-hop conversieroutes te bouwen, en voedt sanity-checks die kapotte koersen vangen voordat ze je klanten bereiken.

Deze gids legt uit wat driehoeksarbitrage is, doorloopt stap voor stap de kruiskoersformule en laat zien hoe je een werkende scanner voor driehoeksarbitrage bouwt met echte code in JavaScript, Python, PHP en cURL — allemaal aangedreven door een realtime valuta-API.

Wat is driehoeksarbitrage?

Driehoeksarbitrage (ook cross-currency arbitrage of drie-punts-arbitrage genoemd) is het uitbuiten van een prijsverschil tussen drie valuta's op de valutamarkt. De handelaar wisselt valuta A om in B, B in C en C terug in A. Als het eindbedrag in A groter is dan het beginbedrag, heb je risicovrije winst gepakt.

De techniek werkt alleen wanneer de genoteerde kruiskoers tussen twee valuta's afwijkt van de impliciete kruiskoers berekend via een derde (meestal de Amerikaanse dollar). Wanneer de markt in evenwicht is — vrijwel altijd — komen die koersen overeen en bestaat er geen arbitrage. Wanneer ze kort uiteenlopen tijdens een snelle beweging, een nieuwsshock of een verouderde quote van een trage broker, ontstaat er een kans.

In de moderne forex wordt driehoeksarbitrage gedomineerd door algoritmische traders met co-located servers waarvan de latency in microseconden wordt gemeten. Particuliere traders kunnen niet concurreren op snelheid en na spreads en kosten is bijna geen schijnbare kans daadwerkelijk winstgevend. Waarom zou een ontwikkelaar zich er dan iets aan gelegen laten liggen? Omdat dezelfde wiskunde die een HFT-scanner aandrijft, de wiskunde is die je gebruikt om:

• Te valideren of de kruiskoersen van je provider intern consistent zijn
• Multi-hop conversies te routeren voor valutaparen die je provider niet direct quoot
• Verouderde data te detecteren voordat ze een klantgerichte quote vervuilen
• Educatieve tools, paper-trading simulators en analytics-dashboards te bouwen

Dat is de échte prijs. Op naar de formule.

De wiskunde: hoe detecteer je een driehoeksarbitragekans

Er zijn drie koersen betrokken. Kies een basisvaluta (meestal USD) en twee andere — zeg EUR en GBP. Dan heb je drie wisselkoersen:

• EUR/USD — hoeveel dollars één euro koopt
• GBP/USD — hoeveel dollars één pond koopt
• EUR/GBP — hoeveel ponden één euro koopt (dit is de genoteerde kruiskoers)

De impliciete kruiskoers voor EUR/GBP, afgeleid uit EUR/USD en GBP/USD, is:

Impliciete EUR/GBP = EUR/USD ÷ GBP/USD

De intuïtie: één euro is EUR/USD dollars waard, en één pond is GBP/USD dollars waard, dus één euro moet EUR/USD ÷ GBP/USD ponden waard zijn — als de markt consistent is.

Als de genoteerde EUR/GBP verschilt van de impliciete EUR/GBP met meer dan de transactiekosten, is er een theoretische arbitrage. Het procentuele verschil:

Arbitrage % = (Impliciet − Genoteerd) ÷ Genoteerd × 100

Een eenvoudiger manier: start met 1 eenheid valuta A, doorloop de lus en kijk waarmee je eindigt. Is het resultaat groter dan 1, dan heb je een kans gevonden. De algemene luscheck is:

Winstratio = Koers(A→B) × Koers(B→C) × Koers(C→A)

Als Winstratio > 1, is de cyclus A → B → C → A (vóór kosten) winstgevend. Is hij kleiner dan 1, dan kan de omgekeerde cyclus (A → C → B → A) winstgevend zijn. Is hij gelijk aan 1, dan is de markt in evenwicht.

Dit is de enige formule die je echt hoeft te onthouden. De rest is leidingwerk.

Uitgewerkt voorbeeld: USD → EUR → GBP → USD

Stel dat je provider de volgende live koersen teruggeeft:

Impliciete EUR/GBP = 1.0850 ÷ 1.2700 = 0.8543

Stap 2: vergelijk met de genoteerde EUR/GBP.

Genoteerd = 0.8500
Impliciet = 0.8543
Verschil = (0.8543 − 0.8500) ÷ 0.8500 × 100 = 0.51%

Een verschil van 51 basispunten is enorm in moderne FX (echte kansen liggen typisch tussen 1 en 5 basispunten en verdwijnen in milliseconden). Ter illustratie laten we de lus draaien.

Stap 3: stuur \$1.000.000 door de cyclus.

1. USD → EUR: 1.000.000 ÷ 1.0850 = €921.659
2. EUR → GBP: 921.659 × 0.8500 = £783.410
3. GBP → USD: 783.410 × 1.2700 = $994.931

Dat is een verlies van ongeveer $5.069. De cyclus USD → EUR → GBP → USD is niet winstgevend. Draai hem om:

1. USD → GBP: 1.000.000 ÷ 1.2700 = £787.402
2. GBP → EUR: 787.402 ÷ 0.8500 = €926.355
3. EUR → USD: 926.355 × 1.0850 = $1.005.095

De omgekeerde richting levert $5.095 winst op $1M op. De les: de richting van de trade is even belangrijk als het verschil zelf. Controleer altijd beide kanten.

Waarom ontwikkelaars zich erom moeten bekommeren (ook als je niet handelt)

Bouw je een SaaS-billingsysteem, een e-commerce checkout, een payroll-engine of een reisboekingsplatform, dan kan HFT je niets schelen — maar de wiskunde absoluut wel.

1. Consistentiechecks op kruiskoersen. Geeft je provider EUR/USD, GBP/USD en EUR/GBP terug, dan kun je de eerste twee delen en vergelijken met de derde. Een verschil groter dan de typische spread (zeg 10 bps) is een sterk signaal dat een van de quotes verouderd of fout is. Loggen, alerten, terugvallen op een secundaire bron.

2. Slimmer multi-hop converteren. Stel dat een klant Thaise baht (THB) wil omzetten naar Noorse kroon (NOK), en je provider quoot THB/NOK niet direct. Je kunt routeren via USD: THB → USD → NOK. De driehoekswiskunde vertelt je dat dit (op afronding na) wiskundig equivalent is aan een hypothetische directe quote. De Finexly API-documentatie beschrijft hoe je conversies netjes aaneenschakelt.

3. Slechte data oppikken vóór productie. Eén verouderde quote in een multi-currency factuur kan leiden tot verkeerd geprijsde contracten, mislukte reconciliaties en ontevreden financiële teams. Driehoekschecks zijn de goedkoopste sanity-test die je kunt schrijven — drie API-calls, twee delingen, één vergelijking.

4. Onderwijs en visualisatie. Interne tools die kruiskoersconsistentie in realtime visualiseren zijn een prima manier om afwijkingen zichtbaar te maken voor je ops-team en vertrouwen op te bouwen bij financiële stakeholders.

Een driehoeksarbitrage-scanner bouwen met Finexly

Laten we de scanner bouwen. We halen live koersen op voor een mandje valuta's, berekenen elke impliciete kruiskoers tegen de genoteerde en brengen elke afwijking boven een instelbare drempel aan het licht.

cURL: de laatste koersen ophalen

De simpelst mogelijke call. De latest-endpoint geeft mid-market koersen ten opzichte van een basisvaluta voor elke gevraagde subset van symbolen.

curl "https://api.finexly.com/v1/latest?base=USD&symbols=EUR,GBP,JPY" \
  -H "Authorization: Bearer YOUR_API_KEY"

Een typische respons:

{
  "base": "USD",
  "timestamp": 1763309480,
  "rates": {
    "EUR": 0.9217,
    "GBP": 0.7874,
    "JPY": 152.43
  }
}

Dat zijn koersen genoteerd in USD: 1 USD = 0.9217 EUR, 0.7874 GBP, 152.43 JPY. Om EUR/GBP te berekenen gebruiken we de relatie EUR/GBP = (1/EUR_per_USD) × GBP_per_USD = GBP_per_USD ÷ EUR_per_USD, of leesbaarder: EUR/GBP = 0.7874 / 0.9217 ≈ 0.8543.

JavaScript / Node.js: een productieklare scanner

Deze implementatie haalt een valutamandje op in één request, berekent de impliciete kruiskoers voor elk paar en markeert alles wat een instelbare drempel overschrijdt.

// triangular-scanner.js
const API_KEY = process.env.FINEXLY_API_KEY;
const BASE_URL = "https://api.finexly.com/v1";

async function getRates(base, symbols) {
  const url = `${BASE_URL}/latest?base=${base}&symbols=${symbols.join(",")}`;
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });
  if (!res.ok) throw new Error(`Finexly API ${res.status}`);
  const data = await res.json();
  return data.rates; // { EUR: 0.9217, GBP: 0.7874, ... }
}

function impliedCrossRate(baseToA, baseToB) {
  // If 1 USD = X EUR and 1 USD = Y GBP, then 1 EUR = Y/X GBP
  return baseToB / baseToA;
}

async function scanTriangles(base, currencies, thresholdBps = 10) {
  const rates = await getRates(base, currencies);
  const opportunities = [];

  for (let i = 0; i < currencies.length; i++) {
    for (let j = i + 1; j < currencies.length; j++) {
      const a = currencies[i];
      const b = currencies[j];

      // Implied a/b cross-rate via the base
      const implied = impliedCrossRate(rates[a], rates[b]);

      // Quoted a/b — fetch directly to compare
      const quoted = await getRates(a, [b]);
      const quotedRate = quoted[b];

      const gapBps = ((implied - quotedRate) / quotedRate) * 10000;

      if (Math.abs(gapBps) > thresholdBps) {
        opportunities.push({
          triangle: `${base} → ${a} → ${b} → ${base}`,
          implied: implied.toFixed(6),
          quoted: quotedRate.toFixed(6),
          gapBps: gapBps.toFixed(2),
        });
      }
    }
  }

  return opportunities;
}

scanTriangles("USD", ["EUR", "GBP", "JPY", "CHF"], 10).then(console.log);

Draai hem periodiek (elke 5–30 seconden is ruim voldoende voor monitoring) en stuur de alerts door naar Slack, PagerDuty of waar je team ook zit. Voor een diepere integratierondleiding, zie onze Node.js-integratiegids voor valuta-API.

Python: een scanner met gevectoriseerde wiskunde

Python's kracht is bondige numerieke code. Hetzelfde idee, sneller geschreven:

# triangular_scanner.py
import os
import itertools
import requests

API_KEY = os.environ["FINEXLY_API_KEY"]
BASE_URL = "https://api.finexly.com/v1"

def get_rates(base, symbols):
    r = requests.get(
        f"{BASE_URL}/latest",
        params={"base": base, "symbols": ",".join(symbols)},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=5,
    )
    r.raise_for_status()
    return r.json()["rates"]

def scan_triangles(base, currencies, threshold_bps=10):
    rates = get_rates(base, currencies)
    opportunities = []

    for a, b in itertools.combinations(currencies, 2):
        implied = rates[b] / rates[a]
        quoted = get_rates(a, [b])[b]
        gap_bps = (implied - quoted) / quoted * 10_000

        if abs(gap_bps) > threshold_bps:
            opportunities.append({
                "triangle": f"{base} → {a} → {b} → {base}",
                "implied": round(implied, 6),
                "quoted": round(quoted, 6),
                "gap_bps": round(gap_bps, 2),
            })

    return opportunities

if __name__ == "__main__":
    results = scan_triangles("USD", ["EUR", "GBP", "JPY", "CHF"], 10)
    for r in results:
        print(r)

Het patroon is identiek: haal basiskoersen op in één call, leid elke impliciete kruisrelatie af, vergelijk met de genoteerde kruiskoers, breng alles boven je drempel aan het licht. Voor meer Python-patronen inclusief caching en retries, zie onze Python-tutorial voor valuta-API.

PHP: dezelfde scanner, web-vriendelijk

PHP schittert wanneer je hem direct in een billingdashboard of admin-tool inbedt.

<?php
// triangular_scanner.php
$apiKey = getenv('FINEXLY_API_KEY');
$baseUrl = 'https://api.finexly.com/v1';

function getRates(string $base, array $symbols, string $apiKey, string $baseUrl): array {
    $url = "{$baseUrl}/latest?base={$base}&symbols=" . implode(',', $symbols);
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => ["Authorization: Bearer {$apiKey}"],
        CURLOPT_TIMEOUT => 5,
    ]);
    $response = curl_exec($ch);
    curl_close($ch);
    $data = json_decode($response, true);
    return $data['rates'] ?? [];
}

function scanTriangles(string $base, array $currencies, int $thresholdBps, string $apiKey, string $baseUrl): array {
    $rates = getRates($base, $currencies, $apiKey, $baseUrl);
    $opportunities = [];

    for ($i = 0; $i < count($currencies); $i++) {
        for ($j = $i + 1; $j < count($currencies); $j++) {
            $a = $currencies[$i];
            $b = $currencies[$j];
            $implied = $rates[$b] / $rates[$a];
            $quoted = getRates($a, [$b], $apiKey, $baseUrl)[$b];
            $gapBps = ($implied - $quoted) / $quoted * 10000;

            if (abs($gapBps) > $thresholdBps) {
                $opportunities[] = [
                    'triangle' => "{$base} → {$a} → {$b} → {$base}",
                    'implied'  => round($implied, 6),
                    'quoted'   => round($quoted, 6),
                    'gap_bps'  => round($gapBps, 2),
                ];
            }
        }
    }
    return $opportunities;
}

print_r(scanTriangles('USD', ['EUR', 'GBP', 'JPY', 'CHF'], 10, $apiKey, $baseUrl));

Voor Laravel-specifieke patronen — queued jobs en Eloquent-caching — zie onze Laravel-tutorial voor valuta-API.

Veelvoorkomende valkuilen en waarom retail-arbitrage faalt

Word je verleid om driehoeksarbitrage écht te traden, lees deze sectie dan twee keer.

1. Spreads eten de kans op. Alle bovenstaande wiskunde ging uit van mid-market koersen. In werkelijkheid handel je tegen de ask bij kopen en de bid bij verkopen. Een typische retail-spread op EUR/USD is 1–2 pips. Tegen de tijd dat je drie spreads bent overgestoken, heb je 3–6 pips aan transactiekosten betaald — veel meer dan elk zichtbaar arbitrageverschil.

2. Latency doodt je. Academisch onderzoek heeft aangetoond dat 95% van de driehoekskansen minder dan 5 seconden duurt en 60% minder dan 1 seconde. Tegen de tijd dat je script drie quotes ophaalt en drie orders inschiet, is het verschil weg. HFT-firma's co-localiseren servers in datacentra van beurzen om microseconden te winnen; je laptop kan niet concurreren.

3. "Gratis" koersen zijn niet verhandelbaar. De mid-market koers die je in een API ziet is een informatieprijs — het middenpunt tussen bid en ask. Daar kun je niet tegen handelen. Echte executiekoersen omvatten brokeropslag, slippage en (vaak) verborgen kosten op elk been.

4. Beenrisico (leg risk). Zelfs als je een echte kans signaleert, moet je drie trades atomair uitvoeren. Faalt de tweede of wordt hij gedeeltelijk gevuld, dan zit je vast aan een valuta die je niet wilde — tegen een prijs die mogelijk tegen je in is gegaan.

5. Regelgevingsfrictie. Grensoverschrijdende uitvoeringsplekken, KYC-eisen en valutaconversiekosten op je financieringsrekening voegen lagen kosten toe die retailtraders in hun spreadsheets vaak negeren.

De boodschap: behandel driehoeksarbitrage als een analytisch en engineering-instrument, niet als handelsstrategie. De wiskunde is onbetaalbaar voor caching en foutafhandeling van valuta-API's, monitoring van datakwaliteit, multi-hop routing en educatieve tools. Laat het handelen over aan mensen met co-located servers.

Veelgestelde vragen

Is driehoeksarbitrage winstgevend in 2026? Voor retailtraders effectief niet. Spreads, latency en concurrentie van algoritmische firma's hebben de nettorendementen na kosten praktisch tot nul gedrukt. Winstgevende driehoeksarbitrage wordt tegenwoordig gedomineerd door high-frequency desks met co-located, microseconden-latency systemen. De wiskunde blijft echter essentieel voor kruiskoersconsistentie, multi-hop conversie en datavalidatie in elke FX-rakende toepassing.

Wat is het verschil tussen driehoeksarbitrage en kruiskoersberekening? Kruiskoersberekening is de wiskunde: EUR/GBP afleiden uit EUR/USD en GBP/USD. Driehoeksarbitrage is de handelsstrategie die het verschil uitbuit tussen de berekende kruiskoers en een apart genoteerde kruiskoers. Elke driehoeksarbitragekans is een kruiskoersmismatch, maar niet elke kruiskoersberekening betreft arbitrage.

Welke drie valuta's zijn het beste voor driehoeksarbitrage? Historisch zijn de meest bekeken driehoeken USD-EUR-GBP, USD-EUR-JPY en USD-GBP-JPY vanwege hoge liquiditeit en nauwe spreads. Cryptomarkten bieden soms grotere kansen door gefragmenteerde liquiditeit tussen exchanges, maar brengen bewaring-, opname- en settlementrisico met zich mee.

Kan ik een gratis API zoals Finexly gebruiken om driehoeksarbitrage te testen? Ja — voor leren, monitoren en valideren is een gratis valuta-API perfect. Het gratis abonnement van Finexly dekt meer dan 170 valuta's en is ruim voldoende om een scanner te bouwen die elke paar seconden draait. Verwacht alleen geen winst van een gevonden kans; behandel het als engineering en analytics, niet als trading.

Hoe vaak moet ik een driehoeksarbitrage-scanner draaien? Voor monitoring van datakwaliteit (de echte reden waarom de meeste ontwikkelaars er een bouwen), is elke 30 tot 60 seconden voldoende. Voor HFT-achtige detectie zou je sub-milliseconde polling en een tick-by-tick feed nodig hebben — en op dat punt is een REST API het verkeerde gereedschap. Zie onze REST vs WebSocket-vergelijking voor wanneer welke architectuur zinvol is.

Wat is het verband tussen driehoeksarbitrage en kruiswisselkoersen? Een kruiswisselkoers is elke koers tussen twee valuta's waarbij geen USD betrokken is. Driehoeksarbitrage is in essentie een controle dat de genoteerde kruiskoers gelijk is aan de impliciete kruiskoers afgeleid via USD. Ben je nieuw met kruiskoersen, begin dan met onze diepgaande gids over kruiswisselkoersen voor ontwikkelaars.

Tot slot

Driehoeksarbitrage is zo'n onderwerp dat exotisch klinkt totdat je beseft dat de wiskunde slechts is: deel twee koersen, vergelijk met een derde, alert als ze afwijken. Als handelsstrategie is het in moderne markten vrijwel onmogelijk om er winst mee te maken. Als engineering-patroon is het een van de nuttigste gereedschappen in de toolkit van een fintech-ontwikkelaar — voor datavalidatie, multi-hop conversie en het zichtbaar maken van afwijkingen vóór ze je klanten bereiken.

De volgende keer dat je een valutaconversiestroom inricht, prik er een driehoeksconsistentiecheck in. Drie API-calls en tien regels code, en hij vangt kapotte koersen ruim voor je financiële team.

Klaar om realtime wisselkoersen te integreren in je project? Pak je gratis Finexly API-sleutel — geen creditcard nodig. Start met 1.000 gratis requests per maand, schaal op via onze prijsplannen naarmate je groeit, of probeer de interactieve valutaomzetter om live koersen in actie te zien.