Wie man FXMacroData in einem Jupyter-Notebook (End-to-End) verwendet

Jupyter Notebook ist das bevorzugte Tool für Analysten und Entwickler, die Code, Daten und Kommentare in einem einzigen, freigegebenen Dokument kombinieren möchten. Dieser Leitfaden führt Sie durch einen vollständigen End-to-End-Workflow: Installation des FXMacroData Python SDK, Einrichtung Ihrer API-Schlüssel, Abrufen von Makro-Indikatorenreihen, Durchführung von Analysen und Erstellung von veröffentlichungsbereiten Diagrammen alles in einem einzelnen Notebook. Am Ende haben Sie ein funktionierendes, reproduzierbares Notebook, das Sie mit einem der 80+ Indikatoren erweitern können, die FXMacrodata aufdeckt.

Voraussetzungen

• Python 3.9 oder höher
• Jupyter Notebook oder JupytorLab installieren Sie mit pip install jupyterlab
• Die folgenden Packungen: requests- Ich weiß . pandas- Ich weiß . matplotlib- Ich weiß . seaborn
• Ein FXMacroData API-Schlüssel melden Sie sich an /abonnieren - Ich will einen bekommen.

Sie können alle Abhängigkeiten mit einem Befehl installieren:

pip install requests pandas matplotlib seaborn jupyterlab

Dann starten Sie JupyterLab aus Ihrem Projektordner:

jupyter lab

Schritt 1 Sichern Sie Ihren API-Schlüssel

Nie Hard-Code-Zugriffsdaten in einer Notebook-Datei Notebooks sind leicht zufällig zu teilen, und ein durchgesickter API-Schlüssel kann missbraucht werden.

Auf Linux/macOS fügen Sie diese Zeile zu Ihrem ~/.bashrc Oder ... ~/.zshrc (dann starten Sie Ihr Terminal neu oder laufen Sie source ~/.bashrc):

export FXMD_API_KEY="your_actual_api_key_here"

Bei Windows (PowerShell):

$env:FXMD_API_KEY = "your_actual_api_key_here"

Dann lesen Sie den Schlüssel oben in Ihrem Notizbuch in einer speziellen Setup-Zelle:

import os

API_KEY = os.environ.get("FXMD_API_KEY")
if not API_KEY:
    raise EnvironmentError(
        "FXMD_API_KEY environment variable is not set. "
        "See https://fxmacrodata.com/subscribe to get a key."
    )

print("API key loaded ✓")

Schritt 2 Schreiben Sie einen wiederverwendbaren Abrufhilfe

Jeder Endpunkt des FXMacroData-Indikators folgt derselben URL-Struktur:

GET https://fxmacrodata.com/api/v1/announcements/{currency}/{indicator}?api_key=YOUR_API_KEY

Die JSON-Antwort enthält eine data Hier ist ein Array , in dem jedes Objekt eine date Feld, ein val und (für genaue Zeitbestimmung) ein announcement_datetime Der folgende Helfer wandelt diese Antwort direkt in einen Panda-Datenschema um:

import requests
import pandas as pd

BASE_URL = "https://fxmacrodata.com/api/v1"

def fetch_indicator(currency: str, indicator: str,
                    start: str = None, end: str = None) -> pd.DataFrame:
    """Fetch a macro indicator time series from FXMacroData.

    Parameters
    ----------
    currency  : ISO currency code, e.g. 'usd', 'eur', 'gbp'
    indicator : Indicator slug, e.g. 'policy_rate', 'inflation', 'gdp'
    start     : Optional start date 'YYYY-MM-DD'
    end       : Optional end date 'YYYY-MM-DD'

    Returns
    -------
    pd.DataFrame with columns: date (datetime64), val (float64),
                                announcement_datetime (datetime64, nullable),
                                currency (str), indicator (str)
    """
    params = {"api_key": API_KEY}
    if start:
        params["start"] = start
    if end:
        params["end"] = end

    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params=params, timeout=15)
    resp.raise_for_status()

    rows = resp.json().get("data", [])
    if not rows:
        return pd.DataFrame(columns=["date", "val", "announcement_datetime",
                                     "currency", "indicator"])

    df = pd.DataFrame(rows)
    df["date"] = pd.to_datetime(df["date"])
    df["val"] = pd.to_numeric(df["val"], errors="coerce")
    if "announcement_datetime" in df.columns:
        df["announcement_datetime"] = pd.to_datetime(
            df["announcement_datetime"], errors="coerce", utc=True
        )
    df["currency"] = currency.upper()
    df["indicator"] = indicator
    return df.sort_values("date").reset_index(drop=True)

Der Helfer hebt einen HTTPError Bei 4xx/5xx Antworten wird die date Spalte zu einem ordnungsgemäßen datetime64 Die Anlage ist mit einer Anlage ausgestattet, die die Anlage mit einem Anschluss an die Anschlußanlage und die Anbringung von Währungs- und Indikatoretiketten erleichtert.

Schritt 3 Holen Sie sich Ihre erste Serie

Lassen Sie uns den Helfer überprüfen, indem wir die US-Notenbankentscheidungen seit 2022 abrufen:

usd_rate = fetch_indicator("usd", "policy_rate", start="2022-01-01")
usd_rate.head(10)

Sie sollten einen Datenschema mit Spalten wie:

         date   val       announcement_datetime currency    indicator
0  2022-03-16  0.25  2022-03-16T18:00:00+00:00      USD  policy_rate
1  2022-05-04  0.75  2022-05-04T18:00:00+00:00      USD  policy_rate
2  2022-06-15  1.50  2022-06-15T18:00:00+00:00      USD  policy_rate
3  2022-07-27  2.25  2022-07-27T18:00:00+00:00      USD  policy_rate
...

Siehst du die ? announcement_datetime Die Datenbank enthält die Daten für die Datenbank, die für die Anmeldung der Datenbank verwendet werden. /api-data-docs/usd/policy_rate (Rate) - Die Daten werden in USD/USD/polic_rate angezeigt.- Ich weiß .

Schritt 4 Mehrfache Währungen abrufen

Einer der leistungsstärksten Muster besteht darin, den gleichen Indikator für mehrere Währungen gleichzeitig zu ziehen und die Ergebnisse zu stapeln.

currencies = ["usd", "eur", "gbp", "aud"]
START = "2022-01-01"

policy_rates = pd.concat(
    [fetch_indicator(ccy, "policy_rate", start=START) for ccy in currencies],
    ignore_index=True
)

print(f"Fetched {len(policy_rates)} rows across {policy_rates['currency'].nunique()} currencies")
policy_rates.groupby("currency").tail(2)

Schritt 5 Kombination mehrerer Indikatoren

Um die realen Zinssätze zu berechnen, benötigen Sie sowohl den Leitzins als auch die Gesamtinflation für jede Währung.

inflation = pd.concat(
    [fetch_indicator(ccy, "inflation", start=START) for ccy in currencies],
    ignore_index=True
)

# Stack all observations into one long-form DataFrame
macro = pd.concat([policy_rates, inflation], ignore_index=True)
print(macro.groupby(["currency", "indicator"]).size().to_string())

Schritt 6 Umgestaltung und Vorfüllung

Central bank decisions are sparse — they happen 6–12 times a year. To align them with other monthly series, build a monthly date spine and forward-fill the last known value:

import numpy as np

# Floor each observation to month start for alignment
macro["month"] = macro["date"].dt.to_period("M").dt.to_timestamp()

# Pivot to wide: one column per currency+indicator combination
wide = (
    macro
    .groupby(["month", "currency", "indicator"])["val"]
    .last()                          # latest reading within the month
    .unstack(["currency", "indicator"])
)

# Build a complete monthly date spine and forward-fill
date_spine = pd.date_range(START, pd.Timestamp.today(), freq="MS")
wide = wide.reindex(date_spine).ffill()

wide.tail(3)

Schritt 7 Berechnung der realen Zinsspannen

Ein realer Zinssatz ist der nominelle Leitzins minus die Gesamtinflation. Ein positiver Spread signalisiert eine restriktive Geldpolitik; ein negativer Spreade bedeutet, dass die Zentralbank im Verhältnis zum Verbraucherpreissteigen immer noch akkommodativ ist. EURUSD-Realzinsdifferenzen gehören zu den stärksten mittelfristigen Treibern des EUR/USD:

for ccy in [c.upper() for c in currencies]:
    try:
        wide[(ccy, "real_rate")] = (
            wide[(ccy, "policy_rate")] - wide[(ccy, "inflation")]
        )
    except KeyError:
        pass  # skip if either series is missing

# EUR minus USD real rate differential
wide[("spread", "eur_usd")] = (
    wide[("EUR", "real_rate")] - wide[("USD", "real_rate")]
)

wide[[("USD", "real_rate"), ("EUR", "real_rate"), ("spread", "eur_usd")]].tail(6)

Schritt 8 Visualisieren mit Matplotlib

Mit dem DataFrame bereit, ein Multi-Panel-Diagramm nimmt nur ein paar Zeilen.

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, axes = plt.subplots(3, 1, figsize=(13, 11), sharex=True)
fig.patch.set_facecolor("#F8FAFC")

COLORS = {"USD": "#2563EB", "EUR": "#16A34A", "GBP": "#7C3AED", "AUD": "#F97316"}

# Panel 1: Policy rates
ax1 = axes[0]
for ccy in [c.upper() for c in currencies]:
    try:
        series = wide[(ccy, "policy_rate")].dropna()
        ax1.step(series.index, series.values, where="post",
                 label=ccy, color=COLORS[ccy], linewidth=1.8)
    except KeyError:
        pass
ax1.set_ylabel("Policy rate (%)")
ax1.set_title("Central Bank Policy Rates — G4", fontweight="bold")
ax1.legend(loc="upper left", fontsize=9)
ax1.grid(axis="y", alpha=0.3)

# Panel 2: Real rates
ax2 = axes[1]
for ccy in [c.upper() for c in currencies]:
    try:
        series = wide[(ccy, "real_rate")].dropna()
        ax2.plot(series.index, series.values,
                 label=ccy, color=COLORS[ccy], linewidth=1.8)
    except KeyError:
        pass
ax2.axhline(0, color="#94A3B8", linewidth=0.8, linestyle="--")
ax2.set_ylabel("Real rate (%)")
ax2.set_title("Real Interest Rates (Policy Rate − Inflation)", fontweight="bold")
ax2.legend(loc="upper left", fontsize=9)
ax2.grid(axis="y", alpha=0.3)

# Panel 3: EUR–USD spread
ax3 = axes[2]
spread = wide[("spread", "eur_usd")].dropna()
ax3.fill_between(spread.index, spread.values, 0,
                  where=spread.values >= 0,
                  color="#16A34A", alpha=0.30, label="EUR favoured")
ax3.fill_between(spread.index, spread.values, 0,
                  where=spread.values < 0,
                  color="#2563EB", alpha=0.30, label="USD favoured")
ax3.plot(spread.index, spread.values, color="#374151", linewidth=1.6)
ax3.axhline(0, color="#94A3B8", linewidth=0.8, linestyle="--")
ax3.set_ylabel("Spread (pp)")
ax3.set_title("EUR−USD Real Rate Differential", fontweight="bold")
ax3.legend(loc="upper left", fontsize=9)
ax3.grid(axis="y", alpha=0.3)

ax3.xaxis.set_major_formatter(mdates.DateFormatter("%b %Y"))
ax3.xaxis.set_major_locator(mdates.MonthLocator(interval=4))
plt.setp(ax3.xaxis.get_majorticklabels(), rotation=30, ha="right")

fig.tight_layout(h_pad=1.6)
plt.savefig("macro_analysis.png", dpi=150, bbox_inches="tight")
plt.show()

Schritt 9 Überprüfen Sie den Kalender der Veröffentlichungen

Vor der Planung von wiederkehrenden Abrufen ist es nützlich, genau zu wissen, wann die nächsten Datenveröffentlichungen fällig sind. Endpunkt des Release-Kalenders gibt bevorstehende Ankündigungsdaten für jede Währung zurück, so dass Sie Ihre Notebook-Aktualisierungen in Minuten nach jeder Veröffentlichung anstellen können, anstatt nach einem festen Zeitplan zu wählen:

def fetch_calendar(currency: str) -> pd.DataFrame:
    """Fetch upcoming release dates for a currency from the FXMacroData calendar."""
    url = f"{BASE_URL}/calendar/{currency}"
    resp = requests.get(url, params={"api_key": API_KEY}, timeout=15)
    resp.raise_for_status()
    events = resp.json().get("data", [])
    df = pd.DataFrame(events)
    if df.empty:
        return df
    df["release_date"] = pd.to_datetime(df["release_date"], errors="coerce")
    return df.sort_values("release_date").reset_index(drop=True)

# Upcoming USD releases
usd_calendar = fetch_calendar("usd")
upcoming = usd_calendar[usd_calendar["release_date"] >= pd.Timestamp.today()]
print(upcoming[["release_date", "indicator"]].head(10).to_string(index=False))

Schritt 10 Speichern und Planen

Für eine wiederholbare Analyse können Sie den breiten DataFrame in CSV exportieren und das Notizbuch über papermill, das Notizbücher aus der Befehlszeile mit Parameter-Injektion ausführt:

pip install papermill

# At the end of your notebook: persist the dataset
wide.to_csv("macro_data.csv")
print(f"Saved {wide.shape[0]} rows × {wide.shape[1]} columns to macro_data.csv")

# Execute the notebook from the command line (e.g. from cron or a CI job)
papermill macro_analysis.ipynb macro_analysis_output.ipynb \
  -p START "2022-01-01"

Verknüpfen Sie dies mit dem Release-Kalender, damit Ihre geplanten Aufgaben nur ausgeführt werden, wenn neue Indikatordaten tatsächlich erwartet werden die API-Nutzung an Tagen mit geringer Aktivität effizient halten.

Zusammenfassung

Sie haben einen vollständigen Jupyter Notebook-Workflow erstellt, der:

• Authentifiziert sich mit FXMacroData sicher über eine Umgebungsvariable
• Implementiert eine wiederverwendbare fetch_indicator() Helfer, der API-Antworten in Pandas umwandelt
• Pulls and stacks Politikzins- und Inflationsreihen für mehrere G10-Währungen
• Umgestaltet spärliche Zentralbankdaten auf eine regelmäßige monatliche Datumsspalte mit Terminfüllung
• Berechnet reale Zinsspannen und Währungsdifferenzen
• Erstellt ein dreipaneliges Matplotlib-Diagramm, das für Berichte oder Freigabe bereit ist
• Abfragt den Release-Kalender auf Zeit wiederkehrende Aktualisierungen intelligent
• Exporte Ergebnisse in CSV und Zeitpläne Notebook-Ausführung mit papermill

Als nächsten Schritt erweitern Sie das Notebook um zusätzliche FXMacroData-Serie wie Arbeitslosigkeit- Ich weiß . HandelsbilanzUnd ... KPI Die gleiche fetch_indicator() nur die Indikator-Schlange aktualisiert werden muss.