Contekan curl: 40+ Contoh Perintah HTTP & API

Anda sudah tiga lompatan SSH masuk ke staging box, sebuah API mengembalikan hasil yang salah, dan satu-satunya HTTP client yang terpasang cuma curl. Atau Anda sedang membaca skrip CI yang menjalankan health-check pada suatu layanan dan penasaran apa sebenarnya yang dilakukan -fsS. Atau rekan kerja menempelkan one-liner di Slack dan Anda perlu menyesuaikannya. curl ada di mana-mana, dan flag-nya cukup ringkas sehingga tidak ada yang hafal semuanya.

Contekan curl ini dibuat untuk momen-momen seperti itu. Anda dapat tabel referensi cepat berisi belasan flag yang dipakai sehari-hari, lalu contoh perintah siap salin untuk tugas-tugas umum: request GET dan POST, mengirim header, auth bearer token, mengunggah dan mengunduh file, sampai pengujian API di dalam skrip. Setiap perintah memakai URL nyata yang bisa dijalankan (httpbin.org atau placeholder api.example.com), jadi Anda bisa langsung tempel dan coba. Perilakunya mengikuti dokumentasi resmi curl dan RFC 9110, standar semantik HTTP yang berlaku sekarang.

Referensi cepat — flag curl yang benar-benar Anda pakai

Sembilan puluh persen pemakaian curl harian cuma melibatkan belasan flag. Tandai tabel ini; sisa panduan menjabarkan masing-masing dengan contoh perintah curl yang bisa dijalankan.

Flag	Arti	Contoh
`-X`	Menetapkan metode HTTP	`curl -X DELETE https://api.example.com/items/42`
`-H`	Menambahkan request header (bisa diulang)	`curl -H "Accept: application/json" https://httpbin.org/get`
`-d`	Mengirim request body (menyiratkan POST)	`curl -d "name=alice" https://httpbin.org/post`
`--json`	Mengirim JSON body + menyetel header JSON	`curl --json '{"id":1}' https://httpbin.org/post`
`-F`	Mengirim field/file multipart form	`curl -F "file=@report.pdf" https://httpbin.org/post`
`-o`	Menyimpan output ke file dengan nama tertentu	`curl -o page.html https://example.com`
`-O`	Menyimpan dengan nama file remote	`curl -O https://example.com/archive.zip`
`-L`	Mengikuti 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`	Menyertakan response header dalam output	`curl -i https://httpbin.org/get`
`-I`	Mengambil header saja (HEAD)	`curl -I https://example.com`
`-v`	Verbose: menampilkan request + TLS handshake	`curl -v https://example.com`
`-s`	Silent (tanpa progress meter)	`curl -s https://httpbin.org/get`
`-w`	Menulis variabel setelah transfer	`curl -s -o /dev/null -w "%{http_code}" https://example.com`
`-b`	Mengirim cookie (string atau file)	`curl -b cookies.txt https://httpbin.org/cookies`
`-c`	Menyimpan cookie yang diterima ke jar	`curl -c cookies.txt https://httpbin.org/cookies/set/a/1`
`-k`	Melewati verifikasi sertifikat TLS	`curl -k https://self-signed.example.com`
`--http2`	Meminta HTTP/2	`curl --http2 https://example.com`
`--http3`	Meminta HTTP/3 (QUIC)	`curl --http3 https://example.com`
`-T`	Mengunggah file dengan PUT	`curl -T backup.tar https://api.example.com/files/backup.tar`
`--data-urlencode`	Meng-URL-encode sebuah field body	`curl --data-urlencode "q=hello world" https://httpbin.org/get -G`
`--max-time`	Batasi total durasi transfer (detik)	`curl --max-time 10 https://example.com`
`--connect-timeout`	Batasi pembentukan koneksi (detik)	`curl --connect-timeout 5 https://example.com`
`--retry`	Coba ulang transfer yang gagal N kali	`curl --retry 3 https://example.com`
`--limit-rate`	Batasi bandwidth transfer	`curl --limit-rate 2M -O https://example.com/big.iso`

Dasar sintaks curl — anatomi sebuah request

Perintah curl terdiri atas binary, beberapa flag, dan satu URL. URL boleh diletakkan sebelum atau sesudah flag; curl tidak peduli urutan. Yang penting baginya adalah flag mana yang menyiratkan metode atau body, karena keduanya saling berinteraksi.

Sebuah request GET sederhana

Tanpa flag metode, curl mengirim GET. Ini perintah lengkapnya:

curl https://httpbin.org/get

httpbin memantulkan request Anda kembali dalam bentuk JSON, jadi enak buat pengujian. Tambahkan query string persis seperti di browser:

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

Beri tanda kutip pada URL-nya. Sebuah & polos akan menyuruh shell menjalankan perintah di latar belakang lalu diam-diam membuang segala sesuatu setelahnya, salah satu kesalahan curl paling umum yang dibahas di bagian jebakan di bawah.

Melihat respons: body, header, atau keduanya

Secara default curl hanya mencetak response body. Tiga flag mengubah apa yang Anda lihat:

# Body + status line + response header
curl -i https://httpbin.org/get

# Header saja — mengirim request HEAD, tanpa body
curl -I https://example.com

# Trace penuh: request line, request header, TLS handshake, respons
curl -v https://example.com

Pakai -i saat Anda ingin body sekaligus melirik Content-Type atau Set-Cookie. Pakai -I untuk memeriksa resource tanpa mengunduhnya (ukuran file, last-modified, target redirect). Andalkan -v saat ada yang salah dan Anda perlu lihat persis apa yang dikirim curl.

Mengikuti redirect

curl tidak mengikuti redirect kecuali Anda memintanya. Akses URL yang mengembalikan 301 atau 302 tanpa -L, dan yang Anda dapat adalah respons redirect itu sendiri, bukan tujuannya:

# Berhenti di 302, tidak mencetak apa pun yang berguna
curl https://httpbin.org/redirect/1

# Mengikuti rantainya hingga 200 akhir
curl -L https://httpbin.org/redirect/1

Kalau Anda tidak yakin kenapa suatu request berakhir di suatu tempat, -IL menampilkan status code tiap lompatan. Untuk arti masing-masing code, plus kenapa 301 dan 302 tidak bisa dipertukarkan, lihat contekan kode status HTTP.

Metode HTTP dengan curl (GET, POST, PUT, PATCH, DELETE)

curl memilih metode otomatis dari flag Anda: -d atau --json menyiratkan POST, URL polos menyiratkan GET. Pakai -X hanya saat Anda butuh metode yang tidak cocok dengan body yang dikirim.

GET dengan parameter query

Membangun query string secara manual gampang salah begitu nilainya mengandung spasi atau &. Flag -G menyuruh curl menempelkan field --data-urlencode ke URL sebagai query string yang ter-encode dengan benar:

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

Hasilnya ?q=hello%20world&tag=c%2B%2B; curl yang menangani percent-encoding, jadi Anda tidak mengirim URL yang rusak.

POST: data form vs JSON

Sebuah curl post request umumnya datang dalam dua bentuk. Form-encoded (body form HTML klasik):

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

-d menyetel Content-Type: application/x-www-form-urlencoded dan mengganti metodenya jadi POST untuk Anda. Untuk API JSON, kirim JSON saja:

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

Ada cara yang lebih rapi, dibahas di bagian berikutnya.

PUT dan PATCH

PUT mengganti seluruh resource; PATCH memperbarui sebagiannya. PUT bersifat idempoten, jadi mengirimkannya dua kali meninggalkan state yang sama.

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

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

DELETE

DELETE biasanya tidak membawa body, jadi -X saja cukup:

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

Mengirim header dan body JSON

Sebagian besar pekerjaan API nyata berkutat di header dan JSON. Dua flag yang memikul beban ini: -H dan --json.

Header curl kustom dengan `-H`

-H menambahkan satu header dan bisa diulang sebanyak yang Anda perlu. Begini cara menyetel Accept, Authorization, header X- kustom, dan request ID:

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

Untuk menghapus header default yang seharusnya dikirim curl, beri nilai kosong (-H "User-Agent:"). Untuk mengirim header tanpa nilai, pakai titik koma (-H "X-Empty;").

POST JSON: `-d` vs flag modern `--json`

Sejak curl 7.82, --json adalah cara idiomatik mengirim curl post request JSON. Ia menangani tiga hal sekaligus: menyetel Content-Type: application/json, menyetel Accept: application/json, dan mengirim body apa adanya.

# Cara lama yang bertele-tele — tiga bagian yang harus disinkronkan
curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"name":"alice"}' \
  https://httpbin.org/post

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

--json bisa diulang dan digabungkan, dan --json @file.json membaca body dari file. Utamakan flag ini untuk API JSON apa pun.

Content-Type dan Accept

Kedua header inilah biang error 415 dan 406. Content-Type mendeskripsikan body yang Anda kirim; Accept menyatakan apa yang Anda mau kembali. Kirim JSON ke endpoint yang cuma menerima data form, dan Anda kena 415 Unsupported Media Type. Minta XML dari API yang cuma melayani JSON, dan Anda bisa kena 406 Not Acceptable. (Code-code ini diuraikan di panduan kode status HTTP.)

Kalau respons kembali sebagai dinding JSON terminifikasi, rapikan tampilannya dengan JSON Formatter, atau alirkan langsung ke jq untuk mengambil satu field:

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

Untuk kumpulan lengkap filter jq yang menyeleksi, memetakan, dan membentuk ulang respons API, lihat cheat sheet jq untuk JSON di command line.

Autentikasi dengan curl

Empat gaya auth menutupi hampir semua API: basic auth, bearer token, API key, dan cookie.

Basic auth (`-u user:pass`)

-u mengirim header Authorization: Basic dengan kredensial Anda yang ter-encode dalam Base64:

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

Hilangkan kata sandinya (-u alice) dan curl akan menanyakannya, jadi tidak ikut masuk ke riwayat shell Anda.

Bearer token & OAuth

Sebagian besar API modern memakai curl bearer token: access token OAuth 2.0 atau API token di dalam header Authorization. curl punya bentuk singkat, --oauth2-bearer, yang setara dengan menulis header secara manual:

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

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

Kalau backend menolak token-nya, dekode dengan Dekoder JWT untuk memeriksa klaim exp (kedaluwarsa), aud (audience), dan iss (issuer) sebelum menyalahkan curl. Token yang kedaluwarsa atau salah audience biasanya jadi penyebabnya.

API key (header vs query param)

Sebagian API ingin key-nya di header, sebagian lain di parameter query. Header lebih aman karena URL bocor ke log dan riwayat browser:

# Disarankan: key di sebuah header
curl -H "X-API-Key: sk_live_a1b2c3" https://api.example.com/data

# Kurang aman: key di URL (berakhir di access log)
curl "https://api.example.com/data?api_key=sk_live_a1b2c3"

Cookie (`-b` untuk mengirim, `-c` untuk menyimpan)

-c menulis cookie jar; -b membacanya kembali. Begini cara membawa satu sesi lintas request:

# Login dan simpan cookie sesi
curl -c jar.txt -d "user=alice&pass=s3cret" https://httpbin.org/cookies/set/session/abc123

# Pakai ulang pada panggilan berikutnya
curl -b jar.txt https://httpbin.org/cookies

Catatan keamanan: kirim token dan kredensial hanya lewat koneksi HTTPS, karena TLS mengenkripsi header sedangkan HTTP biasa tidak. Jangan menaruh rahasia langsung di baris perintah, karena akan mendarat di riwayat shell dan di output ps. Baca header dari file dengan -H @authfile, atau ambil nilainya dari variabel environment (-H "Authorization: Bearer $TOKEN").

Mengunduh dan mengunggah file

curl dinamai “client URL” karena memindahkan file memang pekerjaan aslinya. Pengunduhan dan pengunggahan masing-masing punya beberapa flag yang patut Anda tahu.

Unduh: `-O` vs `-o` vs `-C -`

-O (O besar) menyimpan file dengan nama remote-nya. -o (huruf kecil) membiarkan Anda memilih namanya sendiri. -C - melanjutkan unduhan yang belum selesai dari titik terakhir:

# Simpan sebagai nama file remote: archive.zip
curl -O https://example.com/downloads/archive.zip

# Simpan dengan nama yang Anda pilih
curl -o backup.zip https://example.com/downloads/archive.zip

# Lanjutkan unduhan yang terputus
curl -C - -O https://example.com/downloads/archive.zip

# Ikuti redirect ke file sebenarnya (umum dengan CDN)
curl -OL https://example.com/latest/archive.zip

Untuk meng-curl download file konten yang berada di balik redirect, tambahkan -L. Halaman rilis dan link CDN hampir selalu melakukan redirect.

Unggah: `-T` vs `-F`

-T mengunggah file dengan PUT, mengirim byte mentahnya sebagai body (umum untuk object storage dan endpoint file REST). -F mengirim request multipart/form-data, format yang sama yang dipakai browser untuk input file:

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

# Unggahan multipart/form-data (perhatikan prefiks @)
curl -F "file=@report.pdf" -F "title=Q2 report" https://httpbin.org/post

Prefiks @ menyuruh curl membaca isi file. Tanpa itu, -F "file=report.pdf" mengirim string literal report.pdf, bukan file-nya.

`--data-urlencode` dan percent-encoding

Kalau sebuah nilai mengandung spasi, &, =, atau karakter non-ASCII, -d mengirimnya apa adanya dan merusak request Anda. --data-urlencode meng-encode-nya dengan benar:

# Salah: & memecah body, spasi tidak valid
curl -d "q=hello world&filter=a&b" https://httpbin.org/post

# Benar: setiap field di-percent-encode
curl --data-urlencode "q=hello world" \
  --data-urlencode "filter=a&b" \
  https://httpbin.org/post

Kalau Anda perlu memahami arti urutan %20 dan %26, atau men-debug nilai yang ter-encode ganda, tempel ke URL Decoder & Encoder atau baca penjelasan tingkat byte di panduan URL encoding dan decoding.

Pengujian API & memeriksa respons

curl paling berguna di dalam skrip dan CI: -w membuka segala hal tentang transfer, dan exit code-nya membuat kegagalan bisa dideteksi.

Status code saja

Untuk mengambil status HTTP saja, buang body-nya dengan -o /dev/null lalu cetak code-nya dengan -w:

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

Inilah inti dari tiap health check curl api testing. Untuk menafsirkan angka yang Anda terima, contekan kode status HTTP menjelaskan tiap rentangnya.

Rincian timing

-w membuka variabel timing, jadi Anda bisa melihat ke mana waktu terpakai: DNS, TCP connect, TLS, atau server itu sendiri:

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

time_appconnect yang tinggi menunjuk ke TLS, time_starttransfer yang tinggi menunjuk ke backend yang lambat.

Silent tapi tetap tampilkan error

-s menyembunyikan progress meter, tetapi sekaligus menyembunyikan pesan error, dan ini jebakan klasik di dalam skrip. Pasangkan dengan -S agar curl tetap diam saat sukses tapi tetap melaporkan kegagalan:

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

curl di CI / skrip: gagal saat ada error HTTP

Secara default curl keluar dengan kode 0 bahkan pada 404 atau 500, karena transfer-nya sendiri berhasil. Di sebuah health check, itu justru kebalikan dari yang Anda mau. -f (fail) membuat curl keluar dengan kode bukan-nol pada error HTTP sehingga pipeline Anda menangkapnya:

# Menggagalkan build jika endpoint mengembalikan 4xx/5xx
curl -fsS https://api.example.com/health || exit 1

-fsS (fail, silent, show-errors) adalah kombinasi health-check standar. Untuk diagnostik yang lebih lengkap, --fail-with-body (curl 7.76+) tetap mencetak respons error sebelum keluar.

Timeout dan percobaan ulang

Health check yang menggantung selamanya lebih buruk daripada yang gagal cepat. Batasi setiap permintaan dalam skrip dengan --max-time (batas untuk seluruh transfer) dan --connect-timeout (batas hanya untuk membangun koneksi):

# Menyerah setelah 5 d koneksi, 10 d total
curl --connect-timeout 5 --max-time 10 -fsS https://api.example.com/health

Di jaringan yang tidak stabil, --retry mencoba ulang transfer yang gagal dengan backoff eksponensial. Secara default hanya mengulang kegagalan sementara (timeout, 5xx); tambahkan --retry-all-errors untuk mengulang koneksi yang ditolak juga:

# Hingga 3 percobaan, dengan jeda yang membesar
curl --retry 3 --retry-all-errors --max-time 30 -fsS https://api.example.com/health

Saat skrip mengunduh file besar dan Anda tidak ingin menjenuhkan tautan, --limit-rate membatasi bandwidth — --limit-rate 2M menahannya di 2 MB/s.

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

curl menegosiasikan versi HTTP di atas TLS lewat ALPN. Anda bisa memaksa satu versi saat perlu menguji jalur protokol tertentu.

`--http2` dan `--http3`

# Meminta HTTP/2 (jatuh kembali ke 1.1 jika tidak tersedia)
curl --http2 https://example.com

# Meminta HTTP/3 di atas QUIC
curl --http3 https://example.com

HTTP/3 berjalan di atas QUIC dan membutuhkan TLS 1.3. Ini hanya bekerja kalau curl Anda dibangun dengan backend yang mendukung HTTP/3 dan server mengiklankannya lewat header Alt-Svc. Jalankan curl --version untuk memastikan HTTP3 muncul di baris features; kalau tidak ada, --http3 akan error.

Info TLS / ALPN verbose

-v menampilkan protokol yang dinegosiasikan dan TLS handshake. Begini cara memastikan satu versi benar-benar berlaku:

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

Cari ALPN: server accepted h2 (HTTP/2) atau h3 (HTTP/3) di output handshake.

8 jebakan curl yang umum (dan cara memperbaikinya)

Delapan hal ini cepat atau lambat menjebak siapa saja.

Tanda kutip tunggal vs ganda. Tanda kutip ganda membuat shell meng-expand $VARS; tanda kutip tunggal meneruskan semuanya apa adanya. Pakai tanda kutip tunggal untuk body JSON agar $ dan ! tidak ikut diinterpretasikan: curl --json '{"price":"$5"}'. Pakai tanda kutip ganda saat Anda memang ingin expansion: -H "Authorization: Bearer $TOKEN".
-d tidak melakukan URL-encode. Spasi atau & di dalam nilai -d merusak body. Beralihlah ke --data-urlencode untuk nilai apa pun yang belum ter-encode.
-X POST yang berlebihan bersama -d. -d sudah menyiratkan POST. Menulis -X POST -d ... tidak berbahaya tapi mubazir; yang lebih parah, -X GET -d ... mengirim body bersama GET, dan ini mengagetkan sebagian server. Biarkan flag body yang menetapkan metodenya.
Lupa @ saat membaca dari file. -d @body.json membaca file-nya; -d body.json mengirim teks literal body.json. Jebakan yang sama berlaku pada -F "file=@upload.png" versus -F "file=upload.png".
Mengandalkan -k saat ada error sertifikat. -k menonaktifkan verifikasi TLS dan menutupi masalah nyata (sertifikat kedaluwarsa, hostname salah, intermediate hilang). Perbaiki akar masalahnya: pasang CA dengan --cacert ca.pem, atau perbarui trust store sistem Anda. Sisakan -k untuk dev server self-signed yang sepenuhnya Anda kendalikan.
-s menelan error. Mode silent menutupi kegagalan di dalam skrip. Selalu pakai -sS agar error tetap muncul.
[ ] { } di URL ter-glob. curl memperlakukan [1-5] dan {a,b} sebagai range/list URL. URL dengan bracket literal (umum pada parameter query array seperti arr[]=1) jadi rusak karenanya. Matikan globbing dengan -g: curl -g "https://api.example.com/items?id[]=1&id[]=2".
Case dan duplikasi header. Nama header HTTP bersifat case-insensitive, tetapi mengirim header yang sama dua kali biasanya mengirim keduanya, dan sebagian server mengambil yang pertama, sebagian yang terakhir, sebagian menolaknya. Kalau Anda menimpa default seperti User-Agent, setel sekali saja dengan -H ketimbang mengandalkan urutan.

curl vs wget vs HTTPie — mana yang dipakai

Ketiganya mengambil data lewat HTTP, tetapi masing-masing dioptimalkan untuk pekerjaan yang berbeda. Berikut keputusan curl vs wget (plus HTTPie) sekilas:

Tugas	curl	wget	HTTPie
Panggilan API cepat / debugging	Sangat baik	Terbatas	Sangat baik
Body JSON	Baik (`--json`)	Canggung	Sangat baik (native)
Unduhan/mirroring situs rekursif	Tidak	Sangat baik (`-r`)	Tidak
Resume + retry unduhan besar	Baik (`-C -`)	Sangat baik (bawaan)	Tidak
Scripting / CI (exit code, `-w`)	Sangat baik	Baik	Baik
Output rapi dan berwarna secara default	Tidak	Tidak	Sangat baik
Terpasang lebih dahulu hampir di mana-mana	Ya	Sering	Jarang

Singkatnya: andalkan curl untuk debugging dan skrip API (ada di mana-mana, dan -w tak tertandingi), HTTPie saat Anda ingin ergonomi JSON yang enak dibaca di mesin sendiri, dan wget untuk mirroring situs atau mengunduh file secara batch dengan retry otomatis.

Pertanyaan yang sering diajukan

Untuk apa curl digunakan?

curl adalah alat command line untuk mentransfer data ke dan dari server lewat HTTP, HTTPS, FTP, dan banyak protokol lain. Developer memakainya untuk memanggil dan men-debug API, mengunduh dan mengunggah file, serta menjalankan health check di dalam skrip dan pipeline CI.

Bagaimana cara mengirim request POST dengan curl?

Pakai -d untuk data form atau --json untuk JSON: curl --json '{"name":"alice"}' https://httpbin.org/post. Kedua flag menyetel metode ke POST secara otomatis, jadi Anda tidak perlu -X POST.

Bagaimana cara menambahkan header di curl?

Pakai -H "Name: value", dan ulangi untuk beberapa header: curl -H "Accept: application/json" -H "X-Request-Id: 9f3c1a" https://httpbin.org/headers. Tidak ada batasan berapa kali Anda bisa memberikan -H.

Bagaimana cara mengirim bearer token dengan curl?

Berikan header Authorization: curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com/me, atau pakai bentuk singkat --oauth2-bearer YOUR_TOKEN. Kirim token hanya lewat HTTPS, dan dekode dengan Dekoder JWT saat men-debug.

Bagaimana cara mengunduh file dengan curl?

Pakai -O untuk mempertahankan nama file remote atau -o name untuk memilih nama sendiri: curl -O https://example.com/archive.zip. Tambahkan -L untuk mengikuti redirect dan -C - untuk melanjutkan unduhan yang terputus.

Bagaimana cara melihat hanya kode status HTTP dengan curl?

Buang body-nya dan cetak code-nya: curl -s -o /dev/null -w "%{http_code}" https://example.com. Inilah pola standar untuk health check di dalam skrip.

Apa perbedaan antara curl dan wget?

curl mentransfer satu resource dan menulis ke stdout secara default, jadi pas untuk panggilan API dan scripting. wget berfokus pada pengunduhan, termasuk mirroring rekursif dan retry otomatis. Untuk pengujian API, pakai curl; untuk unduhan file massal, pakai wget.

Apakah curl tersedia di Windows?

Ya. curl disertakan dengan Windows 10 (build 1803+) dan Windows 11, tersedia sebagai curl di Command Prompt dan PowerShell. Satu catatan: PowerShell secara historis meng-alias-kan curl ke Invoke-WebRequest, jadi panggil curl.exe secara eksplisit kalau flag berperilaku tak terduga.

Penutup

curl membayar sedikit hafalan dengan banyak: tabel flag di bagian atas mencakup sebagian besar yang akan Anda ketik, dan sisanya soal tahu flag mana yang menyiratkan metode, mana yang perlu diberi tanda kutip, dan mana yang menipu Anda di dalam skrip (iya, -s polos, ini soal kamu). Biarkan contekan curl ini tetap terbuka di samping terminal Anda. Kalau Anda lebih suka merakit perintah secara interaktif, coba pembuat perintah cURL kami untuk membuatnya secara visual.

Langkah berikutnya dalam sebuah alur kerja API cuma berjarak satu klik. Kirim request-nya dengan curl, baca apa yang kembali lewat contekan kode status HTTP, lalu rapikan JSON-nya di JSON Formatter atau iris dengan cheat sheet jq untuk JSON di command line. Untuk daftar opsi lengkap, manual curl sangat menyeluruh, dan referensi HTTP dari MDN menjelaskan semantik di balik tiap metode dan header.