cURL-Befehlsgenerator & Builder

Was ist ein curl-Befehl?

# Plain GET — curl defaults to GET
curl https://api.example.com/users

# GET with a Bearer token (auth is just a header)
curl https://api.example.com/me \
  -H 'Authorization: Bearer YOUR_TOKEN'

# POST a JSON body — note the Content-Type header
curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada","role":"admin"}'

# Multipart file upload — '@' reads the file from disk
curl -X POST https://api.example.com/upload \
  -F 'file=@report.pdf' \
  -F 'title=Q3 report'

Hauptfunktionen

curl-Alternativen & HTTP-Clients

curl-Befehle — Beispiele

curl https://api.example.com/users

curl https://api.example.com/me \
  -H 'Authorization: Bearer YOUR_TOKEN'

curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada","role":"admin"}'

curl -X POST https://api.example.com/login \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'username=ada&password=s3cret'

curl -X POST https://api.example.com/upload \
  -F 'file=@report.pdf' \
  -F 'title=Q3 report'

curl -L -o archive.zip \
  https://example.com/files/archive.zip

curl -u ada:s3cret \
  https://api.example.com/private

curl -v -i https://api.example.com/health

So erstellst du einen curl-Befehl

1. 1

   HTTP-Methode wählen

   Wähle GET, POST, PUT, PATCH, DELETE, HEAD oder OPTIONS. curl verwendet standardmäßig GET; die Auswahl von POST oder einem anderen Verb fügt `-X METHOD` zum generierten Befehl hinzu. Oder tippe einen Vorlagen-Chip, um Methode und passenden Body mit einem Klick zu setzen.

2. 2

   URL und Query-Parameter eingeben

   Gib die Anfrage-URL ein (z. B. `https://api.example.com/users`). Füge Query-Parameter als Schlüssel/Wert-Paare hinzu — das Tool URL-kodiert sie und hängt `?key=value&…` automatisch an die URL an. Keine manuelle Kodierung nötig.

3. 3

   Header und Authentifizierung hinzufügen

   Füge Request-Header als Schlüssel/Wert-Paare hinzu, dann wähle ein Auth-Schema: Keins, Bearer-Token, Basic (Benutzername/Passwort) oder ein benutzerdefinierter API-Key-Header. Der richtige `Authorization`- oder benutzerdefinierte Header wird im genauen Format generiert, das der Server erwartet.

4. 4

   Request-Body festlegen

   Für POST/PUT/PATCH wähle einen Body-Typ: Rohes JSON einfügen (der `Content-Type`-Header wird automatisch hinzugefügt), URL-kodierte Formularfelder aufbauen oder einen Multipart-Upload zusammenstellen und ein Feld mit dem `@`-Präfix auf eine Datei umstellen.

5. 5

   Optionen aktivieren

   Aktiviere die benötigten Flags — Weiterleitungen folgen (`-L`), unsicheres TLS (`-k`), ausführlich (`-v`), Header einschließen (`-i`), komprimiert (`--compressed`), Ausgabe in Datei (`-o`), Verbindungs-Timeout oder Proxy (`-x`). Jede Umschaltung aktualisiert den Befehl live.

6. 6

   Kopieren, exportieren oder zurücksetzen

   Kopiere den fertigen Befehl, exportiere ihn als .sh-Skript oder setze das Formular zurück. Verwende den Mehrzeilig-Schalter, um vor dem Kopieren zwischen einzeiliger und backslash-fortgesetzter Ausgabe zu wechseln.

Häufige curl-Fehler

# PATCH beabsichtigt, aber -d allein impliziert POST
curl -d '{"role":"admin"}' \
  https://api.example.com/users/7

# Verb explizit setzen
curl -X PATCH -d '{"role":"admin"}' \
  -H 'Content-Type: application/json' \
  https://api.example.com/users/7

# Server sieht urlencoded, nicht JSON — 400/415
curl -X POST https://api.example.com/users \
  -d '{"name":"Ada"}'

# JSON-Content-Type deklarieren
curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name":"Ada"}'

# $name wird von der Shell zu leerem String expandiert
curl -d "{\"user\":\"$name\"}" \
  https://api.example.com/users

# Einfache Anführungszeichen senden den Body wörtlich
curl -d '{"user":"$name"}' \
  https://api.example.com/users

# -d macht dies zu einem POST, nicht zu einem GET
curl -d 'page=2&limit=50' \
  https://api.example.com/users

# Query-String in der URL hält es als GET
curl 'https://api.example.com/users?page=2&limit=50'

:: cmd.exe — Backslash ist kein Fortsetzungszeichen
curl -X POST https://api.example.com/users \
  -d '{"name":"Ada"}'

:: cmd.exe — eine Zeile oder ^ zur Fortsetzung verwenden
curl -X POST https://api.example.com/users -d "{\"name\":\"Ada\"}"

# Leerzeichen teilt das Argument — curl sieht zwei Args
curl https://api.example.com/search?q=hello world

# Leerzeichen kodieren (oder die ganze URL in Anführungszeichen)
curl 'https://api.example.com/search?q=hello%20world'

Häufige Anwendungsfälle

REST-API-Tests

Anfragen gegen einen REST-Endpunkt erstellen und abfeuern, ohne das Terminal zu verlassen: Methode setzen, Bearer-Token einfügen, JSON-Body senden und die Antwort lesen. Der schnellste Weg, das Verhalten einer API zu bestätigen, bevor Client-Code geschrieben wird.

Anfrage aus Dokumentation reproduzieren

API-Dokumentation zeigt Endpunkte und Parameter, aber selten einen vollständigen, kopierbaren Befehl. Methode, URL, Header und Auth hier eintragen und einen curl-Befehl erhalten, der direkt ausführbar ist — kein Kämpfen mit Quotierung oder fehlenden `Content-Type`-Headern.

CI/CD-Smoke-Test-Skripte

Einen curl-Befehl für einen Health-Check oder Post-Deploy-Smoke-Test generieren, dann als .sh exportieren und in eine Pipeline einfügen. `--connect-timeout` und `--max-time` hinzufügen, damit ein hängender Endpunkt den Build nicht blockiert, und Statuscodes mit `-w` prüfen.

Datei-Upload & -Download

Einen `multipart/form-data`-Upload mit `-F field=@file` zusammenstellen oder einen `-L -o dateiname`-Download aufbauen, der Weiterleitungen zu einem CDN folgt. Schwierige Dateinamen oder Query-Werte vorher mit unserem URL-Kodierer kodieren.

Webhook-Debugging

Eine Webhook-Nutzlast wiederholen, indem derselbe JSON-Body, den der Anbieter sendet, mit den richtigen Signatur- und `Content-Type`-Headern gepostet wird. Die genaue Anfrage lokal reproduzieren, um zu debuggen, warum der Handler sie abgelehnt hat.

Reproduzierbare Bug-Reports

Einen einzelnen, in sich geschlossenen curl-Befehl in einen Bug-Report oder PR einfügen, damit jeder die genaue Anfrage reproduzieren kann — Methode, Header, Auth-Platzhalter und Body. Weit klarer als die Anfrage in Fließtext zu beschreiben.

curl-Flags erlernen

Sehen, wie jede Formularauswahl einem echten Flag entspricht — Basic-Auth wählen und beobachten, wie `-u` erscheint; einen JSON-Body hinzufügen und beobachten, wie der `Content-Type`-Header angehängt wird. Eine praktische Möglichkeit, die Syntax zu erlernen, gepaart mit unserem curl-Cheatsheet.

Anfrage für Code-Konvertierung vorbereiten

Die Anfrage zuerst als curl aufbauen und verifizieren, dann in den HTTP-Client der App übersetzen. Der kommende Konvertieren-Tab wird einen eingefügten curl-Befehl in fetch, requests, Go, PHP, Ruby und Node.js umwandeln — starte von einem curl-Befehl, der funktioniert.

curl-Flags & Syntax-Referenz

Shell-Quotierung & Escaping

Das Tool schließt Werte in einfache Anführungszeichen ein — in POSIX-Shells die sicherste Form, da innerhalb eines single-quoted Strings nichts expandiert wird. Ein Literal-Single-Quote innerhalb eines Wertes wird als `'\''`-Sequenz ausgegeben (Anführungszeichen schließen, Backslash-Quote, Anführungszeichen erneut öffnen). In `cmd.exe` auf doppelte Anführungszeichen wechseln; Git Bash und WSL führen die generierten Single-Quote-Befehle unverändert aus.

-d vs --data-raw vs --data-binary

`-d`/`--data` entfernt Zeilenumbrüche und Wagenrückläufe aus dem Body — gut für `key=value`-Paare, verlustbehaftet für mehrzeilige Inhalte. `--data-raw` ist identisch, behandelt ein führendes `@` jedoch nicht als Dateinamen. `--data-binary` sendet Bytes exakt wie angegeben (verwende `@file`, um rohe Dateiinhalte hochzuladen). Alle drei implizieren POST, sofern die Methode nicht überschrieben wird.

Multipart (-F) vs URL-kodiert (-d)

`-F field=value` erzeugt `multipart/form-data` mit einer generierten Boundary — erforderlich für Datei-Uploads (`-F file=@pfad`) und gemischte Datei/Text-Formulare. `-d field=value` erzeugt `application/x-www-form-urlencoded`, einen einzelnen `&`-verbundenen String. Setze `Content-Type` für Multipart nie manuell; curl berechnet die Boundary und setzt den Header selbst.

Auth-Header-Kodierung

Bearer-Auth sendet `Authorization: Bearer ` wörtlich (RFC 6750). Basic-Auth aus `-u user:pass` wird Base64-kodiert in `Authorization: Basic ` übertragen — Kodierung, keine Verschlüsselung, also HTTPS verwenden. Ein API-Key ist welcher benutzerdefinierte Header auch immer der Dienst verlangt, z. B. `X-API-Key: `.

Query-String-Kodierung

Im Builder hinzugefügte Query-Parameter werden prozent-kodiert und als `?key=value&key2=value2` angehängt. Reservierte Zeichen (Leerzeichen, `&`, `=`, `#`) werden maskiert, damit die URL gültig ist. Für Body-Felder, die kodiert werden müssen, übernimmt curls eigener `--data-urlencode` die Kodierung zur Anfrage-Zeit.

Weiterleitungsverhalten (-L)

Ohne `-L` gibt curl eine 301/302-Antwort aus und stoppt. Mit `-L` folgt es dem `Location`-Header bis zur endgültigen URL. Beachte: curl löscht den `Authorization`-Header, wenn eine Weiterleitung zu einem anderen Host führt (ein Sicherheitsstandard); verwende `--location-trusted` nur, wenn du die Implikationen verstehst.

Komprimierte Antworten

`--compressed` fügt einen `Accept-Encoding`-Header hinzu, der gzip/deflate/brotli-Unterstützung ankündigt, und dekomprimiert die Antwort transparent — spart Bandbreite. Der dekodierte Body ist identisch zu einer unkomprimierten Anfrage — reine Übertragungsoptimierung, bei den meisten API-Aufrufen sicher zu aktivieren.

Ausgabe: -o vs -O

`-o dateiname` schreibt den Response-Body in eine selbst benannte Datei; `-O` speichert ihn unter dem Remote-Dateinamen aus dem URL-Pfad. Beide unterdrücken die normale stdout-Ausgabe. Mit `-L` kombinieren, damit Weiterleitungen zur eigentlichen Ressource aufgelöst werden, bevor die Datei geschrieben wird.

Best Practices für curl-Anfragen

Niemals Secrets in geteilten Befehlen hartcodieren

Ein curl-Befehl, den du in einem PR, einem Ticket oder einem Chat einfügst, wird von anderen gelesen und von Tools indexiert. Ersetze Token und Passwörter durch Platzhalter (`YOUR_TOKEN`) oder referenziere eine Umgebungsvariable (`-H "Authorization: Bearer $API_TOKEN"`). Für lange Credentials kann curl einen Header aus einer Datei lesen mit `-H @headerfile`, sodass das Secret nie in der Shell-History erscheint.

--data-binary @file für binäre Nutzlasten bevorzugen

Wenn der Body eine Datei ist, deren Bytes wichtig sind — ein Bild, eine signierte Nutzlast, JSON mit bedeutsamen Leerzeichen — verwende `--data-binary @file` statt `-d @file`. Einfaches `-d` entfernt Zeilenumbrüche und Wagenrückläufe und korrumpiert binäre und mehrzeilige Inhalte lautlos. `--data-binary` sendet die Datei exakt so, wie sie auf dem Datenträger liegt.

Header-Werte in Anführungszeichen einschließen

Schließe `-H`-Werte immer in Anführungszeichen ein: `-H 'Content-Type: application/json'`. Ohne Anführungszeichen teilt das Leerzeichen nach dem Doppelpunkt das Argument und curl sieht einen fehlgebildeten Header. Einfache Anführungszeichen verhindern auch die Expansion von `$`, `*` und anderen Sonderzeichen innerhalb des Wertes — genau das, was dieses Tool standardmäßig ausgibt.

--compressed zur Bandbreiteneinsparung verwenden

Füge `--compressed` bei API-Aufrufen und Downloads hinzu, um gzip/brotli-Kodierung anzufordern, die curl transparent dekomprimiert. Bei JSON-lastigen APIs kann dies die Übertragungsgröße um 70–90 % reduzieren, ohne die Antwort zu verändern — ein kostenloser Gewinn in Skripten, die Endpunkte wiederholt abrufen.

Timeouts in Skripten festlegen

In jedem automatisierten Kontext `--connect-timeout` und `--max-time` hinzufügen, damit ein langsamer oder hängender Endpunkt eine Pipeline nicht ewig blockieren kann. Ein Health-Check mit `--max-time 10` schlägt schnell fehl und ermöglicht der CI weiterzumachen. Mit `--retry N` kombinieren, um vorübergehende Netzwerkunterbrechungen aufzufangen, ohne sofort aufzugeben.

Mit -v verifizieren, bevor automatisiert wird

Bevor ein curl-Befehl in ein Skript oder einen Cron-Job gebacken wird, einmal mit `-v` ausführen, um die genaue Anfrage-Zeile, Header und TLS-Handshake zu sehen. Der schnellste Weg, eine falsche Methode, einen fehlenden `Content-Type` oder einen nicht angehängten Auth-Header zu erkennen — interaktiv debuggen, dann `-v` für die Produktion entfernen.

Häufig gestellte Fragen