curl spiekbriefje: 40+ commandovoorbeelden voor HTTP & API’s

Je zit drie SSH-hops diep in een staging-machine, een API geeft het verkeerde terug, en de enige geïnstalleerde HTTP-client is curl. Of je leest een CI-script dat de gezondheid van een service controleert en je wilt weten wat -fsS nou eigenlijk doet. Of een collega plakte een one-liner in Slack en je moet die aanpassen. curl zit overal, en de flags zijn zo beknopt dat niemand ze allemaal onthoudt.

Dit curl-spiekbriefje is precies voor zulke momenten gebouwd. Je krijgt een snelle referentietabel met de tien-en-nog-wat flags die je dagelijks gebruikt, daarna kant-en-klare commandovoorbeelden voor elke veelvoorkomende taak: GET- en POST-requests, headers versturen, Bearer-token-auth, bestanden uploaden en downloaden, en API-tests in scripts. Elk commando gebruikt een echte, uitvoerbare URL (httpbin.org of een api.example.com-placeholder), zodat je kunt plakken en uitproberen. Het gedrag is gebaseerd op de officiële curl-documentatie en RFC 9110, de huidige standaard voor HTTP-semantiek.

Snelle referentie — de curl-flags die je echt gebruikt

Negentig procent van het dagelijkse curl-gebruik draait om een twaalftal flags. Maak een bladwijzer van deze tabel; de rest van de gids breidt elke flag uit met uitvoerbare curl-commandovoorbeelden.

Flag	Betekenis	Voorbeeld
`-X`	HTTP-methode instellen	`curl -X DELETE https://api.example.com/items/42`
`-H`	Een request-header toevoegen (herhaalbaar)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Een request-body versturen (impliceert POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Een JSON-body versturen + JSON-headers instellen	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Een multipart-formulierveld / bestand versturen	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Uitvoer opslaan in een opgegeven bestand	`curl -o page.html https://example.com`
`-O`	Opslaan onder de externe bestandsnaam	`curl -O https://example.com/archive.zip`
`-L`	Redirects volgen	`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-headers in de uitvoer opnemen	`curl -i https://httpbin.org/get`
`-I`	Alleen headers ophalen (HEAD)	`curl -I https://example.com`
`-v`	Verbose: toon request + TLS-handshake	`curl -v https://example.com`
`-s`	Stil (geen voortgangsmeter)	`curl -s https://httpbin.org/get`
`-w`	Variabelen wegschrijven na de overdracht	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Cookies versturen (string of bestand)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Ontvangen cookies opslaan in een jar	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	TLS-certificaatverificatie overslaan	`curl -k https://self-signed.example.com`
`--http2`	HTTP/2 aanvragen	`curl --http2 https://example.com`
`--http3`	HTTP/3 aanvragen (QUIC)	`curl --http3 https://example.com`
`-T`	Een bestand uploaden met PUT	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	Een body-veld URL-encoderen	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Begrenst de totale duur van de overdracht (seconden)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Begrenst het opzetten van de verbinding (seconden)	`curl --connect-timeout 5 https://example.com`
`--retry`	Probeert een mislukte overdracht N keer opnieuw	`curl --retry 3 https://example.com`
`--limit-rate`	Begrenst de bandbreedte van de overdracht	`curl --limit-rate 2M -O https://example.com/big.iso`

Basis van de curl-syntaxis — anatomie van een request

Een curl-commando is de binary, een paar flags en een URL. De URL mag vóór of na de flags staan; volgorde maakt curl niet uit. Wat curl wél uitmaakt, is welke flags een methode of een body impliceren, want die werken op elkaar in.

Een eenvoudig GET-request

Zonder methode-flag verstuurt curl een GET. Dit is het hele commando:

curl https://httpbin.org/get

httpbin echoot je request terug als JSON, wat het ideaal maakt om te testen. Voeg een querystring toe op dezelfde manier als in een browser:

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

Zet de URL tussen aanhalingstekens. Een kale & vertelt je shell het commando op de achtergrond te draaien en laat stilletjes alles erna vallen. Dat is een van de meest gemaakte curl-fouten, behandeld in de valkuilen-sectie hieronder.

De response zien: body, headers, beide

Standaard print curl alleen de response-body. Drie flags veranderen wat je ziet:

# Body + statusregel + response-headers
curl -i https://httpbin.org/get

# Alleen headers — verstuurt een HEAD-request, geen body
curl -I https://example.com

# Volledige trace: requestregel, request-headers, TLS-handshake, response
curl -v https://example.com

Gebruik -i wanneer je de body wilt plus een snelle blik op Content-Type of een Set-Cookie. Gebruik -I om een resource te controleren zonder die te downloaden (bestandsgrootte, last-modified, redirect-doel). Grijp naar -v wanneer er iets misgaat en je precies wilt zien wat curl verstuurde.

Redirects volgen

curl volgt redirects niet tenzij je erom vraagt. Benader een URL die 301 of 302 teruggeeft zonder -L en je krijgt de redirect-response zelf, niet de bestemming:

# Stopt bij de 302, print niets nuttigs
curl https://httpbin.org/redirect/1

# Volgt de keten tot de uiteindelijke 200
curl -L https://httpbin.org/redirect/1

Als je niet zeker weet waarom een request ergens belandt, toont -IL de statuscode van elke hop. Voor wat elk van die codes betekent, en waarom 301 en 302 niet uitwisselbaar zijn, zie het HTTP-statuscodes spiekbriefje.

HTTP-methoden met curl (GET, POST, PUT, PATCH, DELETE)

curl kiest de methode automatisch op basis van je flags: -d of --json impliceert POST, kale URL’s impliceren GET. Gebruik -X alleen wanneer je een methode nodig hebt die niet past bij de body die je verstuurt.

GET met queryparameters

Een querystring met de hand opbouwen is foutgevoelig zodra waarden spaties of & bevatten. De -G-flag vertelt curl om --data-urlencode-velden als correct geëncodeerde querystring aan de URL toe te voegen:

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

Dit levert ?q=hello%20world&tag=c%2B%2B op; curl regelt de percent-encoding zodat je geen kapotte URL verstuurt.

POST: formuliergegevens vs JSON

Een curl post request komt in twee veelvoorkomende vormen. Formulier-geëncodeerd (de klassieke HTML-formulierbody):

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

-d stelt Content-Type: application/x-www-form-urlencoded in en schakelt de methode voor je om naar POST. Voor een JSON-API verstuur je in plaats daarvan JSON:

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

Er is een nettere manier om dat te doen, behandeld in de volgende sectie.

PUT en PATCH

PUT vervangt een resource; PATCH werkt een deel ervan bij. PUT is idempotent: twee keer versturen levert dezelfde staat op.

# De hele resource vervangen
curl -X PUT -d '{"name":"alice","role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

# Eén veld bijwerken
curl -X PATCH -d '{"role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

DELETE

DELETE draagt meestal geen body, dus -X is alles wat je nodig hebt:

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

Headers en JSON-bodies versturen

Het meeste echte API-werk bestaat uit headers en JSON. Twee flags doen het zware werk: -H en --json.

Aangepaste curl-headers met `-H`

-H voegt één header toe en kan zo vaak herhaald worden als je nodig hebt. Zo stel je Accept, Authorization, aangepaste X--headers en request-ID’s in:

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

Om een standaardheader die curl anders zou versturen te verwijderen, geef je die een lege waarde (-H "User-Agent:"). Om een header zonder waarde te versturen, gebruik je een puntkomma (-H "X-Empty;").

JSON POSTen: `-d` vs de moderne `--json`-flag

Sinds curl 7.82 is --json de idiomatische manier om een JSON-curl post request te versturen. Het doet drie dingen tegelijk: stelt Content-Type: application/json in, stelt Accept: application/json in en verstuurt de body letterlijk.

# Verbose, oude manier — drie stukken die synchroon moeten blijven
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name":"alice"}' \
  https://httpbin.org/post

# Modern equivalent
curl --json '{"name":"alice"}' https://httpbin.org/post

--json is herhaalbaar en plakt achter elkaar, en --json @file.json leest de body uit een bestand. Geef er de voorkeur aan voor elke JSON-API.

Content-Type en Accept

Deze twee headers zijn waar 415- en 406-fouten vandaan komen. Content-Type beschrijft de body die je verstuurt; Accept zegt wat je terug wilt. Verstuur JSON naar een endpoint dat alleen formuliergegevens accepteert en je krijgt 415 Unsupported Media Type. Vraag XML van een JSON-only API en je krijgt mogelijk 406 Not Acceptable. (Die codes worden uitgelegd in de HTTP-statuscodes spiekbriefje.)

Wanneer de response terugkomt als een muur van geminificeerde JSON, print die dan netjes uit met de JSON Formatter, of pipe die direct naar jq om één veld te extraheren:

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

Voor de volledige set jq-filters (API-responses selecteren, mappen en hervormen) zie het jq spiekbriefje.

Authenticatie met curl

Vier auth-stijlen dekken vrijwel elke API: basic auth, Bearer-tokens, API-sleutels en cookies.

Basic auth (`-u user:pass`)

-u verstuurt een HTTP-Authorization: Basic-header met je credentials Base64-geëncodeerd:

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

Laat het wachtwoord weg (-u alice) en curl vraagt erom, zodat het buiten je shell-geschiedenis blijft.

Bearer-tokens & OAuth

De meeste moderne API’s gebruiken een curl bearer token: een OAuth 2.0-access-token of API-token in de Authorization-header. curl heeft een afkorting, --oauth2-bearer, die gelijkstaat aan het met de hand schrijven van de header:

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

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

Als de backend het token afwijst, decodeer het dan met de JWT decoder om de claims exp (expiration), aud (audience) en iss (issuer) te controleren voordat je curl de schuld geeft. Een verlopen token of een token met de verkeerde audience is de gebruikelijke oorzaak.

API-sleutels (header vs queryparameter)

Sommige API’s willen de sleutel in een header, andere in een queryparameter. Headers zijn veiliger omdat URL’s in logs en browsergeschiedenis terechtkomen:

# Voorkeur: sleutel in een header
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Minder veilig: sleutel in de URL (belandt in access logs)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookies (`-b` om te versturen, `-c` om op te slaan)

-c schrijft een cookie-jar; -b leest er een terug. Zo draag je een sessie mee over requests heen:

# Log in en sla de sessiecookie op
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Hergebruik die bij de volgende call
curl -b jar.txt https://httpbin.org/cookies

Beveiligingstip: tokens en credentials horen alleen op HTTPS-verbindingen thuis. TLS versleutelt de headers, gewoon HTTP niet. Vermijd het om geheimen direct op de commandoregel te zetten, waar ze in je shell-geschiedenis en in ps-uitvoer belanden. Lees een header uit een bestand met -H @authfile of haal de waarde uit een omgevingsvariabele (-H "Authorization: Bearer $TOKEN").

Bestanden downloaden en uploaden

curl kreeg de naam “client URL” omdat bestanden verplaatsen zijn oorspronkelijke taak is. Downloads en uploads hebben elk een paar flags die de moeite van het kennen waard zijn.

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

-O (hoofdletter O) slaat het bestand op onder de externe naam. -o (kleine letter) laat je de naam kiezen. -C - hervat een gedeeltelijke download op het punt waar die stopte:

# Opslaan onder de externe bestandsnaam: archive.zip
curl -O https://example.com/downloads/archive.zip

# Opslaan onder een naam die je zelf kiest
curl -o backup.zip https://example.com/downloads/archive.zip

# Een onderbroken download hervatten
curl -C - -O https://example.com/downloads/archive.zip

# Redirects volgen naar het echte bestand (gebruikelijk bij CDN's)
curl -OL https://example.com/latest/archive.zip

Om inhoud te curl download file die achter een redirect zit, voeg je -L toe; release-pagina’s en CDN-links redirecten vrijwel altijd.

Upload: `-T` vs `-F`

-T uploadt een bestand met PUT en verstuurt de ruwe bytes als de body (gebruikelijk voor objectopslag en REST-bestandsendpoints). -F verstuurt een multipart/form-data-request, hetzelfde formaat dat een browser gebruikt voor bestandsinvoeren:

# Ruwe bytes met PUT
curl -T report.pdf https://api.example.com/files/report.pdf

# multipart/form-data-upload (let op de @-prefix)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

De @-prefix vertelt curl om de inhoud van het bestand te lezen. Zonder die prefix verstuurt -F "file=report.pdf" de letterlijke string report.pdf, niet het bestand.

`--data-urlencode` en percent-encoding

Wanneer een waarde spaties, &, = of niet-ASCII-tekens bevat, verstuurt -d die ongewijzigd en breekt je request. --data-urlencode encodeert die correct:

# Fout: de & splitst de body, de spatie is ongeldig
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Goed: elk veld is percent-geëncodeerd
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Als je wilt begrijpen wat die %20- en %26-sequenties betekenen (of een waarde wilt debuggen die dubbel geëncodeerd is), plak die dan in de URL Decoder & Encoder of lees de uitleg op byte-niveau in de gids over URL-encoderen en -decoderen.

API-tests & responses inspecteren

curl excelleert in scripts en CI omdat -w alles over de overdracht blootlegt en exitcodes mislukkingen detecteerbaar maken.

Alleen de statuscode

Om alleen de HTTP-status te pakken, gooi je de body weg met -o /dev/null en print je de code met -w:

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

Dit is de kern van elke curl api testing-gezondheidscontrole. Om het getal dat je terugkrijgt te interpreteren, behandelt het HTTP-statuscodes spiekbriefje elk bereik.

Timing-overzicht

-w legt timing-variabelen bloot, zodat je kunt zien waar de tijd naartoe gaat (DNS, TCP-connect, TLS of de server zelf):

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

Een hoge time_appconnect wijst op TLS, een hoge time_starttransfer wijst op een trage backend.

Stil, maar toon fouten

-s verbergt de voortgangsmeter, maar het verbergt ook foutmeldingen, een valkuil in scripts. Combineer het met -S zodat curl stil blijft bij succes en mislukkingen toch meldt:

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

curl in CI / scripts: falen bij HTTP-fouten

Standaard sluit curl af met 0 zelfs bij een 404 of 500, omdat de overdracht zelf slaagde. In een gezondheidscontrole is dat het tegenovergestelde van wat je wilt. -f (fail) zorgt dat curl afsluit met een waarde die niet nul is bij HTTP-fouten, zodat je pijplijn ze opvangt:

# Laat de build falen als het endpoint 4xx/5xx teruggeeft
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) is de canonieke combinatie voor gezondheidscontroles. Voor rijkere diagnostiek print --fail-with-body (curl 7.76+) de foutresponse nog steeds voordat het afsluit.

Time-outs en nieuwe pogingen

Een health check die eindeloos blijft hangen is erger dan een die snel faalt. Begrens elk script-verzoek met --max-time (plafond voor de hele overdracht) en --connect-timeout (plafond voor alleen het opzetten van de verbinding):

# Geeft op na 5 s verbinden, 10 s totaal
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

Op een instabiel netwerk probeert --retry een mislukte overdracht opnieuw met exponentiële backoff. Standaard worden alleen tijdelijke fouten opnieuw geprobeerd (time-outs, 5xx); voeg --retry-all-errors toe om ook geweigerde verbindingen opnieuw te proberen:

# Tot 3 pogingen, met een groeiende pauze ertussen
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Wanneer een script een groot bestand ophaalt en je de verbinding niet wilt verzadigen, begrenst --limit-rate de bandbreedte — --limit-rate 2M houdt het op 2 MB/s.

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

curl onderhandelt de HTTP-versie over TLS via ALPN. Je kunt een versie forceren wanneer je een specifiek protocolpad wilt testen.

`--http2` en `--http3`

# HTTP/2 aanvragen (valt terug op 1.1 indien niet beschikbaar)
curl --http2 https://example.com

# HTTP/3 over QUIC aanvragen
curl --http3 https://example.com

HTTP/3 draait over QUIC en vereist TLS 1.3. Het werkt alleen als je curl gebouwd is met een HTTP/3-capabele backend en de server het adverteert via een Alt-Svc-header. Voer curl --version uit om te bevestigen dat HTTP3 in de features-regel verschijnt; zo niet, dan geeft --http3 een fout.

Verbose TLS- / ALPN-info

-v toont het onderhandelde protocol en de TLS-handshake, en zo bevestig je dat een versie daadwerkelijk van kracht werd:

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

Zoek naar ALPN: server accepted h2 (HTTP/2) of h3 (HTTP/3) in de handshake-uitvoer.

8 veelvoorkomende curl-valkuilen (en hoe je ze oplost)

Deze acht laten iedereen vroeg of laat struikelen.

Enkele vs dubbele aanhalingstekens. Dubbele aanhalingstekens laten de shell $VARS expanderen; enkele aanhalingstekens geven alles letterlijk door. Gebruik enkele aanhalingstekens voor JSON-bodies zodat $ en ! niet geïnterpreteerd worden: curl --json '{"price":"$5"}'. Gebruik dubbele aanhalingstekens wanneer je expansie wilt: -H "Authorization: Bearer $TOKEN".
-d URL-encodeert niet. Een spatie of & in een -d-waarde corrumpeert de body. Schakel over naar --data-urlencode voor elke waarde die niet al geëncodeerd is.
Overbodige -X POST bij -d. -d impliceert al POST. -X POST -d ... schrijven is onschadelijk maar overbodig; erger nog, -X GET -d ... verstuurt een body bij een GET, wat sommige servers verrast. Laat de body-flag de methode bepalen.
De @ vergeten bij het lezen uit een bestand. -d @body.json leest het bestand; -d body.json verstuurt de letterlijke tekst body.json. Dezelfde valkuil bij -F "file=@upload.png" versus -F "file=upload.png".
Naar -k grijpen bij certificaatfouten. -k schakelt TLS-verificatie uit en verbergt echte problemen (verlopen certificaten, verkeerde hostnaam, ontbrekende intermediate). Los de onderliggende oorzaak op: installeer de CA met --cacert ca.pem, of werk je systeem-trust-store bij. Bewaar -k voor een self-signed dev-server die je volledig zelf beheert.
-s dat fouten opslokt. Stille modus verbergt mislukkingen in scripts. Gebruik altijd -sS zodat fouten toch zichtbaar worden.
[ ] { } in URL’s die geglobt worden. curl behandelt [1-5] en {a,b} als URL-bereiken/-lijsten. Een URL met letterlijke haakjes (gebruikelijk in array-queryparameters zoals arr[]=1) raakt verminkt. Schakel globbing uit met -g: curl -g "https://api.example.com/items?id[]=1&id[]=2".
Hoofdlettergebruik en duplicaten van headers. HTTP-headernamen zijn hoofdletterongevoelig, maar dezelfde header twee keer versturen stuurt meestal beide: sommige servers nemen de eerste, sommige de laatste, sommige wijzen het af. Als je een standaardwaarde zoals User-Agent overschrijft, stel die dan één keer in met -H in plaats van op de volgorde te vertrouwen.

curl vs wget vs HTTPie — welke gebruik je

Alle drie halen ze data op over HTTP, maar ze zijn voor verschillende taken geoptimaliseerd. Hier is de curl vs wget-keuze (plus HTTPie) in één oogopslag:

Taak	curl	wget	HTTPie
Snelle API-call / debuggen	Uitstekend	Beperkt	Uitstekend
JSON-bodies	Goed (`--json`)	Omslachtig	Uitstekend (ingebouwd)
Recursieve site-download / mirroring	Nee	Uitstekend (`-r`)	Nee
Grote downloads hervatten + opnieuw proberen	Goed (`-C -`)	Uitstekend (ingebouwd)	Nee
Scripting / CI (exitcodes, `-w`)	Uitstekend	Goed	Goed
Standaard mooie, gekleurde uitvoer	Nee	Nee	Uitstekend
Bijna overal voorgeïnstalleerd	Ja	Vaak	Zelden

Kort samengevat: gebruik curl voor API-debugging en scripts (het zit overal en -w geeft je timing en statuscodes die de andere twee niet bieden), HTTPie wanneer je leesbare JSON-ergonomie op je eigen machine wilt, en wget voor het mirroren van sites of het batchgewijs downloaden van bestanden met automatische retries.

Veelgestelde vragen

Waar wordt curl voor gebruikt?

curl is een commandoregeltool voor het overdragen van data van en naar een server over HTTP, HTTPS, FTP en veel andere protocollen. Ontwikkelaars gebruiken het om API’s aan te roepen en te debuggen, bestanden te downloaden en uploaden, en gezondheidscontroles uit te voeren in scripts en CI-pijplijnen.

Hoe verstuur ik een POST-request met curl?

Gebruik -d voor formuliergegevens of --json voor JSON: curl --json '{"name":"alice"}' https://httpbin.org/post. Beide flags stellen de methode automatisch in op POST, dus je hebt geen -X POST nodig.

Hoe voeg ik een header toe in curl?

Gebruik -H "Name: value" en herhaal het voor meerdere headers: curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Er is geen limiet aan hoe vaak je -H kunt meegeven.

Hoe verstuur ik een Bearer-token met curl?

Geef een Authorization-header mee: curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, of gebruik de afkorting --oauth2-bearer YOUR_TOKEN. Verstuur tokens alleen over HTTPS, en decodeer ze met de JWT decoder tijdens het debuggen.

Hoe download ik een bestand met curl?

Gebruik -O om de externe bestandsnaam te behouden of -o name om je eigen naam te kiezen: curl -O https://example.com/archive.zip. Voeg -L toe om redirects te volgen en -C - om een onderbroken download te hervatten.

Hoe zie ik alleen de HTTP-statuscode met curl?

Gooi de body weg en print de code: curl -s -o /dev/null -w "%{http_code}" https://example.com. Dit is het standaardpatroon voor gezondheidscontroles in scripts.

Wat is het verschil tussen curl en wget?

curl draagt één resource over en schrijft standaard naar stdout, wat het ideaal maakt voor API-calls en scripting. wget is gespecialiseerd in downloaden, inclusief recursieve mirroring en automatische retries. Voor API-tests gebruik je curl; voor bulk-bestandsdownloads gebruik je wget.

Is curl beschikbaar op Windows?

Ja. curl wordt meegeleverd met Windows 10 (build 1803+) en Windows 11, beschikbaar als curl in Command Prompt en PowerShell. Let op dat PowerShell curl van oudsher als alias voor Invoke-WebRequest had, dus roep curl.exe expliciet aan als flags zich onverwacht gedragen.

Tot slot

curl beloont een beetje geheugenwerk: de flag-tabel bovenaan dekt het overgrote deel van wat je zult typen, en de rest is weten welke flags een methode impliceren, welke aanhalingstekens nodig hebben en welke je in scripts voorliegen (jij dus, kale -s). Houd dit curl-spiekbriefje open naast je terminal. Liever commando’s interactief samenstellen? Probeer onze cURL-opdrachtbouwer om ze visueel te genereren.

De logische volgende stappen in een API-workflow liggen één klik verderop. Verstuur de request met curl, lees wat er terugkwam met het HTTP-statuscodes spiekbriefje, print daarna de JSON netjes uit in de JSON Formatter of versnijd die met het jq spiekbriefje. Voor de volledige optielijst is de curl-handleiding uitputtend, en MDN’s HTTP-referentie legt de semantiek achter elke methode en header uit.