Comment analyser les données macro avec R

R est l'un des langages les plus puissants pour l'analyse statistique et la modélisation financière et il dispose d'un écosystème mature pour travailler avec les données de séries temporelles. httr2 Je suis désolé . Jsonlite À la fin, vous aurez un flux de travail R réutilisable qui extrait les données de la banque centrale, construit un tibble bien rangé et produit un graphique prêt à être publié tout cela en moins de 50 lignes de code.

Pré-requis

• R ≥ 4,2 et RStudio (ou tout environnement R)
• Les paquets suivants: httr2Je suis désolé . jsonliteJe suis désolé . dplyrJe suis désolé . tidyrJe suis désolé . lubridateJe suis désolé . ggplot2
• Une clé d'API FXMacroData inscrivez-vous à / souscrivez Pour en avoir un

Installez les paquets requis une fois si vous ne les avez pas déjà:

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

Étape 1 Comprendre la forme de l'API

Chaque indicateur FXMacroData suit le même schéma d'URL:

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

La réponse est un objet JSON avec un data une matrice où chaque élément a un date et un val Le champ de recherche est le champ de announcement_datetime Par exemple, en obtenant le taux directeur de la Réserve fédérale américaine:

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

Cette structure propre correspond parfaitement à un cadre de données R avec une transformation minimale.

Étape 2 Configurez votre clé API

Enregistrez votre clé API dans une variable d'environnement plutôt que de la coder dans des scripts. ~/.Renviron fichier:

FXMD_API_KEY=your_actual_api_key_here

Ensuite, rechargez l'environnement et récupérez la clé en haut de chaque script:

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

Étape 3 Écrivez un assistant générique de récupération

Avec . httr2 Vous créez des requêtes déclaratives, gérez les erreurs explicitement et décodez JSON dans un seul 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
    )
}

Les choix clés ici: req_error() Assure que les réponses HTTP 4xx/5xx lancent une condition R plutôt que de retourner silencieusement de mauvaises données; resp_body_json(simplifyVector = TRUE) force les tableaux imbriqués directement sur un cadre de données au lieu d'une liste; et as_date() Le lubrifiant vous donne une bonne . Date Colonne immédiatement.

Étape 4 Récupérer plusieurs monnaies et indicateurs

Maintenant, utilisez l'assistant pour tirer les taux directeurs pour quatre devises du G4 sur une fenêtre de trois ans exactement le genre de comparaison multi-values qui conduit les décisions de négociation divergence:

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>

Vous pouvez obtenir des indicateurs supplémentaires tout aussi facilement. par exemple, tirer l'inflation globale à côté des taux directeurs vous permet de calculer l'écart de taux réel, un moteur clé du positionnement de la transaction de transport:

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

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

Étape 5 Nettoyer et remodeler les données

Pour la plupart des analyses, vous voulez les données. large format une colonne par indicateur par devise plutôt que le format de l'API. pivot_wider() L'appel gère cela en une seule étape, et fill() remplit les observations rares des annonces de la banque centrale dans une grille mensuelle régulière:

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)

Étape 6 Calculer les écarts de taux réels

Un écart de taux réel est le taux directeur moins l'inflation un écart positif signifie que la banque centrale est dans un territoire restrictif par rapport à la croissance des prix à la consommation.

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
  )

Étape 7 Visualiser avec ggplot2

Avec le tibble propre prêt, un graphique multilinial ggplot2 prend quelques lignes. colour esthétique:

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

Utiliser geom_step() plutôt que ... geom_line() pour les séries de taux directeurs les décisions des banques centrales sont des changements discrets d'échelle et un schéma étapeux le représente correctement.

Étape 8 Exportation pour un rapport

Si vous intégrez ce graphique dans un document Quarto ou R Markdown, enregistrez le cadre de données dans un CSV pour la reproductibilité et le graphique en PNG haute résolution pour le rendu en ligne:

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

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

Pour les tableaux de bord interactifs, le même tibble est directement utilisé dans le tableau de bord. plotly::ggplotly() pour une interactivité à friction zéro.

Étape 9 Automatiser avec un script planifié

Pour maintenir votre analyse à jour sans répétitions manuelles, enveloppez la logique de récupération dans un script R autonome et planifiez-la avec cronR (Linux/macOS) ou le planificateur de tâches Windows:

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

Ajoutez ça à la ... point final du calendrier de sortie pour déclencher les mises à jour uniquement les jours où des données à fort impact sont attendues, évitant ainsi les appels inutiles à l'API les jours de calme.

Résumé

Vous avez appris à:

• Authentifier en toute sécurité avec FXMacroData à l'aide d'une variable d'environnement
• Construire un réutilisable fetch_indicator() Je suis un assistant . httr2 Je suis désolé . Jsonlite
• Tirer et empiler les séries d' indicateurs multi-monnaies avec purrr::map_dfr()
• Reshape, forward-fill, et calculer les écarts dérivés avec Le dépôt Je suis désolé . le temps
• Produire des tableaux d'étape prêts à être publiés avec Le projet de loi
• Automatiser les mises à jour quotidiennes avec un script R planifié

Pour la prochaine étape, explorez le Le PIBJe suis désolé . PMI, et la balance commerciale Les résultats de l'analyse de la performance de l'"indicateur" sont les mêmes que ceux de l"indicateurs de performance de la "gglot2".