Wie man Makrodaten mit R analysiert

R ist eine der leistungsfähigsten Sprachen für statistische Analyse und Finanzmodellierung und verfügt über ein ausgereiftes Ökosystem zur Arbeit mit Zeitreihendaten. httr2 Und ... Jsonlit Am Ende haben Sie einen wiederverwendbaren R-Workflow, der Daten der Zentralbank abruft, einen ordentlichen Tyble erstellt und ein veröffentlichungsfähiges Diagramm erstellt alles in weniger als 50 Zeilen Code.

Voraussetzungen

• R ≥ 4,2 und RStudio (oder jede R-Umgebung)
• Die folgenden Packungen: httr2- Ich weiß . jsonlite- Ich weiß . dplyr- Ich weiß . tidyr- Ich weiß . lubridate- Ich weiß . ggplot2
• Ein FXMacroData API-Schlüssel melden Sie sich an /abonnieren - Ich will einen bekommen.

Installieren Sie die erforderlichen Pakete einmal, wenn Sie sie noch nicht haben:

install.packages(c("httr2", "jsonlite", "dplyr", "tidyr", "lubridate", "ggplot2"))

Schritt 1 Die API-Form verstehen

Jeder Endpunkt des FXMacroData-Indikators folgt demselben URL-Muster:

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

Die Antwort ist ein JSON-Objekt mit data Hier ist ein Array , in dem jedes Element eine date Und ein val Feld (und optional ein announcement_datetime Die US-Notenbank (US Federal Reserve) wird in der Regel als "Federal Reserve" bezeichnet.

curl "https://fxmacrodata.com/api/v1/announcements/usd/policy_rate?api_key=YOUR_API_KEY&start=2022-01-01"

{
  "data": [
    { "date": "2025-03-19", "val": 4.25, "announcement_datetime": "2025-03-19T18:00:00Z" },
    { "date": "2025-01-29", "val": 4.25, "announcement_datetime": "2025-01-29T19:00:00Z" },
    { "date": "2024-12-18", "val": 4.25, "announcement_datetime": "2024-12-18T19:00:00Z" }
  ]
}

Diese saubere Struktur ist perfekt auf einen R-Datenrahmen mit minimaler Transformation abgestimmt.

Schritt 2 Setzen Sie Ihren API-Schlüssel ein

Speichern Sie Ihren API-Schlüssel in einer Umgebungsvariablen, anstatt ihn in Skripten zu kodieren. ~/.Renviron Datei:

FXMD_API_KEY=your_actual_api_key_here

Dann laden Sie die Umgebung neu und holen Sie den Schlüssel oben in jedem Skript ab:

readRenviron("~/.Renviron")
API_KEY <- Sys.getenv("FXMD_API_KEY")
if (nchar(API_KEY) == 0) stop("FXMD_API_KEY is not set in .Renviron")

Schritt 3 Schreiben Sie einen allgemeinen Abrufhilfe

Mit httr2 Sie erstellen Anfragen deklarativ, verarbeiten Fehler explizit und dekodieren JSON in einer einzigen Pipeline.

library(httr2)
library(jsonlite)
library(dplyr)
library(lubridate)

BASE_URL <- "https://fxmacrodata.com/api/v1"

#' Fetch an indicator time series from FXMacroData
#'
#' @param currency  Three-letter currency code, e.g. "usd", "eur", "gbp"
#' @param indicator Indicator slug, e.g. "policy_rate", "inflation", "gdp"
#' @param start     Optional start date as "YYYY-MM-DD" string
#' @param end       Optional end date as "YYYY-MM-DD" string
#' @return A tibble with columns: date (Date), val (numeric), currency (chr), indicator (chr)
fetch_indicator <- function(currency, indicator, start = NULL, end = NULL) {
  req <- request(BASE_URL) |>
    req_url_path_append("announcements", currency, indicator) |>
    req_url_query(api_key = API_KEY) |>
    req_error(is_error = \(resp) resp_status(resp) >= 400)

  if (!is.null(start)) req <- req |> req_url_query(start = start)
  if (!is.null(end))   req <- req |> req_url_query(end   = end)

  resp <- req |> req_perform()
  rows <- resp |> resp_body_json(simplifyVector = TRUE)

  as_tibble(rows$data) |>
    mutate(
      date      = as_date(date),
      val       = as.numeric(val),
      currency  = toupper(currency),
      indicator = indicator
    )
}

Die wichtigsten Entscheidungen hier: req_error() stellt sicher, dass HTTP 4xx/5xx Antworten eine R-Bedingung werfen, anstatt schweigend schlechte Daten zurückzugeben; resp_body_json(simplifyVector = TRUE) zwingt verschachtelte Arrays direkt an einen Datenrahmen anstelle einer Liste; und as_date() Sie haben ein gutes Gefühl . Date Kolonne sofort.

Schritt 4 Mehrfache Währungen und Indikatoren abrufen

Jetzt benutzen Sie den Helfer, um die Leitzinsen für vier G4-Währungen über ein dreijähriges Zeitfenster zu ziehen genau die Art von Multi-Währungsvergleich, der Divergenz-Handelsentscheidungen treibt:

currencies <- c("usd", "eur", "gbp", "jpy")
START      <- "2022-01-01"

# Pull policy rates for all four currencies and stack into one tibble
policy_rates <- purrr::map_dfr(
  currencies,
  \(ccy) fetch_indicator(ccy, "policy_rate", start = START)
)

# Quick check
dplyr::glimpse(policy_rates)
#> Rows: ~80
#> Columns: date <date>, val <dbl>, currency <chr>, indicator <chr>

Sie können zusätzliche Indikatoren genauso einfach abrufen. Zum Beispiel, indem Sie die Inflation neben den Leitzinsen ziehen, können Sie den realen Zinsspread berechnen, ein wichtiger Treiber der Carry-Trade-Positionierung:

inflation <- purrr::map_dfr(
  currencies,
  \(ccy) fetch_indicator(ccy, "inflation", start = START)
)

# Combine into one tidy frame
macro_data <- bind_rows(policy_rates, inflation)

Schritt 5 Daten reinigen und neu gestalten

Bei den meisten Analysen müssen die Daten eingegeben werden. breit Format eine Spalte pro Indikator pro Währung anstelle des von der API zurückgegebenen gestapelten ordentlichen Formats. pivot_wider() Der Anruf verarbeitet das in einem Schritt und fill() die wenigen Ankündigungen der Zentralbank in einem regelmäßigen monatlichen Raster weiterfüllt:

library(tidyr)

# Build a regular monthly date spine
date_spine <- tibble(date = seq.Date(as_date(START), Sys.Date(), by = "month"))

# Pivot to wide: one row per date, columns = currency_indicator
wide_data <- macro_data |>
  # Use year-month as join key so quarterly data aligns to month boundaries
  mutate(date = floor_date(date, "month")) |>
  pivot_wider(
    names_from  = c(currency, indicator),
    values_from = val,
    values_fn   = \(x) last(x)   # take latest reading within each month
  )

# Left-join onto the date spine and forward-fill sparse series
full_data <- date_spine |>
  left_join(wide_data, by = "date") |>
  fill(everything(), .direction = "down")

head(full_data)

Schritt 6 Berechnung der realen Zinsspannen

Ein realer Zinsspan ist der Leitzins minus Inflation ein positiver Spread bedeutet, dass sich die Zentralbank im Verhältnis zum Wachstum der Verbraucherpreise in einem restriktiven Gebiet befindet.

spread_data <- full_data |>
  mutate(
    real_rate_usd = USD_policy_rate - USD_inflation,
    real_rate_eur = EUR_policy_rate - EUR_inflation,
    real_rate_gbp = GBP_policy_rate - GBP_inflation,
    real_rate_jpy = JPY_policy_rate - JPY_inflation,
    # EUR minus USD spread: positive = EUR relatively less restrictive
    eur_usd_spread = real_rate_eur - real_rate_usd
  )

Schritt 7 Visualisieren mit ggplot2

Mit dem ordentlichen Tyble bereit, ein ggplot2 mehrzeilige Zeilen-Diagramm nimmt ein paar Zeilen. colour Ästhetik:

library(ggplot2)

policy_rates |>
  ggplot(aes(x = date, y = val, colour = currency)) +
  geom_step(linewidth = 0.9) +
  scale_colour_manual(
    values = c(USD = "#2563eb", EUR = "#16a34a", GBP = "#7c3aed", JPY = "#dc2626")
  ) +
  scale_y_continuous(labels = scales::label_percent(scale = 1)) +
  labs(
    title   = "G4 Central Bank Policy Rates",
    x       = NULL,
    y       = "Policy rate (%)",
    colour  = "Currency",
    caption = "Source: FXMacroData"
  ) +
  theme_minimal(base_size = 13) +
  theme(legend.position = "bottom")

Verwenden geom_step() - Nein . geom_line() für die Leitzinsreihen sind die Entscheidungen der Zentralbanken diskrete Stufenänderungen, die in einem Schrittdiagramm korrekt dargestellt werden.

Schritt 8 Export für einen Bericht

Wenn Sie dieses Diagramm in ein Quarto- oder R-Markdown-Dokument einbetten, speichern Sie den Datenrahmen für die Reproduzierbarkeit in einem CSV-Format und das Diagrammsystem für die Inline-Rendering in einem hochauflösenden PNG:

readr::write_csv(spread_data, "macro_spread_data.csv")

ggsave(
  filename = "policy_rates.png",
  width    = 10,
  height   = 5.6,
  dpi      = 150
)

Für interaktive Glanz-Armbrett, die gleiche Tibble füttert direkt in plotly::ggplotly() für eine reibungslose Interaktivität.

Schritt 9 Automatisieren mit einem geplanten Skript

Um Ihre Analyse ohne manuelle Wiederholungen aktuell zu halten, wickeln Sie die Fetch-Logik in ein eigenständiges R-Skript ein und planen Sie es mit cronR (Linux/macOS) oder der Windows-Aufgabenschema:

# file: refresh_macro.R — run daily at 08:00 UTC
readRenviron("~/.Renviron")
source("fetch_helpers.R")

macro_data <- purrr::map_dfr(
  tidyr::crossing(
    currency  = c("usd", "eur", "gbp", "jpy"),
    indicator = c("policy_rate", "inflation", "unemployment")
  ),
  \(row) fetch_indicator(row$currency, row$indicator, start = "2020-01-01")
)

readr::write_csv(macro_data, paste0("data/macro_", Sys.Date(), ".csv"))
message("Refresh complete: ", nrow(macro_data), " observations written.")

Das ist das ... Endpunkt des Release-Kalenders die Aktualisierungen nur an Tagen auslösen, an denen Daten mit hoher Wirkung erwartet werden, wodurch unnötige API-Aufrufe an ruhigen Tagen eingespart werden.

Zusammenfassung

Sie haben gelernt, wie man:

• Sicher mit FXMacroData mit einer Umgebungsvariablen authentifizieren
• Bauen Sie eine wiederverwendbare . fetch_indicator() - Ich helfe dir . httr2 Und ... Jsonlit
• Mehrwährungsindikatorreihe mit purrr::map_dfr()
• Umgestalten, Vorwärtsfüllen und berechnen abgeleitete Spreads mit - Das ist nicht wahr. Und ... Zeit
• Erstellen Sie mit ggplot2
• Automatische tägliche Aktualisierungen mit einem geplanten R-Skript

Als nächsten Schritt, erkunden Sie die BIP- Ich weiß . KPIUnd ... Handelsbilanz endpoints to build a fuller macro scorecard across all G10 currencies. The same fetch helper and ggplot2 workflow applies unchanged — only the indicator slug needs to change.