curl Spickzettel: 40+ Befehlsbeispiele für HTTP & APIs

Sie sind drei SSH-Sprünge tief in einer Staging-Box, eine API liefert den falschen Inhalt zurück, und der einzige installierte HTTP-Client ist curl. Oder Sie lesen ein CI-Skript, das einen Dienst per Health-Check prüft, und möchten wissen, was -fsS eigentlich bewirkt. Oder eine Kollegin hat einen Einzeiler in Slack eingefügt, und Sie müssen ihn anpassen. curl ist überall, und die Flags sind so knapp gehalten, dass sich niemand alle merkt.

Dieser curl-Spickzettel ist genau für solche Momente gemacht. Sie bekommen eine Schnellreferenz-Tabelle mit dem guten Dutzend Flags, die Sie täglich nutzen, und danach Befehlsbeispiele zum Kopieren für jede gängige Aufgabe: GET- und POST-Anfragen, das Senden von Headern, Bearer-Token-Authentifizierung, das Hoch- und Herunterladen von Dateien sowie API-Tests in Skripten. Jeder Befehl verwendet eine echte, ausführbare URL (httpbin.org oder einen api.example.com-Platzhalter), sodass Sie ihn einfügen und ausprobieren können. Das Verhalten stützt sich auf die offizielle curl-Dokumentation und auf RFC 9110, den aktuellen Standard für HTTP-Semantik.

Schnellreferenz — die curl-Flags, die Sie wirklich brauchen

Neunzig Prozent des täglichen curl-Einsatzes sind ein Dutzend Flags. Speichern Sie diese Tabelle als Lesezeichen; der Rest des Leitfadens vertieft jedes einzelne mit ausführbaren curl-Befehlsbeispielen.

Flag	Bedeutung	Beispiel
`-X`	HTTP-Methode festlegen	`curl -X DELETE https://api.example.com/items/42`
`-H`	Einen Request-Header hinzufügen (wiederholbar)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Einen Request-Body senden (impliziert POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Einen JSON-Body senden + JSON-Header setzen	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Ein Multipart-Formularfeld / eine Datei senden	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Ausgabe in eine benannte Datei speichern	`curl -o page.html https://example.com`
`-O`	Mit dem Remote-Dateinamen speichern	`curl -O https://example.com/archive.zip`
`-L`	Redirects folgen	`curl -L https://httpbin.org/redirect/2`
`-u`	Basic Auth `user:pass`	`curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret`
`-i`	Response-Header in die Ausgabe einschließen	`curl -i https://httpbin.org/get`
`-I`	Nur Header abrufen (HEAD)	`curl -I https://example.com`
`-v`	Ausführlich: Request + TLS-Handshake anzeigen	`curl -v https://example.com`
`-s`	Still (keine Fortschrittsanzeige)	`curl -s https://httpbin.org/get`
`-w`	Variablen nach dem Transfer ausgeben	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Cookies senden (String oder Datei)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Empfangene Cookies in einem Jar speichern	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	TLS-Zertifikatsprüfung überspringen	`curl -k https://self-signed.example.com`
`--http2`	HTTP/2 anfordern	`curl --http2 https://example.com`
`--http3`	HTTP/3 (QUIC) anfordern	`curl --http3 https://example.com`
`-T`	Eine Datei mit PUT hochladen	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	Ein Body-Feld URL-codieren	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Begrenzt die Gesamtdauer der Übertragung (Sekunden)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Begrenzt den Verbindungsaufbau (Sekunden)	`curl --connect-timeout 5 https://example.com`
`--retry`	Wiederholt eine fehlgeschlagene Übertragung N-mal	`curl --retry 3 https://example.com`
`--limit-rate`	Begrenzt die Übertragungsbandbreite	`curl --limit-rate 2M -O https://example.com/big.iso`

curl-Syntaxgrundlagen — Anatomie einer Anfrage

Ein curl-Befehl besteht aus dem Binary, einigen Flags und einer URL. Die URL kann vor oder nach den Flags stehen; die Reihenfolge ist curl egal. Worauf es jedoch ankommt, ist, welche Flags eine Methode oder einen Body implizieren, denn diese beeinflussen sich gegenseitig.

Eine einfache GET-Anfrage

Ohne Methoden-Flag sendet curl ein GET. Das ist der vollständige Befehl:

curl https://httpbin.org/get

httpbin spiegelt Ihre Anfrage als JSON zurück, was es ideal zum Testen macht. Einen Query-String hängen Sie genauso an, wie Sie es im Browser tun würden:

curl "https://httpbin.org/get?page=2&sort=desc"

Setzen Sie die URL in Anführungszeichen. Ein nacktes & weist Ihre Shell an, den Befehl in den Hintergrund zu verschieben, und verwirft stillschweigend alles dahinter. Das ist einer der häufigsten curl-Fehler; der Abschnitt zu den Stolperfallen weiter unten geht darauf ein.

Die Antwort sehen: Body, Header, beides

Standardmäßig gibt curl nur den Response-Body aus. Drei Flags ändern, was Sie sehen:

# Body + Statuszeile + Response-Header
curl -i https://httpbin.org/get

# Nur Header — sendet eine HEAD-Anfrage, kein Body
curl -I https://example.com

# Vollständiger Trace: Request-Zeile, Request-Header, TLS-Handshake, Response
curl -v https://example.com

Verwenden Sie -i, wenn Sie den Body plus einen schnellen Blick auf Content-Type oder ein Set-Cookie möchten. Verwenden Sie -I, um eine Ressource zu prüfen, ohne sie herunterzuladen (Dateigröße, Last-Modified, Redirect-Ziel). Greifen Sie zu -v, wenn etwas nicht stimmt und Sie genau sehen müssen, was curl gesendet hat.

Redirects folgen

curl folgt Redirects nur, wenn Sie es darum bitten. Rufen Sie eine URL auf, die 301 oder 302 zurückgibt, ohne -L, erhalten Sie die Redirect-Antwort selbst, nicht das Ziel:

# Bleibt beim 302 stehen, gibt nichts Nützliches aus
curl https://httpbin.org/redirect/1

# Folgt der Kette bis zum finalen 200
curl -L https://httpbin.org/redirect/1

Falls Sie unsicher sind, warum eine Anfrage dort landet, wo sie landet, zeigt -IL den Statuscode jedes einzelnen Sprungs. Was jeder dieser Codes bedeutet und warum 301 und 302 nicht austauschbar sind, erfahren Sie im HTTP-Statuscodes Spickzettel.

HTTP-Methoden mit curl (GET, POST, PUT, PATCH, DELETE)

curl wählt die Methode automatisch anhand Ihrer Flags: -d oder --json impliziert POST, schlichte URLs implizieren GET. Verwenden Sie -X nur, wenn Sie eine Methode brauchen, die nicht zu dem Body passt, den Sie senden.

GET mit Query-Parametern

Einen Query-String von Hand zu bauen, ist fehleranfällig, sobald Werte Leerzeichen oder & enthalten. Das -G-Flag weist curl an, --data-urlencode-Felder als korrekt codierten Query-String an die URL anzuhängen:

curl -G https://httpbin.org/get \
  --data-urlencode "q=hello world" \
  --data-urlencode "tag=c++"

Das erzeugt ?q=hello%20world&tag=c%2B%2B; curl übernimmt die Prozent-Codierung, sodass Sie keine kaputte URL verschicken.

POST: Formulardaten vs. JSON

Eine curl post request kommt in zwei gängigen Formen. Formular-codiert (der klassische HTML-Formular-Body):

curl -d "name=alice&role=admin" https://httpbin.org/post

-d setzt Content-Type: application/x-www-form-urlencoded und stellt die Methode für Sie auf POST um. Für eine JSON-API senden Sie stattdessen JSON:

curl -d '{"name":"alice","role":"admin"}' \
  -H "Content-Type: application/json" \
  https://httpbin.org/post

Es gibt einen saubereren Weg dafür, behandelt im nächsten Abschnitt.

PUT und PATCH

PUT ersetzt eine Ressource; PATCH aktualisiert einen Teil davon. PUT ist idempotent; es zweimal zu senden, hinterlässt denselben Zustand.

# Die gesamte Ressource ersetzen
curl -X PUT -d '{"name":"alice","role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

# Ein einzelnes Feld aktualisieren
curl -X PATCH -d '{"role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

DELETE

DELETE trägt meist keinen Body, daher genügt -X:

curl -X DELETE https://api.example.com/users/7

Header und JSON-Bodys senden

Der Großteil der echten API-Arbeit besteht aus Headern und JSON. Zwei Flags tragen die Last: -H und --json.

Eigene curl-Header mit `-H`

-H fügt einen Header hinzu und kann so oft wiederholt werden, wie Sie brauchen. So setzen Sie Accept, Authorization, eigene X--Header und Request-IDs:

curl https://httpbin.org/headers \
  -H "Accept: application/json" \
  -H "X-Request-Id: 9f3c1a" \
  -H "User-Agent: my-cli/1.0"

Um einen Standard-Header zu entfernen, den curl andernfalls senden würde, geben Sie ihm einen leeren Wert (-H "User-Agent:"). Um einen Header ohne Wert zu senden, verwenden Sie ein Semikolon (-H "X-Empty;").

POST JSON: `-d` vs. das moderne `--json`-Flag

Seit curl 7.82 ist --json der idiomatische Weg, eine JSON-curl post request zu senden. Es erledigt drei Dinge auf einmal: setzt Content-Type: application/json, setzt Accept: application/json und sendet den Body unverändert.

# Ausführlich, der alte Weg — drei Teile synchron zu halten
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name":"alice"}' \
  https://httpbin.org/post

# Modernes Äquivalent
curl --json '{"name":"alice"}' https://httpbin.org/post

--json ist wiederholbar und konkateniert, und --json @file.json liest den Body aus einer Datei. Bevorzugen Sie es für jede JSON-API.

Content-Type und Accept

Diese beiden Header sind die Quelle von 415- und 406-Fehlern. Content-Type beschreibt den Body, den Sie senden; Accept sagt, was Sie zurückbekommen möchten. Senden Sie JSON an einen Endpunkt, der nur Formulardaten annimmt, erhalten Sie 415 Unsupported Media Type. Fordern Sie XML von einer reinen JSON-API an, bekommen Sie womöglich 406 Not Acceptable. (Diese Codes werden im HTTP-Statuscodes-Leitfaden aufgeschlüsselt.)

Wenn die Antwort als Wand aus minifiziertem JSON zurückkommt, formatieren Sie es lesbar mit dem JSON-Formatierer, oder leiten Sie es direkt in jq, um ein einzelnes Feld zu extrahieren:

curl -s https://httpbin.org/json | jq '.slideshow.title'

Für den vollständigen Satz an jq-Filtern, also Auswählen, Mappen und Umformen von API-Antworten, siehe den jq-Spickzettel.

Authentifizierung mit curl

Vier Auth-Stile decken nahezu jede API ab: Basic Auth, Bearer-Tokens, API-Schlüssel und Cookies.

Basic Auth (`-u user:pass`)

-u sendet einen HTTP-Authorization: Basic-Header mit Ihren Anmeldedaten in Base64-Codierung:

curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret

Lassen Sie das Passwort weg (-u alice), fragt curl danach und hält es so aus Ihrer Shell-Historie heraus.

Bearer-Tokens & OAuth

Die meisten modernen APIs verwenden ein curl bearer token: ein OAuth-2.0-Access-Token oder API-Token im Authorization-Header. curl hat eine Kurzform, --oauth2-bearer, die dem Schreiben des Headers von Hand entspricht:

# Expliziter Header
curl -H "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.abc" \
  https://api.example.com/me

# Kurzform
curl --oauth2-bearer "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.abc" \
  https://api.example.com/me

Falls das Backend das Token ablehnt, dekodieren Sie es mit dem JWT-Dekodierer, um die Claims exp (Ablauf), aud (Audience) und iss (Issuer) zu prüfen, bevor Sie curl die Schuld geben. Ein abgelaufenes Token oder eines mit falscher Audience ist meist die Ursache.

API-Schlüssel (Header vs. Query-Parameter)

Manche APIs wollen den Schlüssel in einem Header, andere in einem Query-Parameter. Header sind sicherer, weil URLs in Logs und im Browser-Verlauf landen:

# Bevorzugt: Schlüssel in einem Header
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Weniger sicher: Schlüssel in der URL (landet in den Access-Logs)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookies (`-b` zum Senden, `-c` zum Speichern)

-c schreibt ein Cookie-Jar; -b liest es wieder ein. So tragen Sie eine Session über mehrere Anfragen hinweg:

# Anmelden und das Session-Cookie speichern
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Beim nächsten Aufruf wiederverwenden
curl -b jar.txt https://httpbin.org/cookies

Sicherheitshinweis: Tokens und Anmeldedaten gehören ausschließlich auf HTTPS-Verbindungen, denn TLS verschlüsselt die Header, einfaches HTTP nicht. Vermeiden Sie es, Geheimnisse direkt in die Befehlszeile zu schreiben, wo sie in Ihrer Shell-Historie und in der ps-Ausgabe landen. Lesen Sie einen Header mit -H @authfile aus einer Datei oder holen Sie den Wert aus einer Umgebungsvariable (-H "Authorization: Bearer $TOKEN").

Dateien herunter- und hochladen

curl wurde “client URL” genannt, weil das Verschieben von Dateien seine ursprüngliche Aufgabe ist. Sowohl Downloads als auch Uploads haben ein paar Flags, die man kennen sollte.

Download: `-O` vs. `-o` vs. `-C -`

-O (großes O) speichert die Datei unter ihrem Remote-Namen. -o (kleines o) lässt Sie den Namen wählen. -C - setzt einen teilweisen Download dort fort, wo er aufgehört hat:

# Unter dem Remote-Dateinamen speichern: archive.zip
curl -O https://example.com/downloads/archive.zip

# Unter einem von Ihnen gewählten Namen speichern
curl -o backup.zip https://example.com/downloads/archive.zip

# Einen unterbrochenen Download fortsetzen
curl -C - -O https://example.com/downloads/archive.zip

# Redirects zur eigentlichen Datei folgen (häufig bei CDNs)
curl -OL https://example.com/latest/archive.zip

Um mit curl download file Inhalte herunterzuladen, die hinter einem Redirect liegen, fügen Sie -L hinzu, denn Release-Seiten und CDN-Links leiten fast immer weiter.

Upload: `-T` vs. `-F`

-T lädt eine Datei mit PUT hoch und sendet die rohen Bytes als Body (üblich bei Object Storage und REST-Datei-Endpunkten). -F sendet eine multipart/form-data-Anfrage, dasselbe Format, das ein Browser für Datei-Eingaben verwendet:

# Rohe Bytes per PUT
curl -T report.pdf https://api.example.com/files/report.pdf

# multipart/form-data-Upload (beachten Sie das @-Präfix)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

Das @-Präfix weist curl an, den Inhalt der Datei zu lesen. Ohne es sendet -F "file=report.pdf" die wörtliche Zeichenkette report.pdf, nicht die Datei.

`--data-urlencode` und Prozent-Codierung

Wenn ein Wert Leerzeichen, &, = oder Nicht-ASCII-Zeichen enthält, sendet -d ihn unverändert und zerstört Ihre Anfrage. --data-urlencode codiert ihn korrekt:

# Falsch: das & teilt den Body, das Leerzeichen ist ungültig
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Richtig: jedes Feld wird prozent-codiert
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Falls Sie verstehen müssen, was diese %20- und %26-Sequenzen bedeuten, oder einen doppelt codierten Wert debuggen wollen, fügen Sie ihn in den URL-Dekodierer & -Kodierer ein oder lesen Sie die Schritt-für-Schritt-Erklärung auf Byte-Ebene im Leitfaden zu URL-Encoding und -Decoding.

API-Tests & Antworten inspizieren

curl glänzt in Skripten und CI, weil -w alles über den Transfer offenlegt und Exit-Codes Fehler erkennbar machen.

Nur der Statuscode

Um nur den HTTP-Status zu erfassen, verwerfen Sie den Body mit -o /dev/null und geben den Code mit -w aus:

curl -s -o /dev/null -w "%{http_code}\n" https://httpbin.org/status/204
# → 204

Das ist der Kern jedes curl api testing-Health-Checks. Um die zurückgegebene Zahl zu interpretieren, deckt der HTTP-Statuscodes Spickzettel jeden Bereich ab.

Timing-Aufschlüsselung

-w legt Timing-Variablen offen, sodass Sie sehen können, wohin die Zeit fließt: DNS, TCP-Connect, TLS oder der Server selbst.

curl -s -o /dev/null \
  -w "dns=%{time_namelookup}s connect=%{time_connect}s tls=%{time_appconnect}s total=%{time_total}s\n" \
  https://example.com
# → dns=0.004s connect=0.021s tls=0.058s total=0.142s

Ein hoher time_appconnect-Wert deutet auf TLS hin, ein hoher time_starttransfer-Wert auf ein langsames Backend.

Still, aber Fehler zeigen

-s verbirgt die Fortschrittsanzeige, verbirgt aber auch Fehlermeldungen, was in Skripten zur Falle wird. Kombinieren Sie es mit -S, damit curl bei Erfolg still bleibt und Fehler dennoch meldet:

curl -sS https://api.example.com/health

curl in CI / Skripten: bei HTTP-Fehlern fehlschlagen

Standardmäßig beendet sich curl mit 0, selbst bei einem 404 oder 500, weil der Transfer selbst erfolgreich war. In einem Health-Check ist das genau das Gegenteil von dem, was Sie wollen. -f (fail) sorgt dafür, dass curl bei HTTP-Fehlern mit einem Wert ungleich null beendet wird, sodass Ihre Pipeline sie erkennt:

# Lässt den Build fehlschlagen, wenn der Endpunkt 4xx/5xx zurückgibt
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) ist die kanonische Health-Check-Kombination. Für reichhaltigere Diagnose gibt --fail-with-body (curl 7.76+) die Fehlerantwort noch vor dem Beenden aus.

Timeouts und Wiederholungen

Ein Health-Check, der ewig hängt, ist schlimmer als einer, der schnell scheitert. Begrenzen Sie jede geskriptete Anfrage mit --max-time (Obergrenze für die gesamte Übertragung) und --connect-timeout (Obergrenze nur für den Verbindungsaufbau):

# Nach 5 s Verbindung, 10 s gesamt abbrechen
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

In einem instabilen Netz wiederholt --retry eine fehlgeschlagene Übertragung mit exponentiellem Backoff. Standardmäßig werden nur vorübergehende Fehler wiederholt (Timeouts, 5xx); mit --retry-all-errors werden auch abgelehnte Verbindungen erneut versucht:

# Bis zu 3 Versuche, mit wachsender Pause dazwischen
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Wenn ein Skript eine große Datei lädt und Sie die Leitung nicht auslasten wollen, begrenzt --limit-rate die Bandbreite — --limit-rate 2M hält sie bei 2 MB/s.

HTTP/1.1, HTTP/2 & HTTP/3 mit curl

curl handelt die HTTP-Version über TLS mittels ALPN aus. Sie können eine Version erzwingen, wenn Sie einen bestimmten Protokollpfad testen müssen.

`--http2` und `--http3`

# HTTP/2 anfordern (fällt auf 1.1 zurück, falls nicht verfügbar)
curl --http2 https://example.com

# HTTP/3 über QUIC anfordern
curl --http3 https://example.com

HTTP/3 läuft über QUIC und erfordert TLS 1.3. Es funktioniert nur, wenn Ihr curl mit einem HTTP/3-fähigen Backend gebaut wurde und der Server es über einen Alt-Svc-Header bewirbt. Führen Sie curl --version aus, um zu bestätigen, dass HTTP3 in der Features-Zeile erscheint; ist das nicht der Fall, wird --http3 einen Fehler ausgeben.

Ausführliche TLS-/ALPN-Informationen

-v zeigt das ausgehandelte Protokoll und den TLS-Handshake, womit Sie bestätigen, dass eine Version tatsächlich wirksam wurde:

curl -v --http2 https://example.com 2>&1 | grep -i "ALPN\|HTTP/2"
# → * ALPN: server accepted h2
# → > GET / HTTP/2

Achten Sie in der Handshake-Ausgabe auf ALPN: server accepted h2 (HTTP/2) oder h3 (HTTP/3).

8 häufige curl-Stolperfallen (und wie man sie behebt)

Über diese acht stolpert früher oder später jeder.

Einfache vs. doppelte Anführungszeichen. Doppelte Anführungszeichen lassen die Shell $VARS expandieren; einfache Anführungszeichen geben alles wörtlich weiter. Verwenden Sie einfache Anführungszeichen für JSON-Bodys, damit $ und ! nicht interpretiert werden: curl --json '{"price":"$5"}'. Verwenden Sie doppelte Anführungszeichen, wenn Sie die Expansion wollen: -H "Authorization: Bearer $TOKEN".
-d codiert nicht URL-mäßig. Ein Leerzeichen oder & in einem -d-Wert beschädigt den Body. Wechseln Sie zu --data-urlencode für jeden Wert, der nicht bereits codiert ist.
Redundantes -X POST mit -d. -d impliziert bereits POST. -X POST -d ... zu schreiben, ist harmlos, aber redundant; schlimmer noch, -X GET -d ... sendet einen Body mit einem GET, was manche Server überrascht. Lassen Sie das Body-Flag die Methode bestimmen.
@ beim Lesen aus einer Datei vergessen. -d @body.json liest die Datei; -d body.json sendet den wörtlichen Text body.json. Dieselbe Falle bei -F "file=@upload.png" gegenüber -F "file=upload.png".
Bei Zertifikatsfehlern zu -k greifen. -k deaktiviert die TLS-Prüfung und verbirgt echte Probleme (abgelaufene Zertifikate, falscher Hostname, fehlende Zwischenzertifikate). Beheben Sie die Ursache: Installieren Sie die CA mit --cacert ca.pem oder aktualisieren Sie Ihren System-Trust-Store. Heben Sie sich -k für einen selbstsignierten Dev-Server auf, den Sie vollständig kontrollieren.
-s verschluckt Fehler. Der stille Modus verbirgt Fehler in Skripten. Verwenden Sie immer -sS, damit Fehler dennoch sichtbar werden.
[ ] { } in URLs werden geglobbt. curl behandelt [1-5] und {a,b} als URL-Bereiche/-Listen. Eine URL mit wörtlichen Klammern (häufig bei Array-Query-Parametern wie arr[]=1) wird verstümmelt. Deaktivieren Sie das Globbing mit -g: curl -g "https://api.example.com/items?id[]=1&id[]=2".
Header-Groß-/Kleinschreibung und Duplikate. HTTP-Header-Namen sind nicht case-sensitiv, aber denselben Header zweimal zu senden, sendet meist beide: manche Server nehmen den ersten, manche den letzten, manche lehnen es ab. Wenn Sie einen Standard wie User-Agent überschreiben, setzen Sie ihn einmal mit -H, statt sich auf die Reihenfolge zu verlassen.

curl vs. wget vs. HTTPie — welches Werkzeug wann

Alle drei rufen über HTTP ab, sind aber für unterschiedliche Aufgaben optimiert. Hier ist die curl vs wget-Entscheidung (plus HTTPie) auf einen Blick:

Aufgabe	curl	wget	HTTPie
Schneller API-Aufruf / Debugging	Hervorragend	Begrenzt	Hervorragend
JSON-Bodys	Gut (`--json`)	Umständlich	Hervorragend (nativ)
Rekursiver Site-Download / Spiegelung	Nein	Hervorragend (`-r`)	Nein
Große Downloads fortsetzen + wiederholen	Gut (`-C -`)	Hervorragend (eingebaut)	Nein
Skripting / CI (Exit-Codes, `-w`)	Hervorragend	Gut	Gut
Hübsche, farbige Ausgabe standardmäßig	Nein	Nein	Hervorragend
Fast überall vorinstalliert	Ja	Oft	Selten

Die Kurzfassung: Greifen Sie zu curl für API-Debugging und Skripte (es ist überall, und -w ist unübertroffen), zu HTTPie, wenn Sie auf Ihrem eigenen Rechner lesbare JSON-Ergonomie möchten, und zu wget, um Sites zu spiegeln oder Dateien im Batch mit automatischen Wiederholungen herunterzuladen.

Häufig gestellte Fragen

Wofür wird curl verwendet?

curl ist ein Kommandozeilen-Tool zum Übertragen von Daten zu und von einem Server über HTTP, HTTPS, FTP und viele weitere Protokolle. Entwickler nutzen es, um APIs aufzurufen und zu debuggen, Dateien herunter- und hochzuladen sowie Health-Checks in Skripten und CI-Pipelines auszuführen.

Wie sende ich eine POST-Anfrage mit curl?

Verwenden Sie -d für Formulardaten oder --json für JSON: curl --json '{"name":"alice"}' https://httpbin.org/post. Beide Flags setzen die Methode automatisch auf POST, sodass Sie kein -X POST brauchen.

Wie füge ich einen Header in curl hinzu?

Verwenden Sie -H "Name: value" und wiederholen Sie es für mehrere Header: curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Es gibt keine Grenze, wie oft Sie -H übergeben können.

Wie sende ich ein Bearer-Token mit curl?

Übergeben Sie einen Authorization-Header: curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, oder verwenden Sie die Kurzform --oauth2-bearer YOUR_TOKEN. Senden Sie Tokens nur über HTTPS und dekodieren Sie sie beim Debuggen mit dem JWT-Dekodierer.

Wie lade ich eine Datei mit curl herunter?

Verwenden Sie -O, um den Remote-Dateinamen zu behalten, oder -o name, um einen eigenen zu wählen: curl -O https://example.com/archive.zip. Fügen Sie -L hinzu, um Redirects zu folgen, und -C -, um einen unterbrochenen Download fortzusetzen.

Wie sehe ich mit curl nur den HTTP-Statuscode?

Verwerfen Sie den Body und geben Sie den Code aus: curl -s -o /dev/null -w "%{http_code}" https://example.com. Das ist das Standardmuster für Health-Checks in Skripten.

Was ist der Unterschied zwischen curl und wget?

curl überträgt eine einzelne Ressource und schreibt standardmäßig nach stdout, was es ideal für API-Aufrufe und Skripting macht. wget ist auf das Herunterladen spezialisiert, einschließlich rekursiver Spiegelung und automatischer Wiederholungen. Für API-Tests verwenden Sie curl; für das Herunterladen großer Dateimengen wget.

Ist curl unter Windows verfügbar?

Ja. curl wird mit Windows 10 (Build 1803+) und Windows 11 ausgeliefert und ist als curl in der Eingabeaufforderung und in PowerShell verfügbar. Beachten Sie, dass PowerShell curl früher als Alias für Invoke-WebRequest führte, rufen Sie also curl.exe explizit auf, falls sich Flags unerwartet verhalten.

Fazit

curl belohnt ein wenig Auswendiglernen. Die Flag-Tabelle ganz oben deckt den weitaus größten Teil dessen ab, was Sie tippen werden. Der Rest besteht darin, zu wissen, welche Flags eine Methode implizieren, welche Anführungszeichen brauchen und welche Sie in Skripten in die Irre führen, allen voran das nackte -s. Halten Sie diesen curl-Spickzettel neben Ihrem Terminal offen. Wenn Sie Befehle lieber interaktiv zusammenstellen, probieren Sie unseren cURL-Befehlsgenerator für eine visuelle Zusammenstellung.

Die natürlichen nächsten Schritte in einem API-Workflow sind nur einen Klick entfernt. Senden Sie die Anfrage mit curl, lesen Sie mit dem HTTP-Statuscodes Spickzettel, was zurückkam, und formatieren Sie das JSON dann lesbar im JSON-Formatierer oder zerlegen Sie es mit dem jq-Spickzettel. Für die vollständige Optionsliste ist das curl-Handbuch erschöpfend, und MDNs HTTP-Referenz erklärt die Semantik hinter jeder Methode und jedem Header.