Cheat Sheet curl: 40+ Esempi di Comandi HTTP e API

Sei a tre salti SSH di distanza dentro una macchina di staging, un’API restituisce la cosa sbagliata e l’unico client HTTP installato è curl. Oppure stai leggendo uno script CI che esegue un health-check di un servizio e vuoi sapere cosa fa davvero -fsS. O ancora, un collega ha incollato una riga di comando su Slack e tu devi adattarla. curl è ovunque, e i flag sono abbastanza criptici da impedire a chiunque di ricordarli tutti.

Questo cheat sheet curl è pensato esattamente per quei momenti. Trovi una tabella di riferimento rapido con la dozzina scarsa di flag che usi ogni giorno, poi esempi di comandi da copiare e incollare per le attività più comuni: richieste GET e POST, invio di header, auth con token Bearer, upload e download di file, test API negli script. Ogni comando usa un URL reale ed eseguibile (httpbin.org o un placeholder api.example.com), così puoi incollarlo e provarlo. Il comportamento si basa sulla documentazione ufficiale di curl e sull’RFC 9110, l’attuale standard di semantica HTTP.

Riferimento rapido — i flag curl che userai davvero

Il novanta percento dell’uso quotidiano di curl si riduce a una dozzina di flag. Tieni questa tabella a portata di mano; il resto della guida approfondisce ogni flag con esempi di comandi curl eseguibili.

Flag	Significato	Esempio
`-X`	Imposta il metodo HTTP	`curl -X DELETE https://api.example.com/items/42`
`-H`	Aggiunge un header di richiesta (ripetibile)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Invia un body di richiesta (implica POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Invia un body JSON + imposta gli header JSON	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Invia un campo/file di form multipart	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Salva l’output in un file con nome scelto	`curl -o page.html https://example.com`
`-O`	Salva usando il nome del file remoto	`curl -O https://example.com/archive.zip`
`-L`	Segue i redirect	`curl -L https://httpbin.org/redirect/2`
`-u`	Basic auth `user:pass`	`curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret`
`-i`	Include gli header della risposta nell’output	`curl -i https://httpbin.org/get`
`-I`	Recupera solo gli header (HEAD)	`curl -I https://example.com`
`-v`	Verbose: mostra richiesta + handshake TLS	`curl -v https://example.com`
`-s`	Silenzioso (nessun indicatore di avanzamento)	`curl -s https://httpbin.org/get`
`-w`	Stampa variabili dopo il trasferimento	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Invia cookie (stringa o file)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Salva i cookie ricevuti in un jar	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	Salta la verifica del certificato TLS	`curl -k https://self-signed.example.com`
`--http2`	Richiede HTTP/2	`curl --http2 https://example.com`
`--http3`	Richiede HTTP/3 (QUIC)	`curl --http3 https://example.com`
`-T`	Carica un file con PUT	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	Codifica in URL un campo del body	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Limita la durata totale del trasferimento (secondi)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Limita l’apertura della connessione (secondi)	`curl --connect-timeout 5 https://example.com`
`--retry`	Riprova N volte un trasferimento fallito	`curl --retry 3 https://example.com`
`--limit-rate`	Limita la larghezza di banda del trasferimento	`curl --limit-rate 2M -O https://example.com/big.iso`

Basi della sintassi curl — anatomia di una richiesta

Un comando curl è il binario, qualche flag e un URL. L’URL può venire prima o dopo i flag; a curl non importa l’ordine. Quello che gli importa è quali flag implicano un metodo o un body, perché questi interagiscono tra loro.

Una semplice richiesta GET

Senza alcun flag di metodo, curl invia un GET. Questo è l’intero comando:

curl https://httpbin.org/get

httpbin ti restituisce la tua richiesta come JSON, il che lo rende ideale per i test. Aggiungi una query string come faresti in un browser:

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

Metti l’URL tra virgolette. Un & nudo dice alla shell di mandare il comando in background e scarta silenziosamente tutto ciò che lo segue. È uno degli errori curl più comuni, trattato nella sezione delle insidie più avanti.

Vedere la risposta: body, header, entrambi

Per impostazione predefinita curl stampa solo il body della risposta. Tre flag cambiano ciò che vedi:

# Body + riga di stato + header della risposta
curl -i https://httpbin.org/get

# Solo header — invia una richiesta HEAD, nessun body
curl -I https://example.com

# Trace completo: riga di richiesta, header di richiesta, handshake TLS, risposta
curl -v https://example.com

Usa -i quando vuoi il body più un’occhiata rapida al Content-Type o a un Set-Cookie. Usa -I per controllare una risorsa senza scaricarla (dimensione del file, last-modified, destinazione del redirect). Ricorri a -v quando qualcosa non va e devi vedere esattamente cosa ha inviato curl.

Seguire i redirect

curl non segue i redirect a meno che tu non glielo chieda. Punta a un URL che restituisce 301 o 302 senza -L e ottieni la risposta di redirect stessa, non la destinazione:

# Si ferma al 302, non stampa nulla di utile
curl https://httpbin.org/redirect/1

# Segue la catena fino al 200 finale
curl -L https://httpbin.org/redirect/1

Se non sei sicuro del perché una richiesta finisca dove finisce, -IL mostra il codice di stato di ogni salto. Per sapere cosa significa ciascuno di quei codici, e perché 301 e 302 non sono intercambiabili, vedi il cheat sheet dei codici di stato HTTP.

Metodi HTTP con curl (GET, POST, PUT, PATCH, DELETE)

curl sceglie il metodo automaticamente in base ai flag: -d o --json implica POST, gli URL semplici implicano GET. Usa -X solo quando ti serve un metodo che non corrisponde al body che stai inviando.

GET con parametri di query

Costruire una query string a mano è soggetto a errori non appena i valori contengono spazi o &. Il flag -G dice a curl di accodare i campi --data-urlencode all’URL come query string correttamente codificata:

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

Questo produce ?q=hello%20world&tag=c%2B%2B: curl gestisce la codifica percentuale così non spedisci un URL rotto.

POST: dati di form vs JSON

Una curl post request si presenta in due forme comuni. Form-encoded (il classico body di un form HTML):

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

-d imposta Content-Type: application/x-www-form-urlencoded e cambia il metodo in POST al posto tuo. Per un’API JSON, invia invece JSON:

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

C’è un modo più pulito per farlo, trattato nella sezione successiva.

PUT e PATCH

PUT sostituisce una risorsa; PATCH ne aggiorna una parte. PUT è idempotente: inviarlo due volte lascia lo stesso stato.

# Sostituisce l'intera risorsa
curl -X PUT -d '{"name":"alice","role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

# Aggiorna un solo campo
curl -X PATCH -d '{"role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

DELETE

DELETE di solito non porta alcun body, quindi -X è tutto ciò che ti serve:

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

Invio di header e body JSON

Gran parte del lavoro reale con le API è fatto di header e JSON. Due flag se ne occupano quasi del tutto: -H e --json.

Header curl personalizzati con `-H`

-H aggiunge un header e può essere ripetuto tutte le volte che ti serve. È così che imposti Accept, Authorization, header X- personalizzati e ID di richiesta:

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

Per rimuovere un header predefinito che curl invierebbe altrimenti, dagli un valore vuoto (-H "User-Agent:"). Per inviare un header senza valore, usa un punto e virgola (-H "X-Empty;").

POST JSON: `-d` vs il moderno flag `--json`

Da curl 7.82, --json è il modo idiomatico per inviare una curl post request JSON. Fa tre cose contemporaneamente: imposta Content-Type: application/json, imposta Accept: application/json e invia il body alla lettera.

# Modo verboso, vecchia maniera — tre pezzi da tenere sincronizzati
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name":"alice"}' \
  https://httpbin.org/post

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

--json è ripetibile e concatena i valori, e --json @file.json legge il body da un file. Preferiscilo per qualsiasi API JSON.

Content-Type e Accept

Da questi due header nascono gli errori 415 e 406. Content-Type descrive il body che invii; Accept dice cosa vuoi ricevere. Invia JSON a un endpoint che accetta solo dati di form e ottieni 415 Unsupported Media Type. Chiedi XML a un’API che parla solo JSON e potresti ottenere 406 Not Acceptable. (Quei codici sono spiegati nella guida ai codici di stato HTTP.)

Quando la risposta torna come un muro di JSON minificato, formattalo con il formattatore JSON, oppure mandalo direttamente in pipe a jq per estrarre un campo:

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

Per l’insieme completo dei filtri jq (selezione, mapping e rimodellamento delle risposte API) vedi il cheat sheet di jq per JSON da riga di comando.

Autenticazione con curl

Quattro stili di auth coprono quasi ogni API: basic auth, token Bearer, chiavi API e cookie.

Basic auth (`-u user:pass`)

-u invia un header HTTP Authorization: Basic con le tue credenziali codificate in Base64:

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

Ometti la password (-u alice) e curl te la chiede, tenendola fuori dalla cronologia della shell.

Token Bearer e OAuth

La maggior parte delle API moderne usa un curl bearer token: un access token OAuth 2.0 o un token API nell’header Authorization. curl ha una scorciatoia, --oauth2-bearer, equivalente a scrivere l’header a mano:

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

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

Se il backend rifiuta il token, decodificalo con il decodificatore JWT per controllare le claim exp (scadenza), aud (audience) e iss (issuer) prima di dare la colpa a curl: un token scaduto o con audience sbagliata è la causa abituale.

Chiavi API (header vs parametro di query)

Alcune API vogliono la chiave in un header, altre in un parametro di query. Gli header sono più sicuri perché gli URL finiscono nei log e nella cronologia del browser:

# Preferito: chiave in un header
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Meno sicuro: chiave nell'URL (finisce negli access log)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookie (`-b` per inviare, `-c` per salvare)

-c scrive un cookie jar; -b ne legge uno. È così che mantieni una sessione tra più richieste:

# Accedi e salva il cookie di sessione
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Riutilizzalo nella chiamata successiva
curl -b jar.txt https://httpbin.org/cookies

Nota di sicurezza: token e credenziali appartengono solo a connessioni HTTPS. TLS cifra gli header, il semplice HTTP no. Evita di mettere i segreti direttamente sulla riga di comando, dove finiscono nella cronologia della shell e nell’output di ps. Leggi un header da un file con -H @authfile oppure prendi il valore da una variabile d’ambiente (-H "Authorization: Bearer $TOKEN").

Download e upload di file

curl è stato chiamato “client URL” perché spostare file è il suo lavoro originale. Download e upload hanno ciascuno un paio di flag che vale la pena conoscere.

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

-O (O maiuscola) salva il file con il suo nome remoto. -o (minuscola) ti lascia scegliere il nome. -C - riprende un download parziale da dove si era interrotto:

# Salva con il nome del file remoto: archive.zip
curl -O https://example.com/downloads/archive.zip

# Salva con un nome scelto da te
curl -o backup.zip https://example.com/downloads/archive.zip

# Riprende un download interrotto
curl -C - -O https://example.com/downloads/archive.zip

# Segue i redirect fino al file vero (comune con le CDN)
curl -OL https://example.com/latest/archive.zip

Per scaricare con curl un contenuto che sta dietro un redirect, aggiungi -L: le pagine di release e i link delle CDN reindirizzano quasi sempre.

Upload: `-T` vs `-F`

-T carica un file con PUT, inviando i byte grezzi come body (comune per l’object storage e gli endpoint REST per i file). -F invia una richiesta multipart/form-data, lo stesso formato che usa un browser per gli input di tipo file:

# PUT di byte grezzi
curl -T report.pdf https://api.example.com/files/report.pdf

# Upload multipart/form-data (nota il prefisso @)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

Il prefisso @ dice a curl di leggere il contenuto del file. Senza di esso, -F "file=report.pdf" invia la stringa letterale report.pdf, non il file.

`--data-urlencode` e codifica percentuale

Quando un valore contiene spazi, &, = o caratteri non ASCII, -d lo invia così com’è e rompe la tua richiesta. --data-urlencode lo codifica correttamente:

# Sbagliato: l'& divide il body, lo spazio non è valido
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Giusto: ogni campo è codificato in percentuale
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Se hai bisogno di capire cosa significano quelle sequenze %20 e %26, o di fare debug di un valore codificato due volte, incollalo nel codificatore/decodificatore URL oppure leggi la spiegazione a livello di byte nella guida alla codifica e decodifica URL.

Test API e ispezione delle risposte

curl dà il meglio negli script e nella CI: -w espone tutto sul trasferimento e i codici di uscita rendono rilevabili gli errori.

Solo il codice di stato

Per ottenere solo lo stato HTTP, scarta il body con -o /dev/null e stampa il codice con -w:

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

Questo è il cuore di qualsiasi health-check per curl api testing. Per interpretare il numero che ti torna indietro, il cheat sheet dei codici di stato HTTP copre ogni intervallo.

Analisi dei tempi

-w espone variabili di tempo, così puoi vedere dove va il tempo: DNS, connessione TCP, TLS o il server stesso:

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

Un time_appconnect alto punta al TLS, un time_starttransfer alto punta a un backend lento.

Silenzioso ma con gli errori visibili

-s nasconde l’indicatore di avanzamento, ma nasconde anche i messaggi di errore, ed è una trappola negli script. Abbinalo a -S così curl resta in silenzio in caso di successo e segnala comunque gli errori:

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

curl in CI / script: fallire sugli errori HTTP

Per impostazione predefinita curl esce con 0 anche su un 404 o 500, perché il trasferimento in sé è riuscito. In un health-check è l’opposto di ciò che vuoi. -f (fail) fa uscire curl con codice diverso da zero sugli errori HTTP, così la tua pipeline li intercetta:

# Fa fallire la build se l'endpoint restituisce 4xx/5xx
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) è la combinazione canonica per gli health-check. Per diagnostica più ricca, --fail-with-body (curl 7.76+) stampa comunque la risposta di errore prima di uscire.

Timeout e tentativi

Un health check che resta bloccato per sempre è peggio di uno che fallisce subito. Limita ogni richiesta in script con --max-time (tetto sull’intero trasferimento) e --connect-timeout (tetto solo sull’apertura della connessione):

# Si arrende dopo 5 s di connessione, 10 s in totale
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

Su una rete instabile, --retry ripete un trasferimento fallito con backoff esponenziale. Per impostazione predefinita ripete solo i fallimenti transitori (timeout, 5xx); aggiungi --retry-all-errors per ripetere anche le connessioni rifiutate:

# Fino a 3 tentativi, con una pausa crescente tra l'uno e l'altro
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Quando uno script scarica un file di grandi dimensioni e non vuoi saturare il collegamento, --limit-rate limita la banda: --limit-rate 2M la mantiene a 2 MB/s.

HTTP/1.1, HTTP/2 e HTTP/3 con curl

curl negozia la versione HTTP tramite ALPN su TLS. Puoi forzare una versione quando devi testare un percorso di protocollo specifico.

`--http2` e `--http3`

# Richiede HTTP/2 (ripiega su 1.1 se non disponibile)
curl --http2 https://example.com

# Richiede HTTP/3 su QUIC
curl --http3 https://example.com

HTTP/3 gira su QUIC e richiede TLS 1.3. Funziona solo se la tua curl è stata compilata con un backend capace di HTTP/3 e il server lo annuncia tramite un header Alt-Svc. Esegui curl --version per confermare che HTTP3 compaia nella riga delle features; se non c’è, --http3 darà errore.

Info verbose su TLS / ALPN

-v mostra il protocollo negoziato e l’handshake TLS, che è come confermi che una versione abbia davvero avuto effetto:

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

Cerca ALPN: server accepted h2 (HTTP/2) o h3 (HTTP/3) nell’output dell’handshake.

8 insidie comuni di curl (e come risolverle)

Queste otto fregano prima o poi tutti.

Virgolette singole vs doppie. Le virgolette doppie lasciano che la shell espanda le $VARS; le singole passano tutto alla lettera. Usa le virgolette singole per i body JSON così $ e ! non vengono interpretati: curl --json '{"price":"$5"}'. Usa le doppie quando vuoi l’espansione: -H "Authorization: Bearer $TOKEN".
-d non codifica in URL. Uno spazio o un & in un valore -d corrompe il body. Passa a --data-urlencode per qualsiasi valore non già codificato.
-X POST ridondante con -d. -d implica già POST. Scrivere -X POST -d ... è innocuo ma ridondante; peggio, -X GET -d ... invia un body con un GET, cosa che sorprende alcuni server. Lascia che sia il flag del body a impostare il metodo.
Dimenticare la @ quando si legge da un file. -d @body.json legge il file; -d body.json invia il testo letterale body.json. Stessa trappola con -F "file=@upload.png" rispetto a -F "file=upload.png".
Ricorrere a -k sugli errori di certificato. -k disabilita la verifica TLS e nasconde problemi reali (certificati scaduti, hostname sbagliato, intermediario mancante). Risolvi la causa alla radice: installa la CA con --cacert ca.pem, oppure aggiorna il trust store del sistema. Riserva -k a un server di sviluppo self-signed che controlli completamente.
-s che ingoia gli errori. La modalità silenziosa nasconde gli errori negli script. Usa sempre -sS così gli errori vengono comunque a galla.
[ ] { } negli URL che vengono interpretati come glob. curl tratta [1-5] e {a,b} come intervalli/liste di URL. Un URL con parentesi letterali (comune nei parametri di query di tipo array come arr[]=1) viene rovinato. Disabilita il globbing con -g: curl -g "https://api.example.com/items?id[]=1&id[]=2".
Maiuscole/minuscole e duplicati negli header. I nomi degli header HTTP non distinguono maiuscole e minuscole, ma inviare lo stesso header due volte di solito li manda entrambi: alcuni server prendono il primo, altri l’ultimo, altri lo rifiutano. Se sovrascrivi un valore predefinito come User-Agent, impostalo una sola volta con -H invece di affidarti all’ordine.

curl vs wget vs HTTPie — quale usare

Tutti e tre recuperano dati su HTTP, ma sono ottimizzati per lavori diversi. Ecco la scelta curl vs wget (più HTTPie) a colpo d’occhio:

Attività	curl	wget	HTTPie
Chiamata API rapida / debugging	Eccellente	Limitato	Eccellente
Body JSON	Buono (`--json`)	Scomodo	Eccellente (nativo)
Download/mirroring ricorsivo di un sito	No	Eccellente (`-r`)	No
Riprendere + riprovare download grandi	Buono (`-C -`)	Eccellente (integrato)	No
Scripting / CI (codici di uscita, `-w`)	Eccellente	Buono	Buono
Output colorato e leggibile di default	No	No	Eccellente
Preinstallato quasi ovunque	Sì	Spesso	Raramente

In breve: usa curl per il debugging delle API e gli script (è ovunque e -w è impareggiabile), HTTPie quando vuoi un’ergonomia leggibile per il JSON sulla tua macchina, e wget per fare il mirroring di siti o scaricare file in blocco con i tentativi automatici.

Domande frequenti

A cosa serve curl?

curl è uno strumento da riga di comando per trasferire dati da e verso un server su HTTP, HTTPS, FTP e molti altri protocolli. Gli sviluppatori lo usano per chiamare e fare debug delle API, scaricare e caricare file ed eseguire health-check negli script e nelle pipeline CI.

Come invio una richiesta POST con curl?

Usa -d per i dati di form o --json per il JSON: curl --json '{"name":"alice"}' https://httpbin.org/post. Entrambi i flag impostano automaticamente il metodo su POST, quindi non ti serve -X POST.

Come aggiungo un header in curl?

Usa -H "Name: value", e ripetilo per più header: curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Non c’è limite a quante volte puoi passare -H.

Come invio un token Bearer con curl?

Passa un header Authorization: curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, oppure usa la scorciatoia --oauth2-bearer YOUR_TOKEN. Invia i token solo su HTTPS, e decodificali con il decodificatore JWT durante il debug.

Come scarico un file con curl?

Usa -O per mantenere il nome del file remoto o -o name per sceglierne uno tuo: curl -O https://example.com/archive.zip. Aggiungi -L per seguire i redirect e -C - per riprendere un download interrotto.

Come vedo solo il codice di stato HTTP con curl?

Scarta il body e stampa il codice: curl -s -o /dev/null -w "%{http_code}" https://example.com. Questo è il pattern standard per gli health-check negli script.

Qual è la differenza tra curl e wget?

curl trasferisce una singola risorsa e scrive su stdout per impostazione predefinita, il che lo rende ideale per le chiamate API e lo scripting. wget è specializzato nel download, incluso il mirroring ricorsivo e i tentativi automatici. Per i test API usa curl; per i download di file in blocco usa wget.

curl è disponibile su Windows?

Sì. curl è incluso in Windows 10 (build 1803+) e Windows 11, disponibile come curl nel Prompt dei comandi e in PowerShell. Nota che PowerShell ha storicamente reso curl un alias di Invoke-WebRequest, quindi chiama curl.exe esplicitamente se i flag si comportano in modo inatteso.

Per concludere

curl ripaga con poco sforzo di memorizzazione: la tabella dei flag in cima copre la stragrande maggioranza di ciò che digiterai, e il resto è sapere quali flag implicano un metodo, quali hanno bisogno delle virgolette e quali ti mentono negli script (sì, dico a te, -s nudo). Tieni questo cheat sheet curl aperto accanto al terminale. Se preferisci assemblare i comandi in modo interattivo, prova il nostro generatore di comandi cURL per crearli visivamente.

I passi successivi naturali in un flusso di lavoro con le API sono a un clic di distanza. Invia la richiesta con curl, leggi cosa è tornato indietro con il cheat sheet dei codici di stato HTTP, poi formatta il JSON nel formattatore JSON oppure affettalo con il cheat sheet di jq per JSON da riga di comando. Per l’elenco completo delle opzioni, il manuale di curl è esaustivo, e il riferimento HTTP di MDN spiega la semantica dietro ogni metodo e header.