Fetch API, XMLHttpRequest, dan Axios adalah tiga cara umum mengirim request HTTP dari JavaScript di browser. Fetch menonjol karena bawaan browser dan berbasis Promise, XMLHttpRequest unggul di area kompatibilitas lama serta progres upload, sedangkan Axios memberi pembungkus siap pakai dengan banyak perilaku default. Pilihan bergantung pada target browser, kompleksitas interceptor, dan seberapa banyak kode yang ingin kamu tulis sendiri.

Perbedaan mendasar ketiganya

XMLHttpRequest adalah API klasik berbasis callback dengan event handler seperti onreadystatechange atau onload. Fetch muncul sebagai penggantinya dengan model Promise, jadi bisa dirangkai dengan async/await. Axios dibangun di atas XMLHttpRequest di sisi browser dan menambahkan lapisan konfigurasi, transformasi request/response, serta dukungan Node.js lewat adapter berbeda.

Karena Fetch mengembalikan Promise yang resolve meski status HTTP 404 atau 500, kamu perlu memeriksa response.ok sebelum membaca body. Axios otomatis melempar error untuk status di luar rentang 2xx. XMLHttpRequest tidak punya perilaku default tersebut, sehingga pengecekan status dilakukan manual di dalam callback.

Membaca dan mengirim data: contoh singkat

Perbedaan gaya penulisan paling terasa saat mengirim JSON. Berikut bentuk minimal dari masing-masing pendekatan.

Fetch API

async function kirimData() {
  const res = await fetch('/api/simpan', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ nama: 'Budi' })
  });
  if (!res.ok) throw new Error('Gagal: ' + res.status);
  return res.json();
}

XMLHttpRequest

function kirimData(callback) {
  const xhr = new XMLHttpRequest();
  xhr.open('POST', '/api/simpan');
  xhr.setRequestHeader('Content-Type', 'application/json');
  xhr.onload = function () {
    if (xhr.status >= 200 && xhr.status < 300) {
      callback(null, JSON.parse(xhr.responseText));
    } else {
      callback(new Error('Gagal: ' + xhr.status));
    }
  };
  xhr.onerror = function () { callback(new Error('Jaringan error')); };
  xhr.send(JSON.stringify({ nama: 'Budi' }));
}

Axios

async function kirimData() {
  const res = await axios.post('/api/simpan', { nama: 'Budi' });
  return res.data;
}

Axios memotong banyak boilerplate karena otomatis menangani header JSON, parsing response, dan pelemparan error. Fetch memaksa kamu menulis JSON.stringify serta membaca body lewat metode seperti .json(). XMLHttpRequest paling panjang, tapi semua langkahnya terlihat eksplisit.

Tabel perbandingan cepat

Aspek Fetch API XMLHttpRequest Axios
Bawaan browser Ya Ya Tidak, perlu pustaka
Model async Promise Callback/event Promise
Error otomatis 4xx/5xx Tidak Tidak Ya
Progres upload Belum stabil Didukung Didukung
Interceptor Manual Tidak ada Bawaan
Dukungan Node.js Ada (versi baru) Tidak Ya
Ukuran tambahan 0 KB 0 KB Puluhan KB

Kapan Fetch API lebih baik

Pakai Fetch kalau target browsermu sudah modern dan kamu ingin nol dependensi. Ini masuk akal pada proyek kecil, landing page, atau ketika yang kamu butuhkan hanya beberapa request ke endpoint milik sendiri. Fetch juga jadi pilihan alami saat bekerja di dalam Web Worker atau service worker, karena API-nya tersedia tanpa impor apa pun.

Kekurangan utama Fetch adalah minimnya fitur siap pakai. Untuk menambahkan timeout, kamu harus merangkai AbortController. Menangani token kedaluwarsa secara terpusat menuntut fungsi pembungkus buatan sendiri. Kalau beberapa kebutuhan itu muncul sekaligus, menulis lapisan tipis di atas Fetch bisa lebih ringan daripada memakai pustaka penuh.

Kapan XMLHttpRequest masih relevan

XMLHttpRequest tetap diperlukan saat kamu harus mendukung browser sangat lama yang tidak mengenal Fetch. Selain itu, kebutuhan menampilkan progres upload file besar masih lebih matang di XMLHttpRequest lewat event upload.onprogress. Beberapa pustaka unggah pihak ketiga juga masih mengandalkan API ini.

Untuk proyek baru, memilih XMLHttpRequest berarti menanggung lebih banyak kode callback dan pengecekan status manual. Kalau progres upload memang jadi syarat, pertimbangkan Axios yang membungkus XMLHttpRequest dengan antarmuka Promise, sehingga kamu mendapat progres tanpa menulis event handler sendiri.

Kapan Axios masuk hitungan

Axios cocok ketika aplikasi punya banyak endpoint dengan kebutuhan seragam: header autentikasi, base URL, timeout, dan penanganan error yang konsisten. Interceptor request dan response membuat logika itu cukup ditulis sekali. Kalau kamu membangun antarmuka yang rutin memanggil API dan menampilkan hasilnya ke halaman, pola ini menghemat banyak pengulangan; lihat juga panduan cara menampilkan data dari AJAX jQuery ke HTML untuk memahami alur request dan render data.

Di sisi backend, endpoint yang dipanggil harus mengembalikan struktur konsisten agar transformasi Axios tidak menyulitkan. Kalau kamu membangun API sendiri dengan PHP, panduan membuat REST API sederhana dengan PHP bisa jadi titik awal yang praktis.

Axios juga berguna pada proyek yang memakai kode yang sama di browser dan Node.js, karena konfigurasi request bisa dipakai ulang. Konsekuensinya, kamu menambah dependensi yang perlu diperbarui dan masuk hitungan ukuran bundle.

Kriteria memilih secara praktis

Susun keputusan berdasarkan empat pertanyaan berikut, dijawab berurutan.

  • Target browser: kalau masih ada pengguna browser lama, Fetch dan Axios modern bisa jadi masalah; XMLHttpRequest atau polyfill dibutuhkan.
  • Kebutuhan progres upload: unggah file besar mengarah ke XMLHttpRequest atau Axios.
  • Keseragaman penanganan: banyak endpoint dengan header dan error serupa lebih nyaman dengan interceptor Axios.
  • Bobot dependensi: proyek kecil atau halaman statis lebih hemat dengan Fetch tanpa pustaka.

Untuk tim yang baru mulai, Fetch sering jadi titik belajar yang baik karena memperlihatkan cara kerja HTTP secara langsung. Setelah kebutuhan meningkat, memindahkan pemanggilan ke pembungkus atau Axios tidak terlalu mahal kalau sejak awal kamu memisahkan logika request ke satu modul. Cara serupa juga berlaku saat memilih lapisan komunikasi ke database; perbandingan PDO vs MySQLi vs Query Builder memakai prinsip yang sama: pilih sesuai kendali dan kenyamanan yang dibutuhkan.

Catatan soal performa dan keamanan

Ketiganya memakai mekanisme jaringan yang sama di browser, jadi perbedaan kecepatan umumnya kecil dibandingkan faktor server dan ukuran payload. Yang lebih berpengaruh adalah jumlah request, cara caching, dan apakah response diproses berulang. Menambahkan Axios menambah beberapa kilobyte JavaScript yang harus diunduh, angka pastinya bergantung versi dan cara bundling.

Dari sisi keamanan, ketiganya tidak otomatis melindungi dari XSS atau CSRF. Data dari server tetap harus diperlakukan sebagai teks sampai kamu sengaja merendernya, dan token CSRF perlu dikirim pada request yang mengubah data. Pilihan pustaka tidak menghapus tanggung jawab itu. Kalau kamu bekerja dengan bahasa lain di sisi klien, memilih antara PHP, JavaScript, atau CSS untuk tugas web bisa membantu memetakan bagian mana yang sebaiknya ditangani server.

Ringkasan

Fetch API pilihan paling ringan untuk browser modern dan proyek tanpa dependensi tambahan. XMLHttpRequest tetap dipakai ketika kompatibilitas lama atau progres upload jadi syarat utama. Axios menghemat kode pada aplikasi dengan banyak endpoint dan kebutuhan konfigurasi seragam, dengan konsekuensi satu dependensi ekstra. Mulai dari kebutuhan nyata proyek, bukan dari popularitas pustaka.

Pertanyaan yang Sering Diajukan

Apakah Fetch API bisa menggantikan XMLHttpRequest sepenuhnya?

Untuk sebagian besar kebutuhan modern, ya. Namun pelaporan progres upload pada Fetch belum seragam di semua browser, jadi XMLHttpRequest atau pustaka yang membungkusnya masih relevan untuk unggah file besar.

Apakah Axios wajib kalau sudah memakai Fetch?

Tidak. Axios berguna ketika kamu butuh interceptor, timeout bawaan, dan penanganan error seragam di banyak endpoint. Kalau aplikasimu hanya punya sedikit request, pembungkus kecil di atas Fetch sudah cukup.

Mana yang paling aman untuk mengirim token autentikasi?

Ketiganya bisa mengirim header Authorization dengan cara yang setara. Yang menentukan keamanan adalah cara token disimpan, masa berlaku, dan apakah koneksi memakai HTTPS. Simpan token di tempat yang tidak bisa dibaca skrip pihak lain, dan kirim hanya lewat koneksi terenkripsi.