Utilisation de FXMacroData avec les marchés de prédiction: Kalshi et Polymarket

Lorsque les données macroéconomiques correspondent aux prévisions des marchés

Les marchés de prédiction sont passés de la curiosité à l'infrastructure. Le Kalshi le premier échange de prévisions réglementé par la CFTC aux États-Unis vous permet de négocier des contrats sur des résultats tels que "Will Indice de consommation des États-Unis Le taux d'inflation devrait-il dépasser 3,5% en avril? Réserve fédérale Les deux plateformes sont sensibles aux mêmes sorties de données macro qui se déplacent. USD/JPYJe suis désolé . Le taux de change, et le reste du complexe FX.

Si vous utilisez déjà FXMacroData pour suivre les calendriers des banques centrales, surveiller les surprises des IPC et extraire l'historique des taux de politique, vous avez les ingrédients pour créer un avantage systématique sur ces marchés.

Pré-requis

• Une clé d'API FXMacroData Souscrivez-vous ici pour une épreuve gratuite.
• Python 3.10 ou plus récent avec requests sont installés (pip install requests) et de la
• Un compte Kalshi avec accès API activé, ou un portefeuille Polymarket pour une référence croisée manuelle.
• Familiarité de base avec l'IPC, Salaires non agricoles, et taux de réglementation Les décisions sont.

Étape 1 Retirer le calendrier de sortie à venir

La première chose dont vous avez besoin est une image claire des annonces qui arrivent et quand. Le point de fin du calendrier de sortie de FXMacroData renvoie tous les événements macro programmés pour une devise, avec leurs dates et heures d'annonce attendues.

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"))

Chaque entrée porte un indicator les moules (par exemple inflationJe suis désolé . non_farm_payrollsJe suis désolé . policy_ratesi un contrat se résolve sur "CPI pour mars 2026", vous avez besoin de la date d'annonce exacte pour dimensionner correctement votre horizon temporel.

Étape 2 Retrouvez les données d'annonces historiques et calculez la série surprise

Si vous pouvez calculer un indice de surprise récent pour un indicateur donné, à quelle fréquence les impressions réelles battent le consensus et de combien vous avez une base de référence pour calibrer votre position.

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%}")

Le predicted_value Le champ de chaque annonce stocke le consensus du marché provenant de sources faisant autorité (Philadelphia Fed Survey of Professional Forecasters for USD indicators).

Étape 3 Indicateurs de carte des contrats de marché de prévision

Les deux Kalshi et Polymarket structurent leurs contrats macro autour de seuils d'indicateur spécifiques. La cartographie est simple une fois que vous connaissez les slugs de l'indicatrice FXMacroData. Ci-dessous un tableau de référence pour les contrats les plus liquides:

Le calendrier de sortie Lorsque le contrat Kalshi indique une date de résolution, faites une référence croisée avec la date de next_release_date Les écarts de prix lorsque le contrat se résolve sur une estimation anticipée par rapport à une révision finale sont une source commune d'erreur de prix.

Étape 4 Rechercher le critère final des prédictions pour l'ancrage du consensus

Le point final de prédiction de FXMacroData fournit des valeurs de consensus prospectives provenant de données d'enquête officielles les mêmes enquêtes que les participants au marché de la prédiction utilisent pour ancrer leurs antécédents.

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']}")

Forme de réponse de l'échantillon:

{
  "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"
        }
      ]
    }
  ]
}

If a Kalshi contract asks "Will April CPI print above 2.9%?" and the SPF consensus is 2.8%, you now have a quantified starting point: the consensus says no with a 0.1 percentage point buffer. Your historical surprise series from Step 2 then tells you how often CPI has beaten consensus by more than 0.1 percentage point, giving you an empirical base rate to compare against the contract's implied probability.

Étape 5 Construire le signal de décision complet

La logique est intentionnellement simple l'objectif est un signal reproductible, basé sur des données, pas une boîte noire:

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))

Exemple de sortie:

{
  "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"
}

Lisez ceci comme suit: le consensus est de 2,8% (en dessous du seuil de 2,9%), le taux de base historique de 24 versions pour l'impression de l'IPC supérieur à 2,9% est de 33%, et la surprise moyenne a été un biais à la hausse modeste de +0,04 ppt. Le signal brut est NON, mais la combinaison de taux de référence et de biais de surprise vous indique que ce n'est pas une position maigre à forte conviction ajustez la taille de la position en conséquence.

Étape 6 Extension aux contrats autres que les contrats en USD et aux contrits transfrontaliers

Les marchés de prévisions répertorient de plus en plus de contrats sur des événements macro non USD: décisions de la BCE, IPC britannique, politique de la Banque du Japon et emploi australien.

# 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,
)

Le Le taux de change Je suis désolé . Le taux de change Les tableaux de bord affichent l'historique des taux de change et la tendance des IPC pour chaque paire, vous donnant une vérification visuelle du contexte avant de vous engager dans une position. La BCE Le taux de base a été réduit de façon constante au cours des quatre dernières réunions, un contrat demandant "La BCE va-t-elle réduire en juin?" a une dynamique de taux de référence très différente de celui demandant

Étape 7 Surveiller le positionnement du COT comme couche de confirmation

Les contrats Kalshi et Polymarket sur les résultats macroéconomiques ne sont pas négociés isolément le positionnement spéculatif dans les contrats à terme sur devises reflète souvent les mêmes vues. Tableau de bord du COT Si les spéculations sont fortement nettes longues USD et que le signal de l'IPC est NO (en dessous du seuil), il existe un double avantage potentiel: le contrat de marché de prédiction peut valoir la peine de s'estomper et la position FX peut également être vulnérable à une contraction.

Extraire les données COT par programmation pour les inclure dans votre cadre de signal:

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")

Je suis en train de tout assembler .

Le flux de travail complet ressemble à ceci:

1. Tirez le calendrier de sortie pour identifier les annonces à venir et leurs horaires prévus.
2. Les dates de l' annonce du match sont à les contrats de marché ouverts de prévision sur Kalshi ou Polymarket.
3. Apportez le prévisions point final pour la valeur de consensus actuelle.
4. Calcule le série de surprises historiques pour mesurer le biais directionnel et le taux de base.
5. Générer un signal directionnel en comparant le consensus au seuil contractuel.
6. Facultatif couche dans Positionnement du COT de futures sur devises comme signal de confirmation.
7. Évaluez votre position en fonction de l'écart entre la probabilité implicite du contrat et votre estimation empirique du taux de base.

Commencez !

Tous les paramètres utilisés dans ce guide sont disponibles en version d'essai gratuite aucune carte de crédit n'est requise. Les indicateurs en USD, y compris l'IPC, le PNB, le PIB, le chômage, le taux de base de PCE et le taux d'intérêt, sont tous accessibles sur le niveau gratuit. Les indices non USD et les données COT nécessitent un plan professionnel.

• Abonnez-vous et obtenez votre clé APIJe suis désolé . / souscrivez
• Calendrier de sortieJe suis désolé . /tableau de bord/calendrier de sortie
• Catégorie des indicateurs USDJe suis désolé . /api-data-docs/USD est le numéro de téléphone de l'entreprise.
• Tableau de bord du COTJe suis désolé . /tableau de bord/litte