Folha de Consulta curl: 40+ Exemplos de Comandos HTTP e API

Você está três saltos de SSH adentro de uma máquina de staging, uma API está devolvendo a coisa errada e o único cliente HTTP instalado é o curl. Ou está lendo um script de CI que faz health-check de um serviço e quer saber o que o -fsS realmente faz. Ou um colega colou um one-liner no Slack e você precisa adaptá-lo. O curl está em toda parte, e as flags são curtas o bastante para ninguém lembrar de todas elas.

Esta folha de consulta curl foi feita exatamente para esses momentos. Primeiro vem uma tabela de referência rápida com a dúzia de flags que você usa todo dia, e depois exemplos de comandos prontos para copiar para cada tarefa comum: requisições GET e POST, envio de cabeçalhos, auth com bearer token, upload e download de arquivos e testes de API em scripts. Todo comando usa uma URL real e executável (httpbin.org ou um placeholder api.example.com), então dá para colar e testar na hora. O comportamento segue a documentação oficial do curl e a RFC 9110, o padrão atual de semântica HTTP.

Referência rápida: as flags do curl que você vai usar de verdade

Uns 90% do curl do dia a dia se resumem a uma dúzia de flags. Salve esta tabela; o resto do guia detalha cada uma com exemplos de comandos curl executáveis.

Flag	Significado	Exemplo
`-X`	Define o método HTTP	`curl -X DELETE https://api.example.com/items/42`
`-H`	Adiciona um cabeçalho de requisição (repetível)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Envia um corpo de requisição (implica POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Envia um corpo JSON + define os cabeçalhos JSON	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Envia um campo/arquivo de formulário multipart	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Salva a saída em um arquivo com nome definido	`curl -o page.html https://example.com`
`-O`	Salva usando o nome de arquivo remoto	`curl -O https://example.com/archive.zip`
`-L`	Segue redirecionamentos	`curl -L https://httpbin.org/redirect/2`
`-u`	Basic auth `user:pass`	`curl -u alice:s3cret https://httpbin.org/basic-auth/alice/s3cret`
`-i`	Inclui os cabeçalhos da resposta na saída	`curl -i https://httpbin.org/get`
`-I`	Busca apenas os cabeçalhos (HEAD)	`curl -I https://example.com`
`-v`	Verboso: mostra a requisição + handshake TLS	`curl -v https://example.com`
`-s`	Silencioso (sem barra de progresso)	`curl -s https://httpbin.org/get`
`-w`	Escreve variáveis após a transferência	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Envia cookies (string ou arquivo)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Salva os cookies recebidos em um jar	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	Pula a verificação do certificado TLS	`curl -k https://self-signed.example.com`
`--http2`	Solicita HTTP/2	`curl --http2 https://example.com`
`--http3`	Solicita HTTP/3 (QUIC)	`curl --http3 https://example.com`
`-T`	Faz upload de um arquivo com PUT	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	URL-encode de um campo do corpo	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Limita a duração total da transferência (segundos)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Limita o estabelecimento da conexão (segundos)	`curl --connect-timeout 5 https://example.com`
`--retry`	Tenta novamente uma transferência falha N vezes	`curl --retry 3 https://example.com`
`--limit-rate`	Limita a largura de banda da transferência	`curl --limit-rate 2M -O https://example.com/big.iso`

Fundamentos da sintaxe do curl: a anatomia de uma requisição

Um comando curl é o binário, algumas flags e uma URL. A URL pode vir antes ou depois das flags; o curl não liga para a ordem. O que ele liga é para quais flags implicam um método ou um corpo, porque elas interagem entre si.

Uma requisição GET simples

Sem nenhuma flag de método, o curl envia um GET. Este é o comando inteiro:

curl https://httpbin.org/get

O httpbin devolve sua requisição em forma de JSON, o que o torna ideal para testes. Adicione uma query string do mesmo jeito que você faria em um navegador:

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

Coloque a URL entre aspas. Um & solto diz ao shell para mandar o comando para segundo plano e descarta silenciosamente tudo o que vem depois. É um dos erros mais comuns com curl, e ele aparece de novo na seção de armadilhas mais abaixo.

Vendo a resposta: corpo, cabeçalhos, ambos

Por padrão o curl imprime apenas o corpo da resposta. Três flags mudam o que você vê:

# Corpo + linha de status + cabeçalhos da resposta
curl -i https://httpbin.org/get

# Apenas cabeçalhos — envia uma requisição HEAD, sem corpo
curl -I https://example.com

# Trace completo: linha de requisição, cabeçalhos de requisição, handshake TLS, resposta
curl -v https://example.com

Use -i quando quiser o corpo mais uma olhada rápida no Content-Type ou em um Set-Cookie. Use -I para checar um recurso sem baixá-lo (tamanho do arquivo, last-modified, destino do redirecionamento). E recorra ao -v quando algo está errado e você precisa ver exatamente o que o curl enviou.

Seguindo redirecionamentos

O curl não segue redirecionamentos a menos que você peça. Acesse uma URL que devolve 301 ou 302 sem o -L e você recebe a própria resposta de redirecionamento, não o destino:

# Para no 302, não imprime nada útil
curl https://httpbin.org/redirect/1

# Segue a cadeia até o 200 final
curl -L https://httpbin.org/redirect/1

Se você não tem certeza de por que uma requisição vai parar onde para, -IL mostra o código de status de cada salto. Para entender o que cada um desses códigos significa (e por que 301 e 302 não são intercambiáveis), veja a folha de consulta de códigos de status HTTP.

Métodos HTTP com curl (GET, POST, PUT, PATCH, DELETE)

O curl escolhe o método automaticamente com base nas suas flags: -d ou --json implica POST, URLs simples implicam GET. Use -X apenas quando precisar de um método que não corresponde ao corpo que você está enviando.

GET com parâmetros de consulta

Montar uma query string na mão dá errado fácil assim que os valores contêm espaços ou &. A flag -G diz ao curl para anexar os campos --data-urlencode à URL como uma query string corretamente codificada:

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

Isso produz ?q=hello%20world&tag=c%2B%2B, com o curl cuidando do percent-encoding para você não enviar uma URL quebrada.

POST: dados de formulário vs JSON

Uma curl post request aparece em dois formatos comuns. Form-encoded (o clássico corpo de formulário HTML):

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

-d define Content-Type: application/x-www-form-urlencoded e troca o método para POST por você. Para uma API JSON, envie JSON:

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

Há um jeito mais limpo de fazer isso, abordado na próxima seção.

PUT e PATCH

PUT substitui um recurso; PATCH atualiza parte dele. PUT é idempotente: enviá-lo duas vezes deixa o mesmo estado.

# Substitui o recurso inteiro
curl -X PUT -d '{"name":"alice","role":"owner"}' \
  -H "Content-Type: application/json" \
  https://api.example.com/users/7

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

DELETE

DELETE normalmente não carrega corpo, então -X é tudo de que você precisa:

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

Enviando cabeçalhos e corpos JSON

A maior parte do trabalho real com APIs são cabeçalhos e JSON. Duas flags dão conta disso: -H e --json.

Cabeçalhos curl personalizados com `-H`

-H adiciona um cabeçalho e pode ser repetido quantas vezes você precisar. É assim que você define Accept, Authorization, cabeçalhos X- personalizados e IDs de requisição:

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

Para remover um cabeçalho padrão que o curl enviaria, dê a ele um valor vazio (-H "User-Agent:"). Para enviar um cabeçalho sem valor, use um ponto e vírgula (-H "X-Empty;").

POST JSON: `-d` vs a moderna flag `--json`

Desde o curl 7.82, --json é a forma idiomática de enviar uma curl post request JSON. Ela faz três coisas de uma vez: define Content-Type: application/json, define Accept: application/json e envia o corpo literalmente.

# Forma antiga e verbosa — três peças para manter sincronizadas
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 é repetível e concatena, e --json @file.json lê o corpo de um arquivo. Prefira-a para qualquer API JSON.

Content-Type e Accept

É desses dois cabeçalhos que vêm os erros 415 e 406. Content-Type descreve o corpo que você envia; Accept diz o que você quer de volta. Envie JSON para um endpoint que só aceita dados de formulário e você recebe 415 Unsupported Media Type. Peça XML de uma API que só fala JSON e você pode receber 406 Not Acceptable. (Esses códigos são detalhados no guia de códigos de status HTTP.)

Quando a resposta volta como um paredão de JSON minificado, formate-a com o Formatador JSON, ou jogue direto no jq para extrair um único campo:

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

Para o conjunto completo de filtros jq (selecionar, mapear e remodelar respostas de API), veja a folha de consulta de JSON na linha de comando com jq.

Autenticação com curl

Quatro estilos de auth cobrem quase toda API: basic auth, bearer tokens, chaves de API e cookies.

Basic auth (`-u user:pass`)

-u envia um cabeçalho HTTP Authorization: Basic com suas credenciais codificadas em Base64:

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

Omita a senha (-u alice) e o curl pede por ela, mantendo-a fora do histórico do seu shell.

Bearer tokens e OAuth

A maioria das APIs modernas usa um curl bearer token: um token de acesso OAuth 2.0 ou token de API no cabeçalho Authorization. O curl tem um atalho, --oauth2-bearer, que é equivalente a escrever o cabeçalho na mão:

# Cabeçalho explícito
curl -H "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.abc" \
  https://api.example.com/me

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

Se o backend rejeitar o token, decodifique-o com o Decodificador JWT para checar as claims exp (expiração), aud (audiência) e iss (emissor) antes de culpar o curl. Quase sempre o culpado é um token expirado ou com a audiência errada.

Chaves de API (cabeçalho vs parâmetro de consulta)

Algumas APIs querem a chave em um cabeçalho, outras em um parâmetro de consulta. Cabeçalhos são mais seguros porque URLs vazam para logs e para o histórico do navegador:

# Preferível: chave em um cabeçalho
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Menos seguro: chave na URL (acaba nos logs de acesso)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookies (`-b` para enviar, `-c` para salvar)

-c escreve um cookie jar; -b lê um de volta. É assim que você carrega uma sessão entre requisições:

# Faz login e salva o cookie de sessão
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Reaproveita na próxima chamada
curl -b jar.txt https://httpbin.org/cookies

Nota de segurança: tokens e credenciais só pertencem a conexões HTTPS, porque o TLS criptografa os cabeçalhos e o HTTP puro não. Evite colocar segredos diretamente na linha de comando, onde eles vão parar no histórico do shell e na saída do ps. Leia um cabeçalho de um arquivo com -H @authfile ou puxe o valor de uma variável de ambiente (-H "Authorization: Bearer $TOKEN").

Baixando e enviando arquivos

O curl recebeu o nome “client URL” porque mover arquivos é sua função original. Downloads e uploads têm cada um algumas flags que vale a pena conhecer.

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

-O (O maiúsculo) salva o arquivo com seu nome remoto. -o (minúsculo) deixa você escolher o nome. -C - retoma um download parcial de onde parou:

# Salva com o nome de arquivo remoto: archive.zip
curl -O https://example.com/downloads/archive.zip

# Salva com um nome que você escolhe
curl -o backup.zip https://example.com/downloads/archive.zip

# Retoma um download interrompido
curl -C - -O https://example.com/downloads/archive.zip

# Segue redirecionamentos até o arquivo real (comum com CDNs)
curl -OL https://example.com/latest/archive.zip

Para fazer curl download file de conteúdo que está atrás de um redirecionamento, adicione -L, já que páginas de release e links de CDN quase sempre redirecionam.

Upload: `-T` vs `-F`

-T faz upload de um arquivo com PUT, enviando os bytes brutos como corpo (comum para object storage e endpoints REST de arquivo). -F envia uma requisição multipart/form-data, o mesmo formato que um navegador usa para inputs de arquivo:

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

# upload multipart/form-data (note o prefixo @)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

O prefixo @ diz ao curl para ler o conteúdo do arquivo. Sem ele, -F "file=report.pdf" envia a string literal report.pdf, não o arquivo.

`--data-urlencode` e percent-encoding

Quando um valor contém espaços, &, = ou caracteres não-ASCII, -d envia-o como está e quebra sua requisição. --data-urlencode codifica-o corretamente:

# Errado: o & divide o corpo, o espaço é inválido
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Certo: cada campo é percent-encoded
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Se você precisa entender o que essas sequências %20 e %26 significam, ou depurar um valor que está com codificação dupla, cole-o no Decodificador e Codificador de URL ou leia o passo a passo no nível dos bytes no guia de codificação e decodificação de URL.

Testes de API e inspeção de respostas

O curl é forte em scripts e CI porque -w expõe tudo sobre a transferência e os códigos de saída tornam as falhas detectáveis.

Apenas o código de status

Para pegar só o status HTTP, descarte o corpo com -o /dev/null e imprima o código com -w:

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

Esse é o núcleo de qualquer health check de curl api testing. Para interpretar o número que volta, a folha de consulta de códigos de status HTTP cobre todas as faixas.

Detalhamento de tempos

-w expõe variáveis de tempo, então você consegue ver para onde o tempo vai: DNS, conexão TCP, TLS ou o próprio servidor.

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

Um time_appconnect alto aponta para o TLS, um time_starttransfer alto aponta para um backend lento.

Silencioso, mas mostrando erros

-s esconde a barra de progresso, mas também esconde as mensagens de erro, o que vira uma armadilha em scripts. Combine-o com -S para o curl ficar quieto no sucesso e ainda assim reportar falhas:

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

curl em CI / scripts: falhar em erros HTTP

Por padrão o curl sai com 0 mesmo em um 404 ou 500, porque a transferência em si teve sucesso. Em um health check isso é o oposto do que você quer. -f (fail) faz o curl sair com código não-zero em erros HTTP para o seu pipeline pegá-los:

# Quebra o build se o endpoint retornar 4xx/5xx
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) é a combinação canônica para health check. Para diagnósticos mais detalhados, --fail-with-body (curl 7.76+) ainda imprime a resposta de erro antes de sair.

Tempos limite e novas tentativas

Um health check que trava para sempre é pior do que um que falha rápido. Limite cada requisição em script com --max-time (teto para toda a transferência) e --connect-timeout (teto apenas para estabelecer a conexão):

# Desiste após 5 s de conexão, 10 s no total
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

Em uma rede instável, --retry tenta de novo uma transferência falha com recuo exponencial. Por padrão só repete falhas transitórias (tempos esgotados, 5xx); adicione --retry-all-errors para repetir também conexões recusadas:

# Até 3 tentativas, com pausa crescente entre elas
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Quando um script baixa um arquivo grande e você não quer saturar o link, --limit-rate limita a largura de banda: --limit-rate 2M a mantém em 2 MB/s.

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

O curl negocia a versão do HTTP sobre TLS via ALPN. Você pode forçar uma versão quando precisa testar um caminho de protocolo específico.

`--http2` e `--http3`

# Solicita HTTP/2 (cai para 1.1 se indisponível)
curl --http2 https://example.com

# Solicita HTTP/3 sobre QUIC
curl --http3 https://example.com

O HTTP/3 roda sobre QUIC e exige TLS 1.3. Ele só funciona se o seu curl foi compilado com um backend capaz de HTTP/3 e o servidor o anuncia via um cabeçalho Alt-Svc. Rode curl --version para confirmar que HTTP3 aparece na linha de features; se não aparecer, --http3 vai dar erro.

Info verbosa de TLS / ALPN

-v mostra o protocolo negociado e o handshake TLS, que é como você confirma que uma versão de fato entrou em vigor:

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

Procure por ALPN: server accepted h2 (HTTP/2) ou h3 (HTTP/3) na saída do handshake.

8 armadilhas comuns do curl (e como resolvê-las)

Estas oito acabam pegando todo mundo em algum momento.

Aspas simples vs duplas. Aspas duplas deixam o shell expandir $VARS; aspas simples passam tudo literalmente. Use aspas simples para corpos JSON, para que $ e ! não sejam interpretados: curl --json '{"price":"$5"}'. Use aspas duplas quando você quer a expansão: -H "Authorization: Bearer $TOKEN".
-d não faz URL-encode. Um espaço ou & em um valor de -d corrompe o corpo. Mude para --data-urlencode para qualquer valor que ainda não esteja codificado.
-X POST redundante com -d. -d já implica POST. Escrever -X POST -d ... é inofensivo, mas redundante; pior, -X GET -d ... envia um corpo com um GET, o que surpreende alguns servidores. Deixe a flag de corpo definir o método.
Esquecer o @ ao ler de um arquivo. -d @body.json lê o arquivo; -d body.json envia o texto literal body.json. A mesma armadilha com -F "file=@upload.png" versus -F "file=upload.png".
Recorrer ao -k em erros de certificado. -k desativa a verificação TLS e esconde problemas reais (certificados expirados, hostname errado, intermediário ausente). Corrija a causa raiz: instale a CA com --cacert ca.pem ou atualize o trust store do sistema. Reserve o -k para um servidor de dev self-signed que você controla por completo.
-s engolindo erros. O modo silencioso esconde falhas em scripts. Sempre use -sS para os erros ainda virem à tona.
[ ] { } em URLs sendo interpretados como globbing. O curl trata [1-5] e {a,b} como faixas/listas de URL. Uma URL com colchetes literais (comum em parâmetros de array como arr[]=1) acaba destruída. Desative o globbing com -g: curl -g "https://api.example.com/items?id[]=1&id[]=2".
Caixa e duplicatas de cabeçalhos. Os nomes de cabeçalho HTTP são case-insensitive, mas enviar o mesmo cabeçalho duas vezes normalmente manda os dois: alguns servidores pegam o primeiro, alguns o último, alguns rejeitam de vez. Se você sobrescrever um padrão como o User-Agent, defina-o uma vez com -H em vez de depender da ordem.

curl vs wget vs HTTPie: qual usar

Os três buscam dados sobre HTTP, mas otimizam para trabalhos diferentes. Aqui está a decisão curl vs wget (mais o HTTPie) num relance:

Tarefa	curl	wget	HTTPie
Chamada/depuração rápida de API	Excelente	Limitado	Excelente
Corpos JSON	Bom (`--json`)	Trabalhoso	Excelente (nativo)
Download/espelhamento recursivo de site	Não	Excelente (`-r`)	Não
Retomar + repetir downloads grandes	Bom (`-C -`)	Excelente (embutido)	Não
Scripting / CI (códigos de saída, `-w`)	Excelente	Bom	Bom
Saída bonita e colorida por padrão	Não	Não	Excelente
Pré-instalado em quase tudo	Sim	Frequentemente	Raramente

Resumindo: recorra ao curl para depuração de API e scripts (ele está em toda parte e o -w é imbatível), ao HTTPie quando você quer a ergonomia de JSON legível na sua própria máquina, e ao wget para espelhar sites ou baixar arquivos em lote com retentativas automáticas.

Perguntas frequentes

Para que serve o curl?

O curl é uma ferramenta de linha de comando para transferir dados de e para um servidor sobre HTTP, HTTPS, FTP e muitos outros protocolos. Desenvolvedores o usam para chamar e depurar APIs, baixar e enviar arquivos e rodar health checks em scripts e pipelines de CI.

Como envio uma requisição POST com curl?

Use -d para dados de formulário ou --json para JSON: curl --json '{"name":"alice"}' https://httpbin.org/post. As duas flags definem o método como POST automaticamente, então você não precisa do -X POST.

Como adiciono um cabeçalho no curl?

Use -H "Name: value" e repita para múltiplos cabeçalhos: curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Não há limite de quantas vezes você pode passar -H.

Como envio um bearer token com curl?

Passe um cabeçalho Authorization: curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, ou use o atalho --oauth2-bearer YOUR_TOKEN. Envie tokens apenas sobre HTTPS, e decodifique-os com o Decodificador JWT ao depurar.

Como baixo um arquivo com curl?

Use -O para manter o nome de arquivo remoto ou -o name para escolher o seu próprio: curl -O https://example.com/archive.zip. Adicione -L para seguir redirecionamentos e -C - para retomar um download interrompido.

Como vejo apenas o código de status HTTP com curl?

Descarte o corpo e imprima o código: curl -s -o /dev/null -w "%{http_code}" https://example.com. Esse é o padrão usual para health checks em scripts.

Qual a diferença entre curl e wget?

O curl transfere um único recurso e escreve no stdout por padrão, o que o torna ideal para chamadas de API e scripting. O wget é especializado em download, incluindo espelhamento recursivo e retentativas automáticas. Para testes de API, use curl; para downloads de arquivos em massa, use wget.

O curl está disponível no Windows?

Sim. O curl vem com o Windows 10 (build 1803+) e o Windows 11, disponível como curl no Prompt de Comando e no PowerShell. Note que o PowerShell historicamente fazia um alias de curl para Invoke-WebRequest, então chame curl.exe explicitamente se as flags se comportarem de forma inesperada.

Encerrando

O curl recompensa um pouquinho de memorização: a tabela de flags no topo cobre a grande maioria do que você vai digitar, e o resto é saber quais flags implicam um método, quais precisam de aspas e quais te enganam em scripts (é com você que estou falando, -s solto). Deixe esta folha de consulta curl aberta ao lado do terminal. Se preferir montar os comandos de forma interativa, experimente nosso construtor de comandos cURL para gerá-los visualmente.

Num fluxo de trabalho de API, os próximos passos vêm logo em seguida. Envie a requisição com curl, leia o que voltou com a folha de consulta de códigos de status HTTP, depois formate o JSON no Formatador JSON ou fatie-o com a folha de consulta de JSON na linha de comando com jq. Para a lista completa de opções, o manual do curl é exaustivo, e a referência de HTTP da MDN explica a semântica por trás de cada método e cabeçalho.