Using FXMacroData with Prediction Markets: Kalshi and Polymarket

Cuando los datos macro cumplen con los mercados de predicción

Los mercados de predicción han pasado de la curiosidad a la infraestructura. El Kalshi el primer intercambio de predicción regulado por la CFTC en los Estados Unidos te permite negociar contratos sobre resultados como "Will Indicador de precios de los Estados Unidos ¿Se espera que el PIB de la UE supere el 3,5% en abril?" o "¿Se espera Reserva Federal Polymarket, que se ejecuta en la cadena de bloques Polygon, ofrece mercados de resultados binarios similares en eventos macro con acceso abierto global. Ambas plataformas cotizan probabilidades en tiempo real y ambas son sensibles a exactamente las mismas versiones de datos macro que se mueven. El valor de las pérdidas¿ Qué ? El valor de la moneda de referencia, y el resto del complejo FX.

Si ya utiliza FXMacroData para realizar un seguimiento de los calendarios del banco central, monitorear las sorpresas del IPC y extraer el historial de las tasas de interés, tiene los ingredientes para construir una ventaja sistemática en estos mercados.

Los requisitos previos

• Una clave de la API de FXMacroData Suscríbete aquí para una prueba gratuita.
• Python 3.10 o más reciente con requests instalado (pip install requests) y de la Comisión).
• Una cuenta Kalshi con acceso API habilitado, o una billetera Polymarket para la referencia cruzada manual.
• Familiaridad básica con el IPC, Pago de los trabajadores no agrícolas, y tipo de interés Las decisiones son.

Paso 1 Saque el calendario de lanzamiento próximo

Lo primero que necesita es una imagen clara de qué anuncios están llegando y cuándo. El punto final del calendario de lanzamiento de FXMacroData devuelve todos los eventos macro programados para una moneda, con sus fechas y horas de anuncio esperadas.

import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://fxmacrodata.com/api/v1"

def get_upcoming_releases(currency: str) -> list[dict]:
    url = f"{BASE}/calendar/{currency}?api_key={API_KEY}"
    resp = requests.get(url, timeout=10)
    resp.raise_for_status()
    return resp.json().get("data", [])

usd_calendar = get_upcoming_releases("usd")

for event in usd_calendar[:5]:
    print(event["indicator"], event.get("announcement_datetime"), event.get("next_release_date"))

Cada entrada lleva un indicator Las mulas (por ejemplo, inflation¿ Qué ? non_farm_payrolls¿ Qué ? policy_ratesi un contrato se resuelve en "CPI para marzo de 2026" necesita la fecha exacta de anuncio para dimensionar su horizonte temporal correctamente.

Paso 2 Obtener datos de anuncios históricos y calcular las series sorpresa

Si puede calcular un índice de sorpresa de la historia reciente para un indicador dado con qué frecuencia las impresiones reales superan el consenso, y en qué medida tiene una línea de base para calibrar su posición.

def get_announcement_history(currency: str, indicator: str, limit: int = 24) -> list[dict]:
    url = f"{BASE}/announcements/{currency}/{indicator}?api_key={API_KEY}&limit={limit}"
    resp = requests.get(url, timeout=10)
    resp.raise_for_status()
    return resp.json().get("data", [])

def compute_surprise_series(records: list[dict]) -> list[dict]:
    surprises = []
    for r in records:
        actual = r.get("actual_value")
        consensus = r.get("predicted_value")
        if actual is not None and consensus is not None:
            surprises.append({
                "date": r["date"],
                "actual": actual,
                "consensus": consensus,
                "surprise": actual - consensus,
                "direction": "beat" if actual > consensus else "miss",
            })
    return surprises

cpi_history = get_announcement_history("usd", "inflation", limit=24)
cpi_surprises = compute_surprise_series(cpi_history)

beat_count = sum(1 for s in cpi_surprises if s["direction"] == "beat")
miss_count = len(cpi_surprises) - beat_count
print(f"CPI beat rate (last 24 releases): {beat_count}/{len(cpi_surprises)} = {beat_count/len(cpi_surprises):.0%}")

El predicted_value Este es el mismo sinal de consenso que ancla los precios del mercado de predicción, por lo que su serie sorpresa será directamente comparable a la probabilidad implícita incrustada en un contrato Kalshi CPI.

Paso 3 Indicadores de mapas para los contratos de mercado de predicción

Tanto Kalshi como Polymarket estructuran sus contratos macro en torno a umbrales de indicadores específicos. El mapeo es sencillo una vez que conoce las babosas del indicador FXMacroData.

El calendario de liberación Cuando un contrato de Kalshi enumera una fecha de resolución, haga referencia cruzada con el next_release_date Las discrepancias en las que el contrato se resuelve en una estimación anticipada frente a una revisión final son una fuente común de precios erróneos.

Paso 4 Consultar el punto final de las predicciones para el anclaje del consenso

El punto final de predicciones de FXMacroData proporciona valores de consenso prospectivos procedentes de datos oficiales de encuestas las mismas encuestas que los participantes del mercado de predicción utilizan para anclar sus antecedentes.

def get_predictions(currency: str, indicator: str) -> list[dict]:
    url = f"{BASE}/predictions/{currency}/{indicator}?api_key={API_KEY}"
    resp = requests.get(url, timeout=10)
    resp.raise_for_status()
    return resp.json().get("data", [])

cpi_predictions = get_predictions("usd", "inflation")

# Most recent upcoming prediction
if cpi_predictions:
    next_pred = cpi_predictions[0]
    for p in next_pred.get("predictions", []):
        print(f"Source: {p['prediction_source_label']}")
        print(f"Consensus: {p['predicted_value']}%")
        print(f"For release date: {next_pred['date']}")

Forma de la respuesta de la muestra:

{
  "currency": "USD",
  "indicator": "inflation",
  "count": 1,
  "prediction_count": 1,
  "data": [
    {
      "announcement_id": "usd_inflation_2026-05-14",
      "currency": "usd",
      "indicator": "inflation",
      "date": "2026-05-14",
      "announcement_datetime": 1747216200,
      "predictions": [
        {
          "predicted_value": 2.8,
          "prediction_type": "market_consensus",
          "prediction_source": "philly_fed_spf",
          "prediction_source_label": "Philadelphia Fed Survey of Professional Forecasters"
        }
      ]
    }
  ]
}

Si un contrato de Kalshi pregunta "¿Imprimirá el IPC de abril por encima del 2,9%?" y el consenso del SPF es del 2,8%, ahora tiene un punto de partida cuantificado: el consenso dice que no con un búfer de 0,1 puntos porcentuales.

Paso 5 Construir la señal de decisión completa

La lógica es intencionalmente simple el objetivo es una señal reproducible, basada en datos, no una caja negra:

def prediction_market_signal(
    currency: str,
    indicator: str,
    contract_threshold: float,
    contract_direction: str,  # "above" or "below"
    lookback: int = 24,
) -> dict:
    """
    Returns a signal dict for a prediction market contract.

    contract_threshold: the numeric threshold in the contract question
                        (e.g. 2.9 for "Will CPI exceed 2.9%?")
    contract_direction: "above" means YES if actual > threshold
    """
    history = get_announcement_history(currency, indicator, limit=lookback)
    surprises = compute_surprise_series(history)
    predictions = get_predictions(currency, indicator)

    consensus = None
    release_date = None
    if predictions:
        latest_preds = predictions[0].get("predictions", [])
        if latest_preds:
            consensus = latest_preds[0]["predicted_value"]
            release_date = predictions[0]["date"]

    # Base rate: how often did actual exceed the threshold historically?
    actuals_above = sum(1 for r in history if r.get("actual_value") is not None
                        and r["actual_value"] > contract_threshold)
    base_rate = actuals_above / len(history) if history else None

    # Surprise bias: mean surprise (positive = beat)
    mean_surprise = (sum(s["surprise"] for s in surprises) / len(surprises)
                     if surprises else None)

    # Directional signal
    if consensus is not None:
        buffer = consensus - contract_threshold  # positive = consensus above threshold
        signal = "NO" if (contract_direction == "above" and buffer > 0) else "YES"
    else:
        signal = "NEUTRAL"

    return {
        "currency": currency.upper(),
        "indicator": indicator,
        "contract_threshold": contract_threshold,
        "contract_direction": contract_direction,
        "consensus": consensus,
        "release_date": release_date,
        "historical_base_rate_above_threshold": base_rate,
        "mean_surprise_last_n": mean_surprise,
        "lookback": lookback,
        "signal": signal,
    }


result = prediction_market_signal(
    currency="usd",
    indicator="inflation",
    contract_threshold=2.9,
    contract_direction="above",
    lookback=24,
)

import json
print(json.dumps(result, indent=2))

Ejemplo de salida:

{
  "currency": "USD",
  "indicator": "inflation",
  "contract_threshold": 2.9,
  "contract_direction": "above",
  "consensus": 2.8,
  "release_date": "2026-05-14",
  "historical_base_rate_above_threshold": 0.33,
  "mean_surprise_last_n": 0.04,
  "lookback": 24,
  "signal": "NO"
}

Leer esto como: el consenso es de 2.8% (por debajo del umbral de 2.9%), la tasa de base histórica de 24 lanzamientos para la impresión del IPC por encima del 2.9% es del 33%, y la sorpresa media ha sido un modesto sesgo ascendente de +0.04 ppt. La señal bruta es NO, pero la combinación de tasa base y sesgo sorpresa le dice que esta no es una posición lean de alta convicción ajuste el tamaño de la posición en consecuencia.

Paso 6 Extensión a contratos distintos del USD y a contratos de mercado cruzado

Los mercados de predicción enumeran cada vez más contratos sobre eventos macro que no son del USD: decisiones del BCE, IPC del Reino Unido, política del Banco de Japón y empleo australiano.

# ECB rate decision signal
ecb_signal = prediction_market_signal(
    currency="eur",
    indicator="policy_rate",
    contract_threshold=3.15,   # "Will ECB rate fall below 3.15%?"
    contract_direction="below",
    lookback=12,
)

# UK inflation signal
uk_cpi_signal = prediction_market_signal(
    currency="gbp",
    indicator="inflation",
    contract_threshold=2.5,
    contract_direction="above",
    lookback=18,
)

# Australian employment signal
aus_employment_signal = prediction_market_signal(
    currency="aud",
    indicator="employment",
    contract_threshold=30.0,   # thousands, "Will employment add 30K+?"
    contract_direction="above",
    lookback=18,
)

El El valor de la moneda de referencia ¿ Qué ? El valor de las pérdidas Los paneles de control muestran el historial de las tasas de interés y la tendencia del IPC para cada par, lo que le da una verificación visual del contexto antes de comprometerse con una posición. El BCE En el caso de los contratos de tipos de interés que se han reducido de forma constante durante las últimas cuatro reuniones, un contrato que pregunta "¿Cortará el BCE en junio?" tiene una dinámica de tipos base muy diferente al contrato que pide "¿Aumentará el Banco?"

Paso 7 Supervisar el posicionamiento del COT como capa de confirmación

Los contratos de Kalshi y Polymarket sobre resultados macro no se negocian aisladamente el posicionamiento especulativo en futuros de divisas a menudo refleja las mismas opiniones direccionales. Tablero de instrumentos de la COT Si las especificaciones son fuertemente netas en USD y la señal del IPC es NO (por debajo del umbral), existe un doble borde potencial: el contrato del mercado de predicción puede valer la pena desvanecerse y la posición de divisas también puede ser vulnerable a una compresión.

Extraer datos COT programáticamente para incluirlos en su marco de señal:

def get_cot(currency: str) -> list[dict]:
    url = f"{BASE}/cot/{currency}?api_key={API_KEY}&limit=4"
    resp = requests.get(url, timeout=10)
    resp.raise_for_status()
    return resp.json().get("data", [])

usd_cot = get_cot("usd")
if usd_cot:
    latest = usd_cot[0]
    net_position = latest.get("net_position")
    print(f"USD spec net position (latest week): {net_position:+,.0f} contracts")

Poniéndolo todo juntos

El flujo de trabajo completo se ve así:

1. - ¿ Qué ? calendario de liberación para identificar los próximos anuncios y sus horarios previstos.
2. Las fechas de anuncio del partido son contratos de mercado abiertos de predicción en Kalshi o Polymarket.
3. Trae el predicciones punto final para el valor de consenso actual.
4. Calcula el serie de sorpresas históricas para medir el sesgo direccional y la tasa base.
5. Generar un señal de dirección comparando el consenso con el umbral del contrato.
6. Opcionalmente , capa en Posicionamiento de la COT de los futuros de divisas como señal de confirmación.
7. Aumente su posición basándose en la brecha entre la probabilidad implícita en el contrato y su estimación empírica de la tasa base.

Empieza .

Todos los puntos finales utilizados en esta guía están disponibles en una prueba gratuita no se requiere tarjeta de crédito. Los indicadores en USD, incluidos el IPC, el PPN, el PIB, el desempleo, el PCP básico y la tasa de política, son todos accesibles en el nivel gratuito. Los indicadores no en USD y los datos de COT requieren un plan profesional.

• Suscríbete y consigue tu clave API¿ Qué ? / suscribirse
• Calendario de liberación¿ Qué ? /tablero de control/calendario de lanzamiento
• Catálogo de indicadores en USD¿ Qué ? /api-data-docs/USD (en inglés)
• Tablero de instrumentos de la COT¿ Qué ? /tablero de control/cuchillo