curl ist ein Befehlszeilentool für die Übertragung von Daten mithilfe verschiedener Netzwerkprotokolle. Curl ist auf allen gängigen Betriebssystemen verfügbar und hat sich zum Standardtool für das Senden von HTTP-Anforderungen über die Befehlszeile entwickelt.
Das plattformübergreifende Dienstprogramm von curl unterstützt Protokolle wie HTTP, HTTPS, FTP und IMAP, sodass es einfach ist, Anforderungen an APIs zu senden und mit curl Website-Inhalte zu extrahieren (Scraping). Aufgrund der breiten Verfügbarkeit von curl und der Unterstützung mehrerer Protokolle wird in der REST-API-Dokumentation häufig auf curl verwiesen, um API-Aufrufe schnell direkt von der Befehlszeile aus zu testen:
In diesem Artikel erfahren Sie, wie Sie POST-Anforderungen mit curl von der Kommandozeile aus senden können.
Was ist eine POST-Anforderung?
Eine POST-Anforderung ist eine HTTP-Methode zum Senden von Daten an einen Server und eine der gängigsten HTTP-Methoden.
Wenn Sie eine POST-Anforderung senden, sind die übertragenen Daten im Anforderungstext enthalten. Auf diese Weise können Sie Daten diskreter senden als über die URL (wie Sie es bei einer GET-Anforderung tun würden). Sie können auch deutlich mehr Daten in einer POST-Anforderung senden und so die URL-Längenbeschränkungen umgehen, die von Browsern für GET-Anforderungen auferlegt werden.
Oftmals werden Sie POST-Anforderungen sehen, die zum Senden von Formularen, Hochladen von Dateien oder Senden von JSON-Daten an eine API verwendet werden. Im Vergleich zu GET werden POST-Anforderungen normalerweise nicht zwischengespeichert, und die Daten werden nicht in Ihrem Browserverlauf angezeigt, da sich die Anforderungsdaten im Hauptteil der Anfrage befinden.
So senden Sie eine POST-Anforderung mit curl
Bevor Sie mit diesem Tutorial beginnen, müssen Sie curl auf Ihrem Computer installieren. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob curl installiert ist:
curl --version
Wenn Sie eine Fehlermeldung erhalten, dass der Befehl nicht gefunden werden konnte, müssen Sie das Tool installieren.
curl installieren
Im Folgenden finden Sie die Anweisungen zur Installation von curl auf allen gängigen Betriebssystemen:
Windows
Unter Windows können Sie WinGet (den Standard-Paketmanager in Windows 11) verwenden, um curl zu installieren:
winget install curl.curl
Chocolatey ist ein weiterer Paketmanager für Windows, mit dem Sie curl mit dem folgenden Befehl installieren können:
choco install curl
Linux
curl ist in den meisten Linux-Paketmanagern verfügbar. Verwenden Sie auf Ubuntu/Debian den folgenden Befehl, um curl zu installieren:
apt-get install curl
MitRed Hat Enterprise Linux (RHEL), CentOS und Fedora können Sie curl mit dem Yellowdog Updater Modified (YUM) wie folgt installieren:
yum install curl
Wenn Sie OpenSUSE verwenden, können Sie curl mit dem folgenden Terminalbefehl installieren:
zypper install curl
Schließlich ermöglicht es Arch Linux Ihnen, pacman zu verwenden, um curl mit folgendem Befehl zu installieren:
pacman -Sy curl
macOS
Mit Homebrew ist es am einfachsten, curl auf macOS zu installieren. Stellen Sie sicher, dass Sie Homebrew installiert haben, und führen Sie dann den folgenden Befehl aus:
brew install curl
Nun, da Sie curl auf Ihrem Betriebssystem installiert haben, können Sie lernen, wie Sie POST-Anforderungen stellen.
Eine POST-Anforderung stellen
Mitcurl können Sie beim Senden von POST-Anforderungen mehrere Optionen angeben. In den folgenden Abschnitten werden einige allgemeine curl-Funktionen vorgestellt, auf die Sie möglicherweise stoßen, wenn Sie POST-Anforderungen mit dem Dienstprogramm stellen.
Spezifizieren Sie die POST-Methode
Wenn Sie HTTP-Anforderungen mit curl stellen, müssen Sie die HTTP-Methode angeben, die Sie ausführen möchten. Zu den HTTP-Methoden gehören GET, POST, PUT und DELETE. Mit curl können Sie die HTTP-Methode angeben, die Sie verwenden möchten, indem Sie das Befehlszeilen-Flag -X verwenden.
Um beispielsweise eine POST-Anforderung an https://httpbin.org/anythingzu senden, können Sie den folgenden curl-Befehl in Ihrem Terminal ausführen:
curl -X POST https://httpbin.org/anything
httpbin.org gibt den Anforderungstext und die Header in der Antwort wieder. Deine Antwort sollte so aussehen:
{
"args": {},
"data": "",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": null,
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Das Flag -X POST entspricht der Verwendung des Flag --request POST . Sie können also auch den folgenden Befehl ausführen und dasselbe Ergebnis erzielen:
curl --request POST https://httpbin.org/anything
Die Antwort sieht genauso aus wie die vorherige.
Mehr über die Flags -X und --request erfahren Sie in der offiziellen Dokumentation.
Inhaltstyp (Content-Type) festlegen
Beim Senden einer POST-Anforderung ist es wichtig, die Art des von Ihnen gesendeten Inhalts im Hauptteil der Anforderung anzugeben, damit der Server den Anforderungstext korrekt interpretieren kann. Sie können MIME-Typen im Content-Type-Header in einer HTTP-Anfrage verwenden, um das Format des Anforderungstexts anzugeben.
Wenn Sie beispielsweise JSON im Anforderungstext senden, müssen Sie dem Webserver mitteilen, dass er sich auf JSON-Inhalte einstellen soll, indem Sie den Content-Type-Header als application/jsonfestlegen. Wenn Sie XML senden, sollte Ihr Inhaltstyp-Header application/xmllauten. Weitere Informationen finden Sie in der offiziellen Dokumentation zu Content-Type.
Mitcurl können Sie Header für eine HTTP-Anforderung mit dem Flag -H angeben. Wenn Sie beispielsweise JSON in einer POST-Anforderung senden, zeigt der folgende curl-Befehl, wie Sie den Content-Type-Header für die Anfrage festlegen können:
curl -X POST -H 'Content-Type: application/json' -d '{}' https://httpbin.org/anything
In der Antwort können Sie den Content-Type-Header sehen, der als application/jsonfestgelegt ist:
{
"args": {},
"data": "{}",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Content-Length": "2",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=-11111111-111111111111111111111111"
},
"json": {},
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Das Flag -H kann auch mit dem längeren Flag --header angegeben werden. In diesem Fall würde Ihr curl-Befehl so aussehen:
curl -X POST --header 'Content-Type: application/json' -d '{}' https://httpbin.org/anything
Ihre Antwort würde genauso aussehen wie die vorherige.
Daten senden
Sie haben vielleicht bemerkt, dass die früheren Befehle das Flag -d hatten. Mit diesem Flag können Sie die Daten angeben, die im Anforderungstext gesendet werden sollen. Sie können das Flag verwenden, um eine beliebige Zeichenfolge von Werten (in Anführungszeichen) zu übermitteln, z. B.:
curl -X POST -H 'Content-Type: application/json' -d '{
"FirstName": "Joe",
"LastName": "Soap"
}' https://httpbin.org/anything
Sie werden feststellen, dass httpbin.org die von Ihnen gesendeten Textdaten in der Eigenschaft data der Antwort anzeigt.
Wenn Sie eine Datei mit Daten haben, die curl im Textkörper senden soll, geben Sie den Dateinamen mit dem Präfix @ an. Der folgende Befehl liest den Inhalt von body.json und sendet ihn über den Anforderungstext:
curl -X POST -H 'Content-Type: application/json' -d @body.json https://httpbin.org/anything
In diesem Fall enthält die Datei body.json Folgendes:
{
"FirstName": "Joe",
"LastName": "Soap"
}
Beim Senden sollte httpbin.org die folgende Antwort zurücksenden:
{
"args": {},
"data": "{\t\"FirstName\": \"Joe\",\t\"LastName\": \"Soap\"}",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Content-Length": "41",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": {
"FirstName": "Joe",
"LastName": "Soap"
},
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Das Flag --data verhält sich genauso wie -d, sodass Sie sie synonym verwenden können.
JSON-Daten senden
Im vorherigen Abschnitt haben Sie gesehen, wie Sie JSON-Daten senden können, indem Sie den Header Content-Type als application/json festlegen und dann die JSON-Daten mit dem Flag -d übertragen. Wenn Sie eine Anforderung senden, ist es auch wichtig, dem Webserver mitzuteilen, welches Datenformat Sie als Antwort erwarten. Sie können den Header Accept mit dem Wert application/json verwenden, um dem Webserver mitzuteilen, dass Sie eine JSON-Antwort erhalten möchten.
Der folgende Befehl sendet eine JSON-Anfrage an den Server und teilt dem Server mit, dass Sie JSON als Antwort erhalten möchten:
curl -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' -d '{
"FirstName": "Joe",
"LastName": "Soap"
}' https://httpbin.org/anything
Sie werden feststellen, dass die Eigenschaften data und json im Antworttext die JSON-Daten enthalten, die Sie in der Anfrage gesendet haben:
{
"args": {},
"data": "{\n \"FirstName\": \"Joe\",\n \"LastName\": \"Soap\"\n}",
"files": {},
"form": {},
"headers": {
"Accept": "application/json",
"Content-Length": "50",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": {
"FirstName": "Joe",
"LastName": "Soap"
},
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Das Senden und Empfangen von JSON-Daten ist beim Senden von HTTP-Anforderungen üblich. Daher bietet curl ein --json -Flag, das die Header Content-Type und Accept für Sie festlegt und die JSON-Daten im Anforderungstext sendet. Mit diesem Flag können Sie Ihren Befehl zum Senden von JSON in einer POST-Anforderung verkürzen:
curl -X POST --json '{
"FirstName": "Joe",
"LastName": "Soap"
}' https://httpbin.org/anything
Dies ergibt dieselbe Antwort wie zuvor:
{
"args": {},
"data": "{\n \"FirstName\": \"Joe\",\n \"LastName\": \"Soap\"\n}",
"files": {},
"form": {},
"headers": {
"Accept": "application/json",
"Content-Length": "50",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": {
"FirstName": "Joe",
"LastName": "Soap"
},
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Das Flag --json wurde im März 2022 in der Version 7.82 von curl veröffentlicht. Stellen Sie also sicher, dass Sie die neueste Version von curl installiert haben, bevor Sie sie verwenden.
XML-Daten senden
Mitcurl können Sie auch Daten in anderen Formaten wie etwa XML senden. Um XML-Daten zu senden, müssen Sie Ihren Content-Type -Header auf application/xml setzen und die XML-Daten mit dem Flag -d in den Anforderungstext übertragen. Sie können dem Webserver auch mitteilen, dass Sie eine XML-Antwort erwarten, indem Sie den Header Accept auf application/xmlsetzen.
Der folgende Befehl zeigt, wie Sie ein XML-Objekt in einer POST-Anforderung mit curl senden können:
curl -X POST -H 'Content-Type: application/xml' -H 'Accept: application/xml' -d '<Person>
<FirstName>Joe</FirstName>
<LastName>Soap</LastName>
</Person>' https://httpbin.org/anything
Sie finden die XML-Anforderungsdaten in der Eigenschaft data , die von httpbin.org zurückgesandt wurde:
{
"args": {},
"data": "<Person>\n <FirstName>Joe</FirstName>\n <LastName>Soap</LastName>\n</Person>",
"files": {},
"form": {},
"headers": {
"Accept": "application/xml",
"Content-Length": "79",
"Content-Type": "application/xml",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": null,
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
FormData senden
Sie können FormData verwenden, um Schlüsselwert-Datenpaare an einen Webserver zu senden. Wie der Name schon sagt, sollten Sie dieses Datenformat verwenden, wenn Sie ein Formular auf einer Webseite absenden. Die Schlüsselwert-Paare haben einen Feldnamen und einen Wert.
Mitcurl können Sie FormData angeben, indem Sie das Flag -F oder --form verwenden. Wenn Sie das Flag verwenden, geben Sie den Feldnamen und den Wert im folgenden Format an: -F oder --form .
Das nächste Snippet zeigt einen curl-Befehl, der eine POST-Anforderung unter Verwendung von FormData mit den Feldern firstName und lastName sendet:
curl -X POST -F FirstName=Joe -F LastName=Soap https://httpbin.org/anything
Die Namen und Werte der Formularfelder finden Sie in der Eigenschaft Form des httpbin.org-Antwortobjekts:
{
"args": {},
"data": "",
"files": {},
"form": {
"FirstName": "Joe",
"LastName": "Soap"
},
"headers": {
"Accept": "*/*",
"Content-Length": "248",
"Content-Type": "multipart/form-data; boundary=------------------------e2bb56049a60b8b8",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": null,
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Sie verwenden das Flag -F für jedes Feld, das Sie an den Server senden möchten.
Dateien hochladen
Sie können FormData verwenden, um Dateien in einer POST-Anforderung hochzuladen, indem Sie die Datei an ein Feld anhängen. Um curl mitzuteilen, dass ein FormData-Feld eine Datei enthält, geben Sie den Pfad zur Datei in den Feldwert ein, dem das Zeichen @ vorangestellt ist.
Der folgende curl-Befehl lädt eine Datei mit dem Namen Contract.pdf in Ihr Arbeitsverzeichnis hoch. Der Befehl verwendet ein Feld namens File , um die Datei hochzuladen:
curl -X POST -F [email protected] https://httpbin.org/anything
Die Antwort enthält die gesamte Datei und ist daher lang. Sie sollte so aussehen:
{
"args": {},
"data": "",
"files": {
"File": "..."
},
"form": {},
"headers": {
"Accept": "*/*",
"Content-Length": "246",
"Content-Type": "multipart/form-data; boundary=------------------------19ed1fc3be4d30c7",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": null,
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Zugangsdaten senden
Viele HTTP-Endpunkte erfordern zum Senden von Anforderungen eine Authentifizierung. Der Webserver entscheidet, welche Authentifizierungsmethode Sie verwenden sollten. Eine derartige Authentifizierungsmethode ist das Standardauthentifizierungsschema, mit dem Sie Anmeldeinformationen, die aus einem Benutzernamen und einem Passwort bestehen, in Ihrer Anfrage senden können. Der Server überprüft dann die Anmeldeinformationen und verarbeitet die Anfrage, sofern die Angaben korrekt sind.
curl vereinfacht das Senden grundlegender Authentifizierungsdaten mit dem Flag -u oder --user . Anschließend müssen Sie den Benutzernamen und das Passwort angeben und diese durchh einen : (Doppelpunkt) wie folgt trennen: -u .
Das folgende Snippet verwendet curl, um eine POST-Anforderung mit Benutzeranmeldeinformationen und einem JSON-Text zu senden:
curl -X POST -u 'admin:password123' --json '{
"FirstName": "Joe",
"LastName": "Soap"
}' https://httpbin.org/anything
Beachten Sie, wie curl den Benutzernamen und das Passwort kodiert und sie im Header Authorization sendet:
{
"args": {},
"data": "{\n \"FirstName\": \"Joe\",\n \"LastName\": \"Soap\"\n}",
"files": {},
"form": {},
"headers": {
"Accept": "application/json",
"Authorization": "Basic YWRtaW46cGFzc3dvcmQxMjM=",
"Content-Length": "50",
"Content-Type": "application/json",
"Host": "httpbin.org",
"User-Agent": "curl/8.1.2",
"X-Amzn-Trace-Id": "Root=1-11111111-111111111111111111111111"
},
"json": {
"FirstName": "Joe",
"LastName": "Soap"
},
"method": "POST",
"origin": "0.0.0.0",
"url": "https://httpbin.org/anything"
}
Fazit
In diesem Artikel haben Sie erfahren, wie Sie POST-Anforderungen mit dem Befehlszeilenprogramm curl senden können. Sie haben gelernt, das Flag -X zu verwenden, um anzugeben, dass Sie eine POST-Anforderung senden möchten. Weiterhin wissen Sie nun, dass Sie die Header Content-Type und Accept mithilfe der Flags -H und --headerfestlegen können, damit der Webserver weiß, in welchem Format sich die Daten befinden. Um Daten im Anforderungstext zu senden, haben Sie das Flag -d zusammen mit den Daten, die Sie senden wollten, verwendet.
Sie haben auch einige Beispiele dafür gesehen, wie Sie verschiedene Datentypen senden können, darunter JSON, XML und FormData. Zudem haben Sie gelernt, wie Sie grundlegende Authentifizierungsdaten in Ihrer Anfrage mit den Flags -u und --user senden können.
In diesem Artikel wurden die in Curl enthaltenen grundlegenden Flags und deren Verwendung erläutert, jedoch bietet curl weitere Funktionen, die Sie vielleicht ausprobieren möchten. Dazu zählen beispielsweise die Verwendung von Variablen, das Senden von Cookies mit Anforderungen und das Senden von Anforderungen über einen Proxy. Viele Programmiersprachen bieten überdies Bibliotheken, in denen erklärt wird, wie Sie mit curl in der jeweiligen Programmiersprache arbeiten können, darunter Python, Node.js und Rust.
Sind Sie auf der Suche nach einer Scraping-Lösung? Sprechen Sie mit einem unserer Datenexperten und finden Sie heraus, welches unserer Produkte Ihren Anforderungen am besten entspricht.
