HTTP-Anfragen mit httr2 senden
Senden Sie GET- und POST-Anfragen, verarbeiten Sie Header und bearbeiten Sie Antworten
HTTP-Anfragen mit httr2 senden ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Einführung in httr2
httr2 ist das moderne R-Paket für HTTP-Anfragen und der Nachfolger von httr. Es verwendet ein Pipe-basiertes Builder-Muster: Beginnen Sie mit request(url), fügen Sie Modifikatoren hinzu und führen Sie die Anfrage anschließend mit req_perform() aus.
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() und req_perform()
request(url) erstellt ein Anfrageobjekt. req_perform() führt die Anfrage aus und gibt ein Antwortobjekt zurück. Die Antwort kann anschließend mit resp_*-Funktionen untersucht werden.
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(): Benutzerdefinierte Header
req_headers() fügt HTTP-Header hinzu oder überschreibt sie. Die Funktion wird für Authentifizierungstoken, die Angabe des Inhaltstyps, API-Versions-Header und benutzerdefinierte Metadaten der Anfrage verwendet.
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(): Abfrageparameter
req_url_query() hängt Abfrageparameter sicher an die URL an und kodiert dabei Sonderzeichen. Das ist sauberer, als Zeichenfolgen manuell mit paste0() zu verketten.
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-Anfragen mit req_body_json()
Senden Sie JSON-Daten in einer POST-Anfrage mit req_body_json(). Die Funktion setzt automatisch den Header Content-Type: application/json und serialisiert die R-Liste in 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(): Antwort parsen
resp_body_json() parst den Antworttext als JSON in eine R-Liste. Verwenden Sie simplifyVector=TRUE (Standard), um JSON-Arrays automatisch in R-Vektoren und Objekte in benannte Listen umzuwandeln.
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() und Fehlerbehandlung
resp_check_status() löst bei 4xx-/5xx-Antworten automatisch einen Fehler aus. Ohne diese Funktion erzeugt httr2 bei fehlerhaften Statuscodes keinen Fehler – Sie müssen den Status ausdrücklich prüfen oder resp_check_status() aufrufen.
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(): Automatische Wiederholungen
req_retry() wiederholt fehlgeschlagene Anfragen automatisch. Geben Sie max_tries und optional is_transient an (eine Funktion, die wiederholbare Fehler wie 429 oder 503 erkennt). Das ist unverzichtbar für robuste API-Clients.
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(): Ratenbegrenzung
req_throttle(rate) stellt sicher, dass Sie eine maximale Anfragerate nicht überschreiten. Übergeben Sie rate = n/period (z. B. 10 Anfragen pro Minute). httr2 wartet bei Bedarf automatisch zwischen den Anfragen.
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')Hilfsfunktionen für die Authentifizierung
httr2 bietet integrierte Hilfsfunktionen für die Authentifizierung: req_auth_basic(user, pass) für die Basic-Authentifizierung, req_auth_bearer_token(token) für Bearer-Token und req_oauth_*() für OAuth-Abläufe.
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')Probelauf mit req_dry_run()
req_dry_run() zeigt genau an, welche Anfrage gesendet würde (Methode, URL, Header und Body), ohne sie tatsächlich zu senden. Das ist unverzichtbar, um komplexe Anfragen zu debuggen, bevor Sie eine echte API aufrufen.
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
# ...Kurzer Test
Testen Sie Ihr Verständnis des Musters zum Erstellen von Anfragen mit httr2.
Zusammenfassung: HTTP-Anfragen mit httr2
Wichtige Erkenntnisse: httr2 verwendet einen Pipe-basierten Builder: request(url) |> req_*() |> req_perform(). Fügen Sie Header mit req_headers(), Abfrageparameter mit req_url_query() und einen JSON-Body mit req_body_json() hinzu. Authentifizieren Sie sich mit req_auth_bearer_token(). Prüfen Sie den Status immer mit resp_check_status(). Erhöhen Sie die Robustheit mit req_retry() und begrenzen Sie die Rate mit req_throttle(). Nutzen Sie req_dry_run() zum Debuggen.
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')Häufig gestellte Fragen
Ist die Lektion „HTTP-Anfragen mit httr2 senden“ kostenlos?
Ja — der vollständige Text von „HTTP-Anfragen mit httr2 senden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „HTTP-Anfragen mit httr2 senden“?
Senden Sie GET- und POST-Anfragen, verarbeiten Sie Header und bearbeiten Sie Antworten Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „HTTP-Anfragen mit httr2 senden“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- JSON mit jsonlite parsen
- HTTP-Anfragen mit httr2 senden
- REST-APIs in R verwenden
- Verschachtelte JSON-Strukturen verarbeiten