R Mastery: From JSON to Statistical Analysis

JSON to R: Converting API Responses to Data Frames

R's primary data structure for analysis is the data frame — a table where each column is a typed vector. When you pull data from a REST API or web scraper, the response arrives as JSON and needs to be flattened into rows and columns before you can use dplyr, ggplot2, or statistical functions. The generator produces a data.frame() scaffold with the correct column names and R types — a starting point for your analysis script.

Live Example: API Response to R Data Frame

// Input JSON (API response)
{
  "user_id": "usr_4421",
  "username": "data_analyst",
  "age": 34,
  "score": 8750.5,
  "is_active": true,
  "joined_at": "2022-03-15T10:00:00Z"
}

# Generated R Code
df <- data.frame(
  user_id   = c("sample_value"),
  username  = c("sample_value"),
  age       = c(0.0),
  score     = c(0.0),
  is_active = c(TRUE),
  joined_at = c(as.POSIXct("2024-01-01")),
  stringsAsFactors = FALSE
)

Real Usage: Fetching and Parsing JSON with jsonlite

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

# Fetch from API and parse in one step
url <- "https://api.example.com/users?limit=100"
users_raw <- fromJSON(url, flatten = TRUE)
# flatten=TRUE: nested objects become "parent.child" column names

# fromJSON returns a data.frame directly for JSON arrays of objects
class(users_raw)  # "data.frame"
nrow(users_raw)   # 100

# Refine types after parsing
users <- users_raw |>
  mutate(
    age       = as.integer(age),           # double → integer
    score     = as.numeric(score),
    is_active = as.logical(is_active),
    joined_at = ymd_hms(joined_at),        # ISO 8601 string → POSIXct
  ) |>
  select(user_id, username, age, score, is_active, joined_at)

# Inspect
glimpse(users)
summary(users$score)

Handling Nested JSON with tidyjson

library(tidyjson)
library(dplyr)

# Complex nested JSON that fromJSON can't flatten automatically
json_str <- '[
  {"id": 1, "user": {"name": "Alice", "age": 30}, "tags": ["R", "stats"]},
  {"id": 2, "user": {"name": "Bob",   "age": 25}, "tags": ["python"]}
]'

# tidyjson: step-by-step navigation
result <- json_str |>
  as.tbl_json() |>
  gather_array() |>                         # expand JSON array
  spread_values(id = jnumber("id")) |>     # extract top-level field
  enter_object("user") |>                   # navigate into "user"
  spread_values(
    name = jstring("name"),
    age  = jnumber("age")
  ) |>
  as_tibble() |>
  select(id, name, age)

# Tags as a separate table (one-to-many)
tags <- json_str |>
  as.tbl_json() |>
  gather_array() |>
  spread_values(id = jnumber("id")) |>
  enter_object("tags") |>                   # wait — it's an array
  gather_array(column.name = "tag_index") |>
  append_values_string("tag") |>
  select(id, tag)

Writing Analysis-Ready Code

library(jsonlite)
library(dplyr)
library(ggplot2)

# Full pipeline: fetch → parse → clean → visualize
sales <- fromJSON("https://api.example.com/sales/monthly", flatten = TRUE) |>
  as_tibble() |>
  mutate(
    month    = as.Date(month),
    revenue  = as.numeric(revenue),
    region   = as.factor(region)
  ) |>
  filter(!is.na(revenue)) |>
  arrange(month)

# Summarize by region
sales |>
  group_by(region) |>
  summarise(
    total_revenue = sum(revenue),
    avg_monthly   = mean(revenue),
    months        = n()
  ) |>
  arrange(desc(total_revenue))

# Plot
ggplot(sales, aes(x = month, y = revenue, color = region)) +
  geom_line() +
  geom_point() +
  scale_y_continuous(labels = scales::dollar) +
  labs(title = "Monthly Revenue by Region", x = NULL, y = "Revenue")

Frequently Asked Questions

Why does the generator use 0.0 for integer fields? JSON numbers are untyped. R's fromJSON() also defaults to numeric (double) for all numbers. Change age, count, and other whole-number fields to integer with as.integer() after parsing — it halves their memory footprint and makes intent explicit.

What's the difference between fromJSON and read_json? fromJSON() (jsonlite) aggressively simplifies — JSON arrays become vectors or data frames automatically. read_json() returns a nested R list that mirrors the JSON structure exactly, giving you more control over the parsing. Use fromJSON(flatten=TRUE) for flat API responses; use read_json() + tidyjson for deeply nested structures.

How do I handle paginated API responses? Use a while loop or purrr::map_dfr: fetch each page, bind rows, stop when the API returns an empty result or next_page is null. bind_rows(page1, page2, ...) combines multiple data frames with matching column names.

Is my JSON sent to a server? No. TypeMorph runs entirely in your browser — none of your data leaves your machine.