Verwendung von FXMacroData mit Prognosemärkten: Kalshi und Polymarket

Wenn Makrodaten den Prognosemärkten entsprechen

Die Prognosemärkte haben sich von Neugier auf Infrastruktur verlagert. Kalshi die erste CFTC-regulierte Prognosebörse in den Vereinigten Staaten ermöglicht Ihnen den Handel mit Verträgen über Ergebnisse wie "Will US-amerikanischer KPI Überschreiten 3,5% im April?" oder "Wird die Die Federal Reserve Die beiden Plattformen bewerten die Wahrscheinlichkeit in Echtzeit und beide sind empfindlich für genau die gleichen Makrodatenveröffentlichungen, die sich bewegen. USD/JPY- Ich weiß . EUR/USD, und der Rest des FX-Komplexes.

Wenn Sie FXMacroData bereits verwenden, um Zentralbankkalender zu verfolgen, CPI-Überraschungen zu überwachen und die Kursgeschichte zu ziehen, haben Sie die Rohstoffe, um einen systematischen Vorteil auf diesen Märkten zu erzielen.

Voraussetzungen

• Ein FXMacroData API-Schlüssel Abonnieren Sie hier für eine kostenlose Testversion.
• Python 3.10 oder höher mit requests installiert (pip install requests)
• Ein Kalshi-Konto mit aktiviertem API-Zugriff oder eine Polymarket-Wallet für manuelle Überprüfung.
• Grundlegende Kenntnis von dem, was der CPI ist, Nichtlandwirtschaftliche LohnhöfteUnd ... Zinssatz Entscheidungen sind.

Schritt 1 Ziehen Sie den Kalender der nächsten Veröffentlichungen

Das erste, was Sie brauchen, ist ein klares Bild davon, welche Ankündigungen kommen und wann. Der Endpunkt des Release-Kalenders von FXMacroData gibt alle geplanten Makroevents für eine Währung mit ihren erwarteten Daten und Ankündigungstermin zurück.

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

Jeder Eintrag trägt eine indicator Schleim (z. B. inflation- Ich weiß . non_farm_payrolls- Ich weiß . policy_rate), die geplante Ankündigung als Unix-Zeitstempel und das nächste erwartete Release-Datum. Dies ist Ihre primäre Eingabe für das Filtern offener Prognose-Marktkontrakte wenn ein Vertrag auf "CPI für März 2026" endet, benötigen Sie das genaue Ankündigungsdatum, um Ihren Zeithorizont richtig zu bestimmen.

Schritt 2 Historische Ankündigungsdaten abrufen und die Überraschungsreihen berechnen

Vorhersage Märkte Preis Wahrscheinlichkeit basierend auf verfügbaren Informationen. Wenn Sie einen Überraschungsindex für eine bestimmte Indikator wie oft tatsächliche Drucke Konsens schlagen berechnen können, und um wie viel Sie eine Basislinie für die Kalibrierung Ihrer Position haben. Ziehen Sie die letzten zwölf Monate der tatsächlichen vs. Prognose Daten aus den Ankündigungen Endpunkt:

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

Die ... predicted_value Dies ist das gleiche Konsenssignal, das die Vorhersage der Marktpreise ankert, so dass Ihre Überraschungsreihe direkt mit der impliziten Wahrscheinlichkeit vergleichbar ist, die in einem Kalshi-CPI-Vertrag enthalten ist.

Schritt 3 Kartenindikatoren für Marktverträge zur Vorhersage

Sowohl Kalshi als auch Polymarket strukturieren ihre Makrokontrakte um spezifische Indikatorschwellen. Die Kartierung ist einfach, sobald Sie die FXMacroData-Indikator-Schläger kennen.

Die ... Veröffentlichungskalender Wenn ein Kalshi-Vertrag einen Abwicklungsdatum auflistet, vergleichen Sie ihn mit der next_release_date Abweichungen , bei denen der Vertrag auf eine Vorausschätzung im Vergleich zu einer endgültigen Revision beruht, sind eine häufige Quelle für Preisfehler.

Schritt 4 Abfrage der Prognosenendpunkte für die Verankerung des Konsenses

Der Prognosenendpunkt von FXMacroData liefert zukunftsgerichtete Konsenswerte, die aus offiziellen Umfragedaten stammen dieselben Umfragen, die die Marktteilnehmer des Prognosemarktes verwenden, um ihre Vorgeschichte zu verankern.

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

Form der Probenantwort:

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

Schritt 5 Erstellen Sie das vollständige Entscheidungssignal

Die Logik ist absichtlich einfach das Ziel ist ein reproduzierbares, datenbasiertes Signal, keine schwarze Box:

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

Ausgabebeispiel:

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

Lesen Sie dies als: Konsens ist 2,8% (unter der Schwelle von 2,9%), die 24-Veröffentlichung historische Basisrate für CPI Druck über 2,9% ist 33%, und die durchschnittliche Überraschung war eine bescheidene +0,04 ppt nach oben Bias. Das Rohsignal ist NEIN, aber die Kombination von Basisrate und Überraschungs Bias sagt Ihnen, dass dies nicht eine hohe Überzeugung Lean Position Größe entsprechend anzupassen.

Schritt 6 Ausdehnung auf Nicht-USD- und marktübergreifende Verträge

Die Prognosemärkte führen zunehmend Verträge über Makroereignisse außerhalb des USD auf: EZB-Entscheidungen, britischer KPI, Bank of Japan-Politik und australische Beschäftigung.

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

Die ... EUR/USD Und ... GBP/USD Das Dashboard zeigt die Kursgeschichte und den Preisindextrend für jedes Paar und gibt Ihnen eine visuelle Kontextprüfung, bevor Sie eine Position einnehmen. Die EZB Die Zinssätze der Banken werden in den letzten vier Sitzungen konsequent gesenkt.

Schritt 7 Überwachung der COT-Positionierung als Bestätigungsschicht

Die Konten von Kalshi und Polymarket auf Makroergebnisse werden nicht isoliert gehandelt Spekulative Positionierungen in FX-Futures spiegeln oft die gleichen Richtungsansichten wider. COT-Armbrett Wenn die Spezifikationen stark lang sind und das CPI-Signal NICHT (unterhalb der Schwelle) ist, gibt es eine mögliche Doppelkante: Der Prognose-Marktvertrag kann sich lohnen, zu verblassen, und die Devisenposition kann auch anfällig für eine Verknappung sein.

Programmiert COT-Daten ziehen, um sie in Ihr Signal-Framework aufzunehmen:

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

Alles zusammenstellen

Der gesamte Workflow sieht so aus:

1. Zieh die ... Veröffentlichungskalender die Ankündigungen und die geplanten Zeiten zu ermitteln.
2. Das Spiel wird bekannt gegeben . offene Marktverträge für Prognosen auf Kalshi oder Polymarket.
3. Holen Sie die ... Prognosen Endpunkt für den aktuellen Konsenswert.
4. Berechnen Sie die historische Überraschungsreihe Um Richtungsschwankungen und Basisraten zu messen.
5. Erstellen Sie eine Richtungssignal durch Vergleich des Konsenses mit dem Vertragsschwellenwert.
6. Optional eingesetzt . Position der COT von FX-Futures als Bestätigungssignal.
7. Beurteilen Sie Ihre Position anhand der Lücke zwischen der impliziten Wahrscheinlichkeit im Vertrag und Ihrer empirischen Basiszinsschätzung.

Fangen Sie an.

Alle in diesem Leitfaden verwendeten Endpunkte sind in einer kostenlosen Testversion verfügbar keine Kreditkarte erforderlich. USD-Indikatoren einschließlich CPI, NFP, BIP, Arbeitslosigkeit, Core PCE und der Kurs sind alle in der kostenloser Stufe zugänglich. Nicht-USD-Indikatoren und COT-Daten erfordern einen Professional-Plan.

• Abonnieren und erhalten Sie Ihren API-Schlüssel- Ich weiß . /abonnieren
• Veröffentlichungskalender- Ich weiß . /Dashboard/Veröffentlichungskalender
• USD-Indikatorkatalog- Ich weiß . /api-data-docs/USD (die Daten von den Datenbanken der Mitgliedstaaten)
• COT-Armbrett- Ich weiß . /Dashboard/Kriegsklo