¿Qué es un Pip en Forex? Guía para Desarrolladores sobre Pips, Pipettes y Matemáticas FX (2026)

Si estás construyendo un bot de trading, una calculadora de tamaño de posición, un panel de riesgo o cualquier producto consciente de FX, te toparás rápido con la pregunta: ¿qué es un pip en forex y cómo calculo su valor en código? Si te equivocas en esto, tu P&L queda mal, tus stop-loss se disparan en niveles incorrectos y tus usuarios no serán pacientes al respecto.

Esta guía explica los pips, pipettes y la fórmula completa del valor del pip desde la perspectiva de un desarrollador, con ejemplos resueltos y código listo para copiar en JavaScript, Python, PHP y cURL. Al final, tendrás una calculadora de pips funcional que extrae tasas en tiempo real desde la documentación de la API de Finexly y maneja cada caso límite que los libros de texto pasan por alto.

¿Qué es un Pip? La Definición Rápida

Un pip (abreviatura de "percentage in point" o "price interest point") es el incremento de precio estandarizado más pequeño para un par de divisas. Para la mayoría de los pares, eso es el cuarto decimal de la cotización: un movimiento de 0.0001. Para los pares cotizados en yenes japoneses, es el segundo decimal: un movimiento de 0.01.

Ejemplos concretos:

• EUR/USD se mueve de 1.0850 a 1.0851 → 1 pip (cambio de 0.0001 USD por EUR).
• GBP/USD se mueve de 1.2640 a 1.2655 → 15 pips.
• USD/JPY se mueve de 154.20 a 154.30 → 10 pips (cambio de 0.10 JPY por USD).
• AUD/JPY se mueve de 99.45 a 99.40 → −5 pips.

El pip es la unidad universal del mercado FX para "¿cuánto se movió el precio?": mucho más útil que los decimales en bruto porque normaliza la conversación entre pares con niveles de precio absolutos muy diferentes.

Pips vs Pipettes vs Puntos

Los brókers y proveedores de datos modernos cotizan tasas con un decimal más allá del pip estándar. Ese dígito extra se llama pipette, pip fraccionario o simplemente punto. Un pipette equivale a una décima de pip.

Cuando un bróker muestra EUR/USD como 1.08507, el 7 final es el pipette, normalmente renderizado más pequeño o como superíndice en una plataforma de trading. Como desarrollador, trata esta distinción con cuidado: si calculas diferencias de precio usando aritmética de strings sobre cotizaciones que incluyen pipettes, subreportarás los movimientos en pips por un factor de 10 a menos que escales correctamente.

Una regla segura: siempre normaliza a un tipo numérico, luego multiplica o divide por la constante de tamaño de pip de ese par.

Por Qué los Tamaños de Pip Difieren Entre Pares

El pip de dos decimales para los pares JPY no es una elección arbitraria. El yen japonés tiene un valor unitario pequeño en relación con la mayoría de las monedas de reserva: alrededor de 1 USD ≈ 154 JPY en 2026, por lo que cotizar a cuatro decimales crearía movimientos de precio cosméticamente diminutos y escaleras ilegibles en pantallas de trading. Truncar a dos decimales mantiene la acción del precio visualmente proporcionada con otros pares mayores.

La misma lógica se aplica a un puñado de otras monedas de cotización con "valor unitario bajo" (won coreano, forint húngaro, etc.): a menudo se cotizan con tamaños de pip de 0.01 o 1. Cuando construyes un sistema multi-par, nunca codifiques 0.0001 como tu constante de tamaño de pip. Siempre búscalo por par.

Una regla pragmática de detección que funciona para la mayoría de los pares:

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

Para un sistema de producción querrás una tabla completa de tamaños de pip indexada por códigos ISO 4217. Consulta nuestra guía completa para desarrolladores de códigos de divisa ISO 4217 para ver la lista completa.

La Fórmula del Valor del Pip

La pregunta central para cualquier cálculo de P&L: para una posición de N unidades de la divisa base, ¿cuánto cambia mi saldo cuando el par se mueve un pip?

La fórmula general:

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

Tres casos, según cómo se relacione la divisa de tu cuenta con el par que operas.

Caso 1: Divisa de la Cuenta = Divisa Cotizada

El caso más sencillo. Si operas EUR/USD en una cuenta USD, cada pip vale una cantidad fija en dólares sin necesidad de conversión adicional.

pip_value = pip_size × position_size

Para 100,000 unidades (un lote estándar) de EUR/USD en una cuenta USD:

0.0001 × 100,000 = 10 USD por pip

Este es el clásico "$10 por pip por lote estándar" que escucharás citado en todas partes: solo se cumple cuando la divisa cotizada coincide con la divisa de la cuenta.

Caso 2: Divisa de la Cuenta = Divisa Base

Si operas USD/CHF en una cuenta USD, el movimiento del pip está denominado en CHF y debe convertirse de vuelta a USD usando la tasa ask actual del par.

pip_value_in_quote = pip_size × position_size
pip_value_in_account = pip_value_in_quote / current_rate

Para 100,000 unidades de USD/CHF cuando USD/CHF = 0.9050:

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

Caso 3: Par Cruzado (Ningún Lado es la Divisa de la Cuenta)

El caso más complicado. Operas EUR/JPY en una cuenta USD. El movimiento del pip está en JPY, y para expresarlo en USD necesitas una tasa de conversión entre JPY y USD.

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

Para 100,000 unidades de EUR/JPY cuando USD/JPY = 154.20:

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

Fíjate que usamos la tasa USD/JPY, no la tasa EUR/JPY, porque estamos convirtiendo de JPY a USD, no de EUR a nada.

Construyendo una Calculadora de Pips con la API de Finexly

Conectemos la fórmula anterior a una API de tasas de cambio en vivo y real para que la calculadora se mantenga precisa según se mueve el mercado. Regístrate en Finexly para obtener una clave API gratuita: 1,000 solicitudes/mes sin tarjeta requerida, suficientes para una calculadora como esta. La referencia completa de solicitudes está en la documentación de la API de 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 solo necesitas la tasa cruda para conectarla a tu propio cálculo de pip:

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

Esa única tasa es suficiente para convertir un movimiento de pip JPY a USD usando la fórmula anterior.

Trampas Comunes en Matemáticas de Pips que Cometen los Desarrolladores

Los pips parecen sencillos. Los bugs son sutiles. Cinco cosas a vigilar:

1. Deriva de punto flotante en aritmética de pips. 0.1 + 0.2 !== 0.3 en JavaScript, y la misma familia de problemas te muerde al sumar P&L en pips sobre muchas operaciones. Para cualquier cosa que llegue a producción, especialmente cálculos financieros, usa contadores enteros de pips internamente (multiplica precios por 10_000 para pares no-JPY y por 100 para pares JPY) o una librería decimal como decimal.js o decimal.Decimal de Python.

2. Codificar 0.0001 como tamaño de pip. Esto rompe cada par JPY en cuanto un usuario opera uno. Siempre busca el tamaño de pip desde una tabla por par.

3. Confundir pips con pipettes al comparar precios. Una cotización EUR/USD de 5 decimales como 1.08502 parece 1.08502 pips de movimiento desde 1.08501, pero solo es 1 pipette = 0.1 pips. Normaliza a flotantes y divide por el tamaño del pip.

4. Usar tasas obsoletas para la conversión a divisa de la cuenta en el Caso 3. Un cálculo de valor de pip para una posición abierta debería usar la tasa actual, no la tasa cuando se abrió la posición. Si cacheas tasas, configura TTLs lo bastante cortos para que la conversión se mantenga precisa: consulta mejores prácticas de caching y manejo de errores en APIs de divisa para patrones probados en producción.

5. Olvidar la asimetría bid/ask. Los brókers convierten P&L usando bid para cerrar largos y ask para cerrar cortos. Para una calculadora orientada al usuario final que solo necesita una estimación, una tasa media está bien. Para un sistema de ejecución, usa el lado apropiado.

Para una mirada más profunda al desglose bid/ask, consulta nuestro artículo tasa spot vs tasa forward, y para conversiones cruzadas tasas de cambio cruzadas explicadas.

Valor del Pip de un Vistazo: Pares Comunes

Para una cuenta denominada en USD operando un lote estándar (100,000 unidades), aquí los valores típicos de pip a tasas indicativas de mayo de 2026. Trátalos como un control de cordura, no como dogma: extrae tasas en vivo desde el convertidor de divisas de Finexly o la API para cualquier cosa que toque una cuenta real.

Dos patrones vale la pena memorizar como desarrollador trabajando con FX: los pares cotizados en USD valen siempre exactamente $10 por pip por lote estándar, y los pares cotizados en JPY rondan la mitad de eso, derivando con USD/JPY.

Preguntas Frecuentes

¿Qué es un pip en forex en términos sencillos? Un pip es el movimiento estandarizado más pequeño en el precio de un par de divisas: típicamente el cuarto decimal para la mayoría de los pares (0.0001) y el segundo decimal para los pares en yen (0.01). Es la unidad universal del mercado FX para medir el movimiento de precio.

¿Cómo calculo el valor del pip en código? Multiplica el tamaño del pip por el tamaño de la posición para obtener el valor del pip en la divisa cotizada, luego conviértelo a la divisa de tu cuenta usando la tasa de cambio actual. Los tres casos (cotizada = cuenta, base = cuenta, cruzado) se muestran en los ejemplos en JavaScript, Python y PHP arriba.

¿Cuál es la diferencia entre un pip y un pipette? Un pipette es una décima de pip: el dígito fraccionario que algunos brókers y feeds de datos añaden para spreads más ajustados. Si un pip en EUR/USD es 0.0001, un pipette es 0.00001.

¿Por qué un pip equivale a unos 10 USD en EUR/USD? Porque un lote estándar son 100,000 unidades y el tamaño de pip para pares no-JPY es 0.0001. 100,000 × 0.0001 = 10 unidades de la divisa cotizada. Cuando la divisa cotizada es USD, eso son 10 USD directamente.

¿Necesito una API de pago para construir una calculadora de pips? No. El plan gratuito de Finexly te da 1,000 solicitudes al mes y cubre 170+ divisas, suficiente para una calculadora de pips personal o un proyecto paralelo de bajo tráfico. Para mayor volumen, consulta nuestros planes de precios.

¿Los tamaños de pip son distintos en pares cripto? Los pares cripto no siguen la convención estándar de pip de FX. BTC/USD a menudo cotiza a 2 o 4 decimales según la plataforma, y "1 pip" se define por venue. Para P&L puro de cripto, trabaja en diferencias de precio absolutas en lugar de pips.

¿Listo para Construirlo?

Ahora tienes la fórmula, tres ejemplos de código funcionales y una lista de los bugs que muerden a la mayoría. La última pieza son tasas en tiempo real que no te derivarán a mitad de cálculo.

Obtén tu clave API gratuita de Finexly: sin tarjeta requerida. Empieza con 1,000 solicitudes gratis por mes, 170+ divisas, latencia sub-50 ms, y actualiza solo cuando lo necesites. Tu calculadora de pips merece tasas tan precisas como las matemáticas detrás.