Wat is een Pip in Forex? Een Ontwikkelaarsgids voor Pips, Pipettes en FX-Wiskunde (2026)

Als je een trading bot, een positiegrootte-calculator, een risicodashboard of welk FX-bewust product dan ook bouwt, loop je snel tegen de vraag aan: wat is een pip in forex en hoe bereken ik de waarde in code? Als je dit verkeerd doet, klopt je P&L niet, gaan je stop-losses op de verkeerde niveaus af en hebben je gebruikers geen geduld.

Deze gids legt pips, pipettes en de complete pip-waardeformule uit vanuit het perspectief van een ontwikkelaar — met uitgewerkte voorbeelden en kopieerbare code in JavaScript, Python, PHP en cURL. Aan het eind heb je een werkende pip-calculator die realtime koersen ophaalt uit de Finexly API-documentatie en elke randgeval afhandelt dat leerboeken oversla­an.

Wat is een Pip? De Snelle Definitie

Een pip (afkorting van "percentage in point" of "price interest point") is de kleinste gestandaardiseerde prijsstap voor een valutapaar. Voor de meeste paren is dat de vierde decimaal van de koers — een beweging van 0.0001. Voor in Japanse yen genoteerde paren is het de tweede decimaal — een beweging van 0.01.

Concrete voorbeelden:

• EUR/USD beweegt van 1.0850 naar 1.0851 → 1 pip (0.0001 USD per EUR verandering).
• GBP/USD beweegt van 1.2640 naar 1.2655 → 15 pips.
• USD/JPY beweegt van 154.20 naar 154.30 → 10 pips (0.10 JPY per USD verandering).
• AUD/JPY beweegt van 99.45 naar 99.40 → −5 pips.

De pip is de universele eenheid van de FX-markt voor "hoeveel is de prijs bewogen?" — veel nuttiger dan ruwe decimalen omdat het het gesprek normaliseert tussen paren met heel verschillende absolute prijsniveaus.

Pips vs Pipettes vs Points

Moderne brokers en datavoorzieningen noteren koersen één decimaal verder dan de standaard pip. Dat extra cijfer wordt pipette, fractionele pip of simpelweg point genoemd. Eén pipette is gelijk aan een tiende van een pip.

Wanneer een broker EUR/USD weergeeft als 1.08507, is de afsluitende 7 de pipette — meestal kleiner of in superscript weergegeven op een trading-platform. Behandel dit onderscheid als ontwikkelaar zorgvuldig: als je prijsverschillen berekent met string-rekenkunde over koersen die pipettes bevatten, rapporteer je pip-bewegingen 10 keer te laag tenzij je correct schaalt.

Een veilige regel: normaliseer altijd naar een numeriek type, vermenigvuldig of deel dan door de pip-grootte-constante voor dat paar.

Waarom Pip-Groottes Verschillen Tussen Paren

De twee-decimalen pip voor JPY-paren is geen willekeurige keuze. De Japanse yen heeft een kleine eenheidwaarde ten opzichte van de meeste reservevaluta — rond 1 USD ≈ 154 JPY in 2026 — dus noteren op vier decimalen zou cosmetisch minuscule prijsbewegingen en onleesbare ladders op trading-schermen creëren. Afkappen op twee decimalen houdt de prijsactie visueel proportioneel met andere hoofdparen.

Dezelfde logica geldt voor een handvol andere "lage eenheidwaarde"-quoteringsvaluta (Koreaanse won, Hongaarse forint, enz.) — vaak genoteerd met pip-groottes van 0.01 of 1. Hard-code nooit 0.0001 als je pip-grootte-constante wanneer je een multi-paar systeem bouwt. Zoek het altijd op per paar.

Een pragmatische detectieregel die voor de meeste paren werkt:

function getPipSize(pair) {
  // pair example: "EURUSD" or "EUR/USD"
  const quote = pair.replace("/", "").slice(3, 6).toUpperCase();
  const twoDecimalQuotes = new Set(["JPY", "HUF", "KRW"]);
  return twoDecimalQuotes.has(quote) ? 0.01 : 0.0001;
}

console.log(getPipSize("EURUSD")); // 0.0001
console.log(getPipSize("USD/JPY")); // 0.01
console.log(getPipSize("EURHUF")); // 0.01

Voor een productiesysteem wil je een complete pip-grootte-tabel geïndexeerd op ISO 4217 valutacodes — zie onze complete ontwikkelaarsgids voor ISO 4217 valutacodes voor de volledige lijst.

De Pip-Waardeformule

De kernvraag voor elke P&L-berekening: voor een positie van N eenheden van de basisvaluta, hoeveel verandert mijn rekeningsaldo wanneer het paar één pip beweegt?

De algemene formule:

pip_value_in_quote_currency = pip_size × position_size
pip_value_in_account_currency = pip_value_in_quote_currency × (quote_to_account_rate)

Drie gevallen, afhankelijk van hoe je rekeningvaluta zich verhoudt tot het paar dat je verhandelt.

Geval 1: Rekeningvaluta = Notatievaluta

Het eenvoudigste geval. Als je EUR/USD verhandelt op een USD-rekening, is elke pip een vast dollarbedrag waard zonder verdere conversie.

pip_value = pip_size × position_size

Voor 100,000 eenheden (één standaardlot) EUR/USD op een USD-rekening:

0.0001 × 100,000 = 10 USD per pip

Dat is de overal geciteerde leerboekzin "10 dollar per pip per standaardlot" — geldt alleen wanneer de notatievaluta overeenkomt met de rekeningvaluta.

Geval 2: Rekeningvaluta = Basisvaluta

Als je USD/CHF verhandelt op een USD-rekening, is de pip-beweging in CHF en moet die teruggerekend worden naar USD met de huidige ask-koers van het paar.

pip_value_in_quote = pip_size × position_size
pip_value_in_account = pip_value_in_quote / current_rate

Voor 100,000 eenheden USD/CHF wanneer USD/CHF = 0.9050:

0.0001 × 100,000 = 10 CHF
10 CHF / 0.9050 = 11.05 USD per pip

Geval 3: Cross Paar (Geen Zijde is de Rekeningvaluta)

Het lastigste geval. Je verhandelt EUR/JPY op een USD-rekening. De pip-beweging is in JPY, en om die in USD uit te drukken heb je een conversiekoers tussen JPY en USD nodig.

pip_value_in_quote = pip_size × position_size
pip_value_in_account = pip_value_in_quote × (account_per_quote_rate)

Voor 100,000 eenheden EUR/JPY wanneer USD/JPY = 154.20:

0.01 × 100,000 = 1,000 JPY
1,000 JPY / 154.20 = 6.49 USD per pip

Merk op dat we de USD/JPY-koers gebruikten, niet de EUR/JPY-koers, omdat we converteren van JPY naar USD, niet van EUR naar iets.

Een Pip-Calculator Bouwen met de Finexly API

Laten we de bovenstaande formule koppelen aan een echte, live wisselkoers-API zodat de calculator nauwkeurig blijft terwijl de markt beweegt. Meld je aan bij Finexly voor een gratis API-sleutel — 1,000 verzoeken/maand zonder kaartvereiste, ruim voldoende voor een calculator als deze. De volledige verzoekreferentie staat in de Finexly API-documentatie.

JavaScript (Node.js)

const FINEXLY_API_KEY = process.env.FINEXLY_API_KEY;
const BASE_URL = "https://finexly.com/api";

// Two-decimal-pip currencies. Extend as needed.
const TWO_DECIMAL_PIP_QUOTES = new Set(["JPY", "HUF", "KRW"]);

function pipSize(quoteCcy) {
  return TWO_DECIMAL_PIP_QUOTES.has(quoteCcy) ? 0.01 : 0.0001;
}

async function getRate(base, quote) {
  const res = await fetch(
    `${BASE_URL}/latest?base=${base}&symbols=${quote}&api_key=${FINEXLY_API_KEY}`
  );
  const json = await res.json();
  return json.rates[quote];
}

async function calcPipValue({ pair, positionSize, accountCcy }) {
  const base = pair.slice(0, 3).toUpperCase();
  const quote = pair.slice(3, 6).toUpperCase();
  const pip = pipSize(quote);
  const pipValueInQuote = pip * positionSize;

  if (accountCcy === quote) {
    return pipValueInQuote;
  }
  if (accountCcy === base) {
    const rate = await getRate(base, quote);
    return pipValueInQuote / rate;
  }
  // Cross: convert quote -> account via account/quote rate
  const rate = await getRate(accountCcy, quote);
  return pipValueInQuote / rate;
}

// Example: 100,000 units of EUR/JPY on a USD account
calcPipValue({
  pair: "EURJPY",
  positionSize: 100_000,
  accountCcy: "USD",
}).then((v) => console.log(`Pip value: ${v.toFixed(2)} USD`));

Python

import os
import requests

FINEXLY_API_KEY = os.environ["FINEXLY_API_KEY"]
BASE_URL = "https://finexly.com/api"
TWO_DECIMAL_PIP_QUOTES = {"JPY", "HUF", "KRW"}

def pip_size(quote_ccy: str) -> float:
    return 0.01 if quote_ccy in TWO_DECIMAL_PIP_QUOTES else 0.0001

def get_rate(base: str, quote: str) -> float:
    r = requests.get(
        f"{BASE_URL}/latest",
        params={"base": base, "symbols": quote, "api_key": FINEXLY_API_KEY},
        timeout=10,
    )
    r.raise_for_status()
    return r.json()["rates"][quote]

def calc_pip_value(pair: str, position_size: float, account_ccy: str) -> float:
    base, quote = pair[:3].upper(), pair[3:6].upper()
    pip = pip_size(quote)
    pip_in_quote = pip * position_size

    if account_ccy == quote:
        return pip_in_quote
    if account_ccy == base:
        return pip_in_quote / get_rate(base, quote)
    # Cross
    return pip_in_quote / get_rate(account_ccy, quote)

if __name__ == "__main__":
    value = calc_pip_value("EURJPY", 100_000, "USD")
    print(f"Pip value: {value:.2f} USD")

PHP

<?php
$apiKey = getenv('FINEXLY_API_KEY');
$baseUrl = 'https://finexly.com/api';
$twoDecimalPipQuotes = ['JPY', 'HUF', 'KRW'];

function pipSize(string $quoteCcy): float {
    global $twoDecimalPipQuotes;
    return in_array($quoteCcy, $twoDecimalPipQuotes, true) ? 0.01 : 0.0001;
}

function getRate(string $base, string $quote): float {
    global $apiKey, $baseUrl;
    $url = "$baseUrl/latest?base=$base&symbols=$quote&api_key=$apiKey";
    $body = file_get_contents($url);
    $data = json_decode($body, true);
    return $data['rates'][$quote];
}

function calcPipValue(string $pair, float $positionSize, string $accountCcy): float {
    $base = strtoupper(substr($pair, 0, 3));
    $quote = strtoupper(substr($pair, 3, 3));
    $pipInQuote = pipSize($quote) * $positionSize;

    if ($accountCcy === $quote) return $pipInQuote;
    if ($accountCcy === $base)  return $pipInQuote / getRate($base, $quote);
    return $pipInQuote / getRate($accountCcy, $quote);
}

echo number_format(calcPipValue('EURJPY', 100000, 'USD'), 2) . " USD\n";

cURL

Als je alleen de ruwe koers nodig hebt om in je eigen pip-berekening te steken:

curl "https://finexly.com/api/latest?base=USD&symbols=JPY&api_key=YOUR_KEY"
# {"base":"USD","rates":{"JPY":154.20},"timestamp":1746...}

Die ene koers is genoeg om een JPY pip-beweging om te rekenen naar USD met de bovenstaande formule.

Veelvoorkomende Pip-Wiskunde Valkuilen voor Ontwikkelaars

Pips lijken simpel. De bugs zijn subtiel. Vijf dingen om op te letten:

1. Floating-point drift in pip-rekenkunde. 0.1 + 0.2 !== 0.3 in JavaScript, en dezelfde familie problemen bijt je wanneer je pip P&L over veel transacties optelt. Voor alles wat productie bereikt — vooral financiële berekeningen — gebruik intern gehele pip-tellers (vermenigvuldig prijzen met 10_000 voor niet-JPY-paren en 100 voor JPY-paren) of een decimale bibliotheek zoals decimal.js of Python's decimal.Decimal.

2. 0.0001 hardcoderen als pip-grootte. Dit breekt elk JPY-paar op het moment dat een gebruiker er een verhandelt. Zoek de pip-grootte altijd op uit een tabel per paar.

3. Pips verwarren met pipettes bij het vergelijken van prijzen. Een 5-decimalen EUR/USD-koers als 1.08502 lijkt 1.08502 pips beweging vanaf 1.08501, maar het is slechts 1 pipette = 0.1 pip. Normaliseer naar floats en deel door de pip-grootte.

4. Verouderde koersen gebruiken voor de rekeningvaluta-conversie in Geval 3. Een pip-waarde berekening voor een open positie zou de huidige koers moeten gebruiken, niet de koers ten tijde van het openen. Als je koersen cachet, stel TTL's kort genoeg in zodat de conversie nauwkeurig blijft — zie best practices voor caching en foutafhandeling van currency-API's voor in productie geteste patronen.

5. Bid/ask-asymmetrie vergeten. Brokers converteren P&L met bid voor het sluiten van longs en ask voor het sluiten van shorts. Voor een eindgebruiker-gerichte calculator die slechts een schatting nodig heeft, voldoet een mid-koers. Voor een uitvoeringssysteem, gebruik de juiste zijde.

Voor een dieper kijkje in de bid/ask-splitsing, zie ons artikel over spotkoers vs forwardkoers, en voor cross-paar conversies cross wisselkoersen uitgelegd.

Pip-Waarde In Een Oogopslag: Veelvoorkomende Paren

Voor een in USD genoteerde rekening die één standaardlot (100,000 eenheden) verhandelt, hier typische pip-waarden bij indicatieve mei-2026 koersen. Behandel deze als een sanity check, niet als dogma — haal live koersen op uit de Finexly valutaomzetter of de API voor alles wat een echte rekening raakt.

Twee patronen zijn de moeite waard om te onthouden als FX-ontwikkelaar: in USD genoteerde paren zijn altijd precies 10 dollar per pip per standaardlot waard, en in JPY genoteerde paren zweven rond de helft daarvan, drijvend met USD/JPY.

Veelgestelde Vragen

Wat is een pip in forex in eenvoudige bewoordingen? Een pip is de kleinste gestandaardiseerde beweging in de prijs van een valutapaar — meestal de vierde decimaal voor de meeste paren (0.0001) en de tweede decimaal voor yen-paren (0.01). Het is de universele eenheid van de FX-markt voor het meten van prijsbeweging.

Hoe bereken ik de pip-waarde in code? Vermenigvuldig de pip-grootte met de positiegrootte om de pip-waarde in de notatievaluta te krijgen, converteer dan naar je rekeningvaluta met de huidige wisselkoers. De drie gevallen (notatie = rekening, basis = rekening, cross) zijn getoond in de JavaScript-, Python- en PHP-voorbeelden hierboven.

Wat is het verschil tussen een pip en een pipette? Een pipette is een tiende van een pip — het fractionele cijfer dat sommige brokers en datafeeds toevoegen voor strakkere spreads. Als een pip op EUR/USD 0.0001 is, is een pipette 0.00001.

Waarom is één pip ongeveer 10 dollar waard op EUR/USD? Omdat een standaardlot 100,000 eenheden is en de pip-grootte voor niet-JPY-paren 0.0001 is. 100,000 × 0.0001 = 10 eenheden van de notatievaluta. Wanneer de notatievaluta USD is, is dat direct 10 dollar.

Heb ik een betaalde API nodig om een pip-calculator te bouwen? Nee. Het gratis plan van Finexly geeft je 1,000 verzoeken per maand en dekt 170+ valuta's — genoeg voor een persoonlijke pip-calculator of een laag-traffic nevenproject. Voor hoger volume, zie onze prijsplannen.

Zijn pip-groottes anders bij crypto-paren? Crypto-paren volgen niet de standaard FX pip-conventie. BTC/USD wordt vaak genoteerd op 2 of 4 decimalen afhankelijk van de venue, en "1 pip" is venue-gedefinieerd. Voor pure crypto-P&L, werk in absolute prijsverschillen in plaats van pips.

Klaar om te Bouwen?

Je hebt nu de formule, drie werkende codevoorbeelden en een lijst van de bugs die de meeste mensen treffen. Het laatste stuk is realtime koersen die niet wegdrijven midden in een berekening.

Krijg je gratis Finexly API-sleutel — geen creditcard nodig. Begin met 1,000 gratis verzoeken per maand, 170+ valuta's, sub-50 ms latency, en upgrade alleen wanneer je het nodig hebt. Je pip-calculator verdient koersen die net zo nauwkeurig zijn als de wiskunde erachter.