Como Analisar Macro Data com R

R é uma das linguagens mais poderosas para análise estatística e modelagem financeira e tem um ecossistema maduro para trabalhar com dados de séries temporais. httr2 E ... jsonlita No final, você terá um fluxo de trabalho R reutilizável que extrai dados do banco central, constrói um tibble arrumado e produz um gráfico pronto para publicação tudo em menos de 50 linhas de código.

Requisitos prévios

• R ≥ 4,2 e RStudio (ou qualquer ambiente R)
• Os seguintes pacotes: httr2- Não . jsonlite- Não . dplyr- Não . tidyr- Não . lubridate- Não . ggplot2
• Uma chave da API do FXMacroData registe-se em / subscrever para conseguir uma

Instale os pacotes necessários uma vez, se ainda não os tiver:

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

Passo 1 Compreender a forma da API

Cada ponto final do indicador FXMacroData segue o mesmo padrão de URL:

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

A resposta é um objeto JSON com um data matriz onde cada elemento tem um date E um val campo (e opcionalmente um announcement_datetime Por exemplo, obtendo a taxa de política da Reserva Federal dos EUA:

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 estrutura limpa mapeia perfeitamente para um quadro de dados R com transformação mínima.

Passo 2 Configure sua chave de API

Armazenar sua chave de API em uma variável de ambiente em vez de codificá-lo em scripts. ~/.Renviron Ficheiro:

FXMD_API_KEY=your_actual_api_key_here

Depois recarregue o ambiente e recupere a chave no topo 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")

Passo 3 Escreva um Auxiliar de Recuperação Genérico

Com httr2 Você cria solicitações declarativamente, lida com erros explicitamente e decodifica JSON em um único 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
    )
}

As principais escolhas aqui: req_error() garante que as respostas HTTP 4xx/5xx lancem uma condição R em vez de retornarem silenciosamente dados errados; resp_body_json(simplifyVector = TRUE) coerce matrizes aninhadas diretamente para um quadro de dados em vez de uma lista; e as_date() do lubrificante dá-lhe um bom Date Coluna imediatamente.

Passo 4 Obter várias moedas e indicadores

Agora use o auxiliar para puxar as taxas de política para quatro moedas do G4 em uma janela de três anos exatamente o tipo de comparação multi-moeda que impulsiona decisões de negociação de divergência:

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 exemplo, puxando a inflação geral ao lado das taxas de juros permite calcular o spread de taxa real, um fator chave do posicionamento do carry-trade:

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

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

Passo 5 Limpe e refaça os dados

Para a maioria das análises , quer os dados . largura O formato uma coluna por indicador por moeda em vez do formato ordenado empilhado devolvido pela API. pivot_wider() A chamada lida com isto numa única etapa, e fill() Apresenta as observações de anúncios escassos do banco central numa grelha mensal regular:

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)

Passo 6 Cálculo dos diferenciais de taxa real

Um diferencial de taxa real é a taxa de juro menos a inflação um diferencial positivo significa que o banco central está em território restritivo em relação ao crescimento dos preços ao 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
  )

Passo 7 Visualizar com ggplot2

Com o tibble arrumado pronto, um gráfico de várias linhas ggplot2 leva algumas linhas. 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")

Utilize geom_step() em vez de ... geom_line() para as séries de taxas de juro as decisões do banco central são alterações discretas de escada e um gráfico de etapas representa-as corretamente.

Etapa 8 Exportação para um relatório

Se você estiver incorporando este gráfico em um documento Quarto ou R Markdown, salve o quadro de dados em um CSV para reprodução e o gráfico para um PNG de alta resolução para renderização em linha:

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

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

Para painéis interativos, o mesmo tibble alimenta diretamente o plotly::ggplotly() para interatividade sem atrito.

Passo 9 Automatizar com um script programado

Para manter sua análise atual sem re-executar manualmente, envolva a lógica de busca em um script R independente e agende-a com cronR (Linux/macOS) ou o Planeador de Tarefas do 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.")

Junta isto com o ... ponto final do calendário de liberação para acionar atualizações apenas nos dias em que se esperam dados de alto impacto, poupando chamadas desnecessárias de API em dias tranquilos.

Resumo

Aprendeu como:

• Autenticar com segurança com o FXMacroData usando uma variável de ambiente
• Construir um reutilizável . fetch_indicator() Ajudante com httr2 E ... jsonlita
• Puxar e empilhar séries de indicadores multivaluados com purrr::map_dfr()
• Reforma, preenchimento para a frente e cálculo de spreads derivados com - Não. E ... - Sim.
• Produção de gráficos de etapas prontos para publicação com ggplot2
• Automatizar atualizações diárias com um script R programado

Como próximo passo, explore o PIB- Não . PMIE ... Balança comercial O mesmo auxiliar de busca e o mesmo fluxo de trabalho ggplot2 aplicam-se inalterados só a lesma do indicador precisa mudar.