Выполнение HTTP-запросов с помощью httr2
Отправляйте GET- и POST-запросы, обрабатывайте заголовки и анализируйте ответы
«Выполнение HTTP-запросов с помощью httr2» — бесплатный урок R Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения R Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс R Academy содержит 4 уроков всего.
Введение в httr2
httr2 — современный пакет R для HTTP-запросов, пришедший на смену httr. Он использует шаблон построителя на основе конвейера: начните с request(url), добавьте модификаторы, а затем выполните запрос с помощью req_perform().
library(httr2)
# Basic GET request pattern:
# request(url) -> create request object
# |> req_*() -> modify request
# |> req_perform() -> send request
# |> resp_*() -> extract from response
# Minimal example (requires internet):
# resp <- request('https://httpbin.org/get') |>
# req_perform()
# resp_status(resp) # 200
# resp_body_json(resp) # parsed JSON body
cat('httr2 follows: build -> perform -> extract')request() и req_perform()
request(url) создаёт объект запроса. req_perform() выполняет запрос и возвращает объект ответа. Затем ответ можно исследовать с помощью функций resp_*.
library(httr2)
# Build and send a GET request
# resp <- request('https://httpbin.org/get') |>
# req_perform()
# Inspect response
# resp_status(resp) # 200
# resp_status_desc(resp) # 'OK'
# resp_headers(resp) # list of headers
# resp_header(resp, 'content-type') # single header
# resp_body_string(resp) # raw body as string
# resp_body_json(resp) # parsed JSON
# resp_body_raw(resp) # raw bytes
cat('Response hierarchy:')
cat('status -> headers -> body')req_headers(): пользовательские заголовки
req_headers() добавляет или переопределяет HTTP-заголовки. Функция используется для токенов аутентификации, указания типа содержимого, заголовков версии API и пользовательских метаданных запроса.
library(httr2)
# Add custom headers
# resp <- request('https://api.example.com/data') |>
# req_headers(
# 'Authorization' = 'Bearer my_token',
# 'X-API-Version' = '2',
# 'Accept' = 'application/json'
# ) |>
# req_perform()
# Common headers:
# 'Content-Type' = 'application/json' for POST with JSON body
# 'Accept' = 'application/json' to request JSON response
# 'User-Agent' = 'MyApp/1.0' for polite identification
# 'X-API-Key' = key for key-based auth
cat('req_headers() sets HTTP request headers')req_url_query(): параметры запроса
req_url_query() безопасно добавляет параметры запроса к URL, кодируя специальные символы. Это аккуратнее, чем вручную объединять строки с помощью paste0().
library(httr2)
# Add query parameters
# resp <- request('https://api.example.com/search') |>
# req_url_query(
# q = 'R programming',
# page = 1,
# size = 20,
# sort = 'relevance'
# ) |>
# req_perform()
# Resulting URL:
# https://api.example.com/search?q=R+programming&page=1&size=20&sort=relevance
# Inspect the URL without performing:
req <- request('https://api.example.com/search') |>
req_url_query(q = 'hello world', page = 2)
req$url
# 'https://api.example.com/search?q=hello+world&page=2'POST-запросы с req_body_json()
Отправляйте данные JSON в POST-запросе с помощью req_body_json(). Функция автоматически устанавливает заголовок Content-Type: application/json и сериализует список R в JSON.
library(httr2)
# POST request with JSON body
# resp <- request('https://api.example.com/users') |>
# req_method('POST') |>
# req_body_json(list(
# name = 'Alice',
# email = 'alice@example.com',
# role = 'admin'
# )) |>
# req_perform()
# resp_status(resp) # 201 Created (if success)
# resp_body_json(resp) # returned user object
# Other body methods:
# req_body_form(...) -> application/x-www-form-urlencoded
# req_body_raw(bytes) -> raw bytes
# req_body_file(path) -> file upload
cat('req_body_json() handles Content-Type automatically')resp_body_json(): разбор ответа
resp_body_json() разбирает тело ответа как JSON и преобразует его в список R. Используйте simplifyVector=TRUE (значение по умолчанию), чтобы автоматически преобразовывать массивы JSON в векторы R, а объекты — в именованные списки.
library(httr2)
library(jsonlite)
# Simulated API response handling
# resp <- request('https://api.github.com/users/hadley') |>
# req_perform()
# user <- resp_body_json(resp)
# user$name # 'Hadley Wickham'
# user$public_repos # number of repos
# user$followers # follower count
# For arrays (simplifyVector=TRUE converts to data frame):
# resp <- request('https://api.github.com/users/hadley/repos') |>
# req_perform()
# repos <- resp_body_json(resp, simplifyVector = TRUE)
# repos$name # vector of repo names
cat('resp_body_json() with simplifyVector=TRUE -> data frame')resp_status() и обработка ошибок
resp_check_status() автоматически вызывает ошибку для ответов 4xx/5xx. Без этой функции httr2 не сообщает об ошибках при недопустимых кодах состояния — необходимо явно проверить код или вызвать resp_check_status().
library(httr2)
# Pattern: check status after perform
# resp <- request('https://api.example.com/data') |>
# req_perform() |>
# resp_check_status() # errors on 4xx/5xx
# Manual status checks:
# status <- resp_status(resp)
# if (status == 200) { ... }
# if (status == 404) { stop('Not found') }
# if (status == 401) { stop('Unauthorized') }
# if (status == 429) { Sys.sleep(60); retry() }
# HTTP status codes:
# 200 OK, 201 Created, 204 No Content
# 400 Bad Request, 401 Unauthorized, 403 Forbidden
# 404 Not Found, 429 Rate Limited
# 500 Server Error, 503 Service Unavailable
cat('Always check response status codes')req_retry(): автоматические повторы
req_retry() автоматически повторяет неудачные запросы. Укажите max_tries и при необходимости is_transient — функцию, определяющую ошибки, для которых следует повторить запрос, например 429 или 503. Это необходимо для надёжных клиентов API.
library(httr2)
# Automatic retry with exponential backoff
# resp <- request('https://api.example.com/data') |>
# req_retry(
# max_tries = 3,
# is_transient = function(resp) {
# resp_status(resp) %in% c(429, 500, 503)
# },
# backoff = ~ 2^.x # exponential: 2, 4, 8 seconds
# ) |>
# req_perform()
# Default retry behavior:
# - Retries on 429 Too Many Requests automatically
# - Uses Retry-After header if present
# - max_tries = 1 by default (no retry)
# Simple retry:
# req_retry(max_tries = 3) # retry up to 3 times total
cat('req_retry() adds resilience to API calls')req_throttle(): ограничение частоты запросов
req_throttle(rate) не позволяет превысить максимальную частоту запросов. Передайте rate = n/period (например, 10 запросов в минуту). httr2 автоматически делает паузы между запросами по мере необходимости.
library(httr2)
# Throttle to at most 10 requests per minute
# urls <- paste0('https://api.example.com/items/', 1:50)
# resps <- lapply(urls, function(url) {
# request(url) |>
# req_throttle(rate = 10 / 60) |> # 10/min
# req_perform()
# })
# Alternative: use req_perform_parallel() for parallel
# with throttle built in:
# reqs <- lapply(urls, \(u) request(u))
# resps <- req_perform_parallel(
# reqs,
# on_error = 'continue', # skip failures
# progress = TRUE
# )
cat('req_throttle(rate = 10/60) = 10 req/min')Помощники для аутентификации
httr2 предоставляет встроенные помощники для аутентификации: req_auth_basic(user, pass) для базовой аутентификации, req_auth_bearer_token(token) для токенов Bearer и req_oauth_*() для потоков OAuth.
library(httr2)
# Bearer token (most common for modern APIs)
# resp <- request('https://api.example.com/data') |>
# req_auth_bearer_token('my_api_token_here') |>
# req_perform()
# Basic authentication
# resp <- request('https://api.example.com/data') |>
# req_auth_basic('username', 'password') |>
# req_perform()
# Store tokens securely in environment variables
# token <- Sys.getenv('MY_API_TOKEN')
# resp <- request('https://api.example.com') |>
# req_auth_bearer_token(token) |>
# req_perform()
cat('Never hardcode tokens in scripts!')
cat('Use Sys.getenv() or the keyring package')Пробный запуск с req_dry_run()
req_dry_run() показывает, какой именно запрос был бы отправлен (метод, URL, заголовки и тело), но не отправляет его. Это необходимо для отладки сложных запросов перед обращением к настоящему API.
library(httr2)
# Inspect the request without sending it
req <- request('https://api.example.com/users') |>
req_method('POST') |>
req_headers(
'X-API-Version' = '2',
'Accept' = 'application/json'
) |>
req_auth_bearer_token('my_token') |>
req_body_json(list(name = 'Alice', role = 'admin')) |>
req_url_query(notify = 'true')
# Show request details without sending
req_dry_run(req)
# POST /users?notify=true HTTP/1.1
# Host: api.example.com
# Authorization: Bearer my_token
# Content-Type: application/json
# ...Быстрая проверка
Проверьте, насколько хорошо Вы поняли шаблон построения запросов в httr2.
Итоги: HTTP-запросы с httr2
Главное: httr2 использует построитель на основе конвейера: request(url) |> req_*() |> req_perform(). Добавляйте заголовки с помощью req_headers(), параметры запроса — с помощью req_url_query(), тело JSON — с помощью req_body_json(). Выполняйте аутентификацию с помощью req_auth_bearer_token(). Всегда проверяйте состояние с помощью resp_check_status(). Повышайте устойчивость с помощью req_retry() и ограничивайте частоту запросов с помощью req_throttle(). Отлаживайте запросы с помощью req_dry_run().
library(httr2)
# Complete httr2 request pattern:
# resp <- request('https://api.example.com/endpoint') |>
# req_headers('Accept' = 'application/json') |>
# req_url_query(param1 = 'value', page = 1) |>
# req_auth_bearer_token(Sys.getenv('API_TOKEN')) |>
# req_retry(max_tries = 3) |>
# req_throttle(rate = 10/60) |>
# req_perform() |>
# resp_check_status()
# Extract data:
# data <- resp_body_json(resp, simplifyVector = TRUE)
cat('build -> authenticate -> perform -> check -> extract')Часто задаваемые вопросы
Урок «Выполнение HTTP-запросов с помощью httr2» бесплатный?
Да — полный текст урока «Выполнение HTTP-запросов с помощью httr2» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс R Academy, подпишись на CoddyKit PRO. Курс R Academy содержит 4 уроков всего.
Чему я научусь в уроке «Выполнение HTTP-запросов с помощью httr2»?
Отправляйте GET- и POST-запросы, обрабатывайте заголовки и анализируйте ответы Ты практикуешь R Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.
Нужен ли мне опыт, чтобы начать R Academy?
Предыдущий опыт не требуется. R Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.
Сколько времени занимает урок «Выполнение HTTP-запросов с помощью httr2»?
Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.
Можно ли писать и запускать код в этом уроке R Academy?
Да. Каждый урок R Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.
Все уроки этого курса
- Разбор JSON с помощью jsonlite
- Выполнение HTTP-запросов с помощью httr2
- Работа с REST API в R
- Работа с вложенными структурами JSON