Qu'est-ce qu'un Pip en Forex ? Guide du Développeur sur les Pips, Pipettes et Mathématiques FX (2026)

Si vous construisez un bot de trading, un calculateur de taille de position, un tableau de bord de risque ou tout produit conscient du FX, vous tomberez vite sur la question : qu'est-ce qu'un pip en forex et comment calculer sa valeur en code ? Si vous vous trompez, votre P&L est faux, vos stops se déclenchent aux mauvais niveaux, et vos utilisateurs ne seront pas patients.

Ce guide explique les pips, pipettes et la formule complète de la valeur du pip du point de vue d'un développeur — avec des exemples résolus et du code prêt à copier en JavaScript, Python, PHP et cURL. À la fin, vous aurez un calculateur de pip fonctionnel qui récupère les taux en temps réel depuis la documentation de l'API Finexly et gère chaque cas limite que les manuels ignorent.

Qu'est-ce qu'un Pip ? La Définition Rapide

Un pip (abréviation de "percentage in point" ou "price interest point") est le plus petit incrément de prix standardisé pour une paire de devises. Pour la plupart des paires, c'est la quatrième décimale de la cotation — un mouvement de 0.0001. Pour les paires cotées en yen japonais, c'est la deuxième décimale — un mouvement de 0.01.

Exemples concrets :

• EUR/USD passe de 1.0850 à 1.0851 → 1 pip (changement de 0.0001 USD par EUR).
• GBP/USD passe de 1.2640 à 1.2655 → 15 pips.
• USD/JPY passe de 154.20 à 154.30 → 10 pips (changement de 0.10 JPY par USD).
• AUD/JPY passe de 99.45 à 99.40 → −5 pips.

Le pip est l'unité universelle du marché FX pour "de combien le prix a-t-il bougé ?" — bien plus utile que les décimales brutes parce qu'il normalise la conversation entre paires aux niveaux de prix absolus très différents.

Pips vs Pipettes vs Points

Les brokers et fournisseurs de données modernes cotent les taux avec une décimale supplémentaire au-delà du pip standard. Ce chiffre supplémentaire est appelé pipette, pip fractionnaire ou simplement point. Un pipette équivaut à un dixième de pip.

Quand un broker affiche EUR/USD à 1.08507, le 7 final est le pipette — généralement rendu en plus petit ou en exposant sur une plateforme de trading. En tant que développeur, traitez cette distinction avec soin : si vous calculez les différences de prix avec de l'arithmétique de chaînes sur des cotations qui incluent des pipettes, vous sous-estimerez les mouvements en pips d'un facteur de 10 sauf si vous mettez à l'échelle correctement.

Une règle sûre : toujours normaliser vers un type numérique, puis multiplier ou diviser par la constante de taille du pip pour cette paire.

Pourquoi les Tailles de Pip Diffèrent entre Paires

Le pip à deux décimales pour les paires JPY n'est pas un choix arbitraire. Le yen japonais a une petite valeur unitaire par rapport à la plupart des monnaies de réserve — autour de 1 USD ≈ 154 JPY en 2026 — donc coter à quatre décimales créerait des mouvements de prix cosmétiquement minuscules et des échelles illisibles sur les écrans de trading. Tronquer à deux décimales garde l'action des prix visuellement proportionnée aux autres paires majeures.

La même logique s'applique à une poignée d'autres devises de cotation à "faible valeur unitaire" (won coréen, forint hongrois, etc.) — souvent cotées avec des tailles de pip de 0.01 ou 1. Quand vous construisez un système multi-paires, ne codez jamais en dur 0.0001 comme votre constante de taille de pip. Cherchez-la toujours par paire.

Une règle de détection pragmatique qui fonctionne pour la plupart des paires :

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

Pour un système de production, vous voudrez une table complète de tailles de pip indexée sur les codes ISO 4217 — voir notre guide complet du développeur sur les codes de devise ISO 4217 pour la liste complète.

La Formule de la Valeur du Pip

La question centrale pour tout calcul de P&L : pour une position de N unités de la devise de base, de combien mon solde change-t-il quand la paire bouge d'un pip ?

La formule générale :

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

Trois cas, selon la relation entre la devise de votre compte et la paire que vous tradez.

Cas 1 : Devise du Compte = Devise Cotée

Le cas le plus simple. Si vous tradez EUR/USD sur un compte USD, chaque pip vaut un montant fixe en dollars sans conversion supplémentaire.

pip_value = pip_size × position_size

Pour 100,000 unités (un lot standard) d'EUR/USD sur un compte USD :

0.0001 × 100,000 = 10 USD par pip

C'est le classique "10 $ par pip par lot standard" qu'on entend partout — il ne tient que lorsque la devise cotée correspond à la devise du compte.

Cas 2 : Devise du Compte = Devise Base

Si vous tradez USD/CHF sur un compte USD, le mouvement du pip est libellé en CHF et doit être reconverti en USD au taux ask actuel de la paire.

pip_value_in_quote = pip_size × position_size
pip_value_in_account = pip_value_in_quote / current_rate

Pour 100,000 unités d'USD/CHF quand USD/CHF = 0.9050 :

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

Cas 3 : Paire Croisée (Aucun Côté n'est la Devise du Compte)

Le cas le plus délicat. Vous tradez EUR/JPY sur un compte USD. Le mouvement du pip est en JPY, et pour l'exprimer en USD vous avez besoin d'un taux de conversion entre JPY et USD.

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

Pour 100,000 unités d'EUR/JPY quand USD/JPY = 154.20 :

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

Notez que nous avons utilisé le taux USD/JPY, pas le taux EUR/JPY, parce que nous convertissons de JPY vers USD, pas d'EUR vers quoi que ce soit.

Construire un Calculateur de Pip avec l'API Finexly

Connectons la formule ci-dessus à une vraie API de taux de change en direct pour que le calculateur reste précis quand le marché bouge. Inscrivez-vous sur Finexly pour une clé API gratuite — 1,000 requêtes/mois sans carte requise, largement assez pour un calculateur comme celui-ci. La référence complète des requêtes est dans la documentation de l'API Finexly.

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

Si vous avez juste besoin du taux brut pour le brancher sur votre propre calcul de pip :

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

Ce seul taux suffit à convertir un mouvement de pip JPY en USD avec la formule ci-dessus.

Pièges Courants des Mathématiques de Pips

Les pips ont l'air simples. Les bugs sont subtils. Cinq choses à surveiller :

1. Dérive en virgule flottante sur l'arithmétique des pips. 0.1 + 0.2 !== 0.3 en JavaScript, et la même famille de problèmes vous mord quand vous additionnez le P&L en pips sur de nombreuses transactions. Pour tout ce qui atteint la production — surtout les calculs financiers — utilisez en interne des compteurs entiers de pips (multipliez les prix par 10_000 pour les paires non-JPY et par 100 pour les paires JPY) ou une bibliothèque décimale comme decimal.js ou decimal.Decimal en Python.

2. Coder en dur 0.0001 comme taille de pip. Cela casse chaque paire JPY dès qu'un utilisateur en trade une. Cherchez toujours la taille du pip dans une table par paire.

3. Confondre pips et pipettes en comparant les prix. Une cotation EUR/USD à 5 décimales comme 1.08502 semble être 1.08502 pips de mouvement depuis 1.08501, mais ce n'est qu'1 pipette = 0.1 pip. Normalisez en flottants et divisez par la taille du pip.

4. Utiliser des taux périmés pour la conversion vers la devise du compte au Cas 3. Un calcul de valeur de pip pour une position ouverte devrait utiliser le taux actuel, pas le taux à l'ouverture. Si vous mettez en cache les taux, configurez des TTL assez courts pour que la conversion reste précise — voir meilleures pratiques de cache et de gestion d'erreurs pour les API de devise pour des patterns testés en production.

5. Oublier l'asymétrie bid/ask. Les brokers convertissent le P&L en utilisant le bid pour fermer les longs et l'ask pour fermer les shorts. Pour un calculateur destiné à l'utilisateur final qui ne demande qu'une estimation, un taux médian convient. Pour un système d'exécution, utilisez le bon côté.

Pour un regard plus profond sur la séparation bid/ask, voir notre article sur taux spot vs taux forward, et pour les conversions cross-paires voir taux de change croisés expliqués.

Valeur du Pip en un Coup d'Œil : Paires Communes

Pour un compte libellé en USD tradant un lot standard (100,000 unités), voici les valeurs de pip typiques aux taux indicatifs de mai 2026. Traitez-les comme un contrôle de cohérence, pas comme une vérité absolue — récupérez les taux en direct depuis le convertisseur de devises Finexly ou l'API pour tout ce qui touche un vrai compte.

Deux schémas valent la peine d'être mémorisés en tant que développeur travaillant sur le FX : les paires cotées en USD valent toujours exactement 10 $ par pip par lot standard, et les paires cotées en JPY tournent autour de la moitié, dérivant avec USD/JPY.

Foire Aux Questions

Qu'est-ce qu'un pip en forex en termes simples ? Un pip est le plus petit mouvement standardisé du prix d'une paire de devises — typiquement la quatrième décimale pour la plupart des paires (0.0001) et la deuxième décimale pour les paires en yen (0.01). C'est l'unité universelle du marché FX pour mesurer le mouvement de prix.

Comment calculer la valeur du pip en code ? Multipliez la taille du pip par la taille de la position pour obtenir la valeur du pip dans la devise cotée, puis convertissez vers la devise de votre compte avec le taux de change actuel. Les trois cas (cotée = compte, base = compte, croisée) sont montrés dans les exemples JavaScript, Python et PHP ci-dessus.

Quelle est la différence entre un pip et un pipette ? Un pipette est un dixième de pip — le chiffre fractionnaire que certains brokers et flux de données ajoutent pour des spreads plus serrés. Si un pip sur EUR/USD est 0.0001, un pipette est 0.00001.

Pourquoi un pip vaut-il environ 10 $ sur EUR/USD ? Parce qu'un lot standard est 100,000 unités et la taille du pip pour les paires non-JPY est 0.0001. 100,000 × 0.0001 = 10 unités de la devise cotée. Quand la devise cotée est USD, c'est 10 $ directement.

Ai-je besoin d'une API payante pour construire un calculateur de pip ? Non. Le plan gratuit de Finexly vous donne 1,000 requêtes par mois et couvre 170+ devises — suffisant pour un calculateur de pip personnel ou un projet annexe à faible trafic. Pour un volume plus important, voir nos plans tarifaires.

Les tailles de pip sont-elles différentes sur les paires crypto ? Les paires crypto ne suivent pas la convention pip standard du FX. BTC/USD se cote souvent à 2 ou 4 décimales selon la venue, et "1 pip" est défini par la venue. Pour du P&L crypto pur, travaillez en différences de prix absolues plutôt qu'en pips.

Prêt à le Construire ?

Vous avez maintenant la formule, trois exemples de code fonctionnels et une liste des bugs qui mordent la plupart des gens. La dernière pièce, ce sont des taux en temps réel qui ne dérivent pas pendant le calcul.

Récupérez votre clé API Finexly gratuite — sans carte de crédit. Commencez avec 1,000 requêtes gratuites par mois, 170+ devises, latence sous 50 ms, et upgradez seulement quand vous en avez besoin. Votre calculateur de pip mérite des taux aussi précis que les mathématiques derrière.