Cómo analizar datos macro con R

R es uno de los lenguajes más potentes para el análisis estadístico y el modelado financiero y tiene un ecosistema maduro para trabajar con datos de series temporales. el número de ¿ Qué ? jsonlita Al final tendrás un flujo de trabajo R reutilizable que extrae datos del banco central, construye un tibble ordenado y produce un gráfico listo para la publicación todo en menos de 50 líneas de código.

Los requisitos previos

• R ≥ 4,2 y RStudio (o cualquier entorno R)
• Los siguientes paquetes: httr2¿ Qué ? jsonlite¿ Qué ? dplyr¿ Qué ? tidyr¿ Qué ? lubridate¿ Qué ? ggplot2
• Una clave de la API de FXMacroData registrarse en / suscribirse para conseguir uno

Instale los paquetes requeridos una vez si no los tiene:

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

Paso 1 Comprender la forma de la API

Cada punto final del indicador FXMacroData sigue el mismo patrón de URL:

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

La respuesta es un objeto JSON con un data matriz donde cada elemento tiene un date y un val campo (y opcionalmente un announcement_datetime Por ejemplo, obteniendo la tasa de política de la Reserva Federal de EE.UU.:

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

Esta estructura limpia se asigna perfectamente a un marco de datos R con una transformación mínima.

Paso 2 Configure su clave de API

Almacene su clave de API en una variable de entorno en lugar de codificarla en scripts. ~/.Renviron archivo:

FXMD_API_KEY=your_actual_api_key_here

Luego recargue el entorno y recupere la clave en la parte superior de cada script:

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

Paso 3 Escriba un ayudante de búsqueda genérico

Con el el número de La función de abajo envuelve los tres pasos en un ayudante reutilizable:

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

Las opciones clave aquí: req_error() Se asegura que las respuestas HTTP 4xx/5xx lancen una condición R en lugar de devolver silenciosamente datos incorrectos; resp_body_json(simplifyVector = TRUE) obliga a las matrices anidadas directamente a un marco de datos en lugar de una lista; y as_date() de lubricante te da una adecuada Date la columna inmediatamente.

Paso 4 Obtener varias monedas e indicadores

Ahora usa el ayudante para extraer tasas de interés para cuatro monedas del G4 durante una ventana de tres años exactamente el tipo de comparación entre monedas que impulsa las decisiones de negociación de divergencia:

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>

Por ejemplo, si se compara la inflación general con las tasas de interés, se puede calcular el diferencial de tasas reales, un factor clave para el posicionamiento de carries:

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

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

Paso 5 Limpiar y remodelar los datos

Para la mayoría de los análisis , desea los datos . ancho El formato una columna por indicador y moneda en lugar del formato ordenado apilado devuelto por la API. pivot_wider() llamada maneja esto en un paso, y fill() En el caso de las entidades de crédito, el valor de las cuentas de los bancos centrales se calcula en función de la cantidad de cuentas que se han emitido en el período de referencia.

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)

Paso 6 Calcular los diferenciales de tipos reales

Un diferencial de tipo real es el tipo de interés de política menos la inflación un diferencial positivo significa que el banco central se encuentra en un territorio restrictivo en relación con el crecimiento de los precios al consumidor.

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
  )

Paso 7 Visualizar con ggplot2

Con el tibble ordenado listo, un gráfico de varias líneas ggplot2 toma unas pocas líneas. colour Estética:

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

¿ Cómo ? geom_step() En vez de ... geom_line() para las series de tipos de interés las decisiones del banco central son cambios discretos de escalera y un gráfico de pasos lo representa correctamente.

Paso 8 Exportación para un informe

Si está incrustando este gráfico en un documento de Quarto o R Markdown, guarde el marco de datos en un CSV para su reproductibilidad y la gráfica en un PNG de alta resolución para su representación en línea:

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

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

Para los paneles interactivos de brillo, el mismo tibble alimenta directamente en plotly::ggplotly() para la interactividad sin fricción.

Paso 9 Automatizar con un guión programado

Para mantener su análisis actual sin re-ejecuciones manuales, envolver la lógica de recuperación en un script R independiente y programarlo con cronR (Linux/macOS) o el Programador de tareas de 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.")

Empareja esto con el punto final del calendario de liberación para activar actualizaciones solo en días en que se esperan datos de alto impacto, ahorrando llamadas innecesarias de API en días tranquilos.

Resumen de las actividades

Usted ha aprendido cómo:

• Autenticarse de forma segura con FXMacroData utilizando una variable de entorno
• Construir una reutilizable fetch_indicator() ayudante con el número de ¿ Qué ? jsonlita
• Se extraen y se apilan series de indicadores multivaluta con purrr::map_dfr()
• Reforma, relleno hacia adelante, y calcular derivados se extiende con - ¿Qué es eso? ¿ Qué ? el tiempo
• Producir gráficos de pasos listos para su publicación con El proyecto de la Comisión
• Automatizar actualizaciones diarias con un script R programado

Como siguiente paso, explorar el El PIB¿ Qué ? PMI, y Balanza comercial El mismo ayudante de búsqueda y el mismo flujo de trabajo ggplot2 se aplican sin cambios solo se necesita cambiar la cara de indicador.