O que é um Pip em Forex? Guia do Desenvolvedor sobre Pips, Pipettes e Matemática FX (2026)

Se você está construindo um bot de trading, uma calculadora de tamanho de posição, um painel de risco ou qualquer produto consciente de FX, vai esbarrar rápido na pergunta: o que é um pip em forex e como calculo seu valor em código? Errar nisso significa P&L incorreto, stops disparando em níveis errados e usuários impacientes.

Este guia explica pips, pipettes e a fórmula completa do valor do pip da perspectiva de um desenvolvedor — com exemplos resolvidos e código pronto para copiar em JavaScript, Python, PHP e cURL. Ao final, você terá uma calculadora de pip funcional que puxa cotações em tempo real da documentação da API Finexly e lida com cada caso extremo que os livros didáticos ignoram.

O que é um Pip? A Definição Rápida

Um pip (abreviação de "percentage in point" ou "price interest point") é o menor incremento de preço padronizado para um par de moedas. Para a maioria dos pares, é a quarta casa decimal da cotação — um movimento de 0.0001. Para pares cotados em iene japonês, é a segunda casa decimal — um movimento de 0.01.

Exemplos concretos:

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

O pip é a unidade universal do mercado FX para "quanto o preço se moveu?" — muito mais útil que decimais brutos porque normaliza a conversa entre pares com níveis de preço absolutos muito diferentes.

Pips vs Pipettes vs Points

Brokers e provedores de dados modernos cotam preços com uma casa decimal além do pip padrão. Esse dígito extra é chamado de pipette, pip fracionário ou simplesmente point. Um pipette equivale a um décimo de um pip.

Quando um broker mostra EUR/USD como 1.08507, o 7 final é o pipette — geralmente renderizado menor ou em sobrescrito numa plataforma de trading. Como desenvolvedor, trate essa distinção com cuidado: se calcular diferenças de preço usando aritmética de strings sobre cotações que incluem pipettes, vai sub-reportar movimentos em pips por um fator de 10 a menos que escale corretamente.

Uma regra segura: sempre normalize para um tipo numérico, depois multiplique ou divida pela constante de tamanho de pip do par.

Por que os Tamanhos de Pip Diferem entre Pares

O pip de duas casas decimais para pares JPY não é uma escolha arbitrária. O iene japonês tem um valor unitário pequeno em relação à maioria das moedas de reserva — em torno de 1 USD ≈ 154 JPY em 2026 — então cotar em quatro casas decimais criaria movimentos de preço cosmeticamente minúsculos e escadas de preço ilegíveis em telas de trading. Truncar para duas casas decimais mantém a ação do preço visualmente proporcional aos outros pares principais.

A mesma lógica se aplica a um punhado de outras moedas de cotação de "valor unitário baixo" (won coreano, forint húngaro, etc.) — frequentemente cotadas com tamanhos de pip de 0.01 ou 1. Quando você constrói um sistema multi-par, nunca codifique 0.0001 como sua constante de tamanho de pip. Sempre busque por par.

Uma regra pragmática de detecção que funciona para a maioria dos 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 um sistema de produção, você vai querer uma tabela completa de tamanhos de pip indexada por códigos ISO 4217 — veja nosso guia completo do desenvolvedor para códigos ISO 4217 para a lista completa.

A Fórmula do Valor do Pip

A pergunta central para qualquer cálculo de P&L: para uma posição de N unidades da moeda base, quanto meu saldo da conta muda quando o par se move um pip?

A fórmula geral:

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

Três casos, dependendo de como a moeda da sua conta se relaciona com o par que está negociando.

Caso 1: Moeda da Conta = Moeda Cotada

O caso mais simples. Se você negocia EUR/USD numa conta USD, cada pip vale uma quantia fixa em dólares sem necessidade de conversão adicional.

pip_value = pip_size × position_size

Para 100,000 unidades (um lote padrão) de EUR/USD numa conta USD:

0.0001 × 100,000 = 10 USD por pip

Esse é o "$10 por pip por lote padrão" do livro didático que você ouve por aí — só vale quando a moeda cotada coincide com a moeda da conta.

Caso 2: Moeda da Conta = Moeda Base

Se você negocia USD/CHF numa conta USD, o movimento do pip é denominado em CHF e deve ser convertido de volta para USD usando a taxa ask atual do 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 quando USD/CHF = 0.9050:

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

Caso 3: Par Cruzado (Nenhum Lado é a Moeda da Conta)

O caso mais complicado. Você negocia EUR/JPY numa conta USD. O movimento do pip é em JPY, e para expressá-lo em USD você precisa de uma taxa de conversão entre JPY e 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 quando USD/JPY = 154.20:

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

Note que usamos a taxa USD/JPY, não a taxa EUR/JPY, porque estamos convertendo de JPY para USD, não de EUR para nada.

Construindo uma Calculadora de Pips com a API Finexly

Vamos conectar a fórmula acima a uma API de taxas de câmbio real e ao vivo para que a calculadora se mantenha precisa conforme o mercado se move. Cadastre-se em Finexly para uma chave API gratuita — 1,000 requisições/mês sem cartão necessário, mais que o suficiente para uma calculadora como essa. A referência completa de requisições está na documentação da 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

Se você só precisa da taxa bruta para conectar ao seu próprio 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...}

Essa única taxa é suficiente para converter um movimento de pip JPY em USD usando a fórmula acima.

Armadilhas Comuns na Matemática de Pips que Desenvolvedores Cometem

Pips parecem simples. Os bugs são sutis. Cinco coisas para observar:

1. Drift de ponto flutuante na aritmética de pips. 0.1 + 0.2 !== 0.3 em JavaScript, e a mesma família de problemas te ataca ao somar P&L em pips por muitas operações. Para qualquer coisa que chegue à produção — especialmente cálculos financeiros — use contadores inteiros de pips internamente (multiplique preços por 10_000 para pares não-JPY e por 100 para pares JPY) ou uma biblioteca decimal como decimal.js ou decimal.Decimal do Python.

2. Codificar 0.0001 como tamanho do pip. Isso quebra todo par JPY no momento que um usuário negociar um. Sempre busque o tamanho do pip de uma tabela por par.

3. Confundir pips com pipettes ao comparar preços. Uma cotação EUR/USD de 5 decimais como 1.08502 parece 1.08502 pips de movimento de 1.08501, mas é apenas 1 pipette = 0.1 pip. Normalize para floats e divida pelo tamanho do pip.

4. Usar taxas obsoletas para conversão de moeda da conta no Caso 3. Um cálculo de valor de pip para uma posição aberta deve usar a taxa atual, não a taxa quando a posição foi aberta. Se cachear taxas, configure TTLs curtos o suficiente para que a conversão se mantenha precisa — veja melhores práticas de cache e tratamento de erros em APIs de moeda para padrões testados em produção.

5. Esquecer da assimetria bid/ask. Brokers convertem P&L usando bid para fechar longs e ask para fechar shorts. Para uma calculadora voltada ao usuário final que só precisa de uma estimativa, uma taxa média serve. Para um sistema de execução, use o lado apropriado.

Para um olhar mais profundo na divisão bid/ask, veja nosso artigo sobre taxa spot vs taxa forward, e para conversões de pares cruzados veja taxas de câmbio cruzadas explicadas.

Valor do Pip num Relance: Pares Comuns

Para uma conta denominada em USD negociando um lote padrão (100,000 unidades), aqui estão os valores típicos de pip em taxas indicativas de maio de 2026. Trate-os como um sanity check, não como dogma — busque taxas ao vivo do conversor de moedas Finexly ou da API para qualquer coisa que toque uma conta real.

Dois padrões valem a pena memorizar como desenvolvedor fazendo trabalho FX: pares cotados em USD valem sempre exatamente $10 por pip por lote padrão, e pares cotados em JPY ficam em torno da metade disso, derivando com USD/JPY.

Perguntas Frequentes

O que é um pip em forex em termos simples? Um pip é o menor movimento padronizado no preço de um par de moedas — tipicamente a quarta casa decimal para a maioria dos pares (0.0001) e a segunda casa decimal para pares em iene (0.01). É a unidade universal do mercado FX para medir movimento de preço.

Como calculo o valor do pip em código? Multiplique o tamanho do pip pelo tamanho da posição para obter o valor do pip na moeda cotada, depois converta para a moeda da sua conta usando a taxa de câmbio atual. Os três casos (cotada = conta, base = conta, cruzado) estão mostrados nos exemplos em JavaScript, Python e PHP acima.

Qual a diferença entre um pip e um pipette? Um pipette é um décimo de um pip — o dígito fracionário que alguns brokers e feeds de dados adicionam para spreads mais apertados. Se um pip em EUR/USD é 0.0001, um pipette é 0.00001.

Por que um pip equivale a cerca de $10 em EUR/USD? Porque um lote padrão são 100,000 unidades e o tamanho do pip para pares não-JPY é 0.0001. 100,000 × 0.0001 = 10 unidades da moeda cotada. Quando a moeda cotada é USD, isso é $10 diretamente.

Preciso de uma API paga para construir uma calculadora de pip? Não. O plano gratuito da Finexly te dá 1,000 requisições por mês e cobre 170+ moedas — suficiente para uma calculadora de pip pessoal ou um projeto paralelo de baixo tráfego. Para volumes maiores, veja nossos planos de preço.

Os tamanhos de pip são diferentes em pares cripto? Pares cripto não seguem a convenção padrão de pip do FX. BTC/USD frequentemente cota com 2 ou 4 decimais dependendo da venue, e "1 pip" é definido pela venue. Para P&L puro de cripto, trabalhe em diferenças absolutas de preço em vez de pips.

Pronto para Construir?

Você agora tem a fórmula, três exemplos de código funcionais e uma lista dos bugs que pegam a maioria das pessoas. A última peça são taxas em tempo real que não vão sair do eixo no meio do cálculo.

Pegue sua chave API Finexly gratuita — sem cartão de crédito necessário. Comece com 1,000 requisições gratuitas por mês, 170+ moedas, latência sub-50 ms, e atualize só quando precisar. Sua calculadora de pip merece taxas tão precisas quanto a matemática por trás.