What Axios Still Gives You Over Fetch

The Fetch API has matured significantly. It’s built into every modern browser, available natively in Node.js since v18 via Undici, and capable of handling JSON, request cancellation, and streaming. For many frontend API requests, it’s genuinely enough.

So why do teams still reach for Axios? Not out of habit, but because Axios still solves specific developer experience problems that Fetch leaves to you. Here’s where that gap actually shows up.

Axios vs Fetch: Where the Real Differences Are

1. HTTP Error Handling That Works by Default

Fetch only rejects on network failure. A 404 or 500 response resolves successfully — you have to check response.ok yourself every time.

// Fetch — you must check manually
const res = await fetch('/api/user');
if (!res.ok) throw new Error(`HTTP error: ${res.status}`);
const data = await res.json();

// Axios — rejects automatically on 4xx/5xx by default
const { data } = await axios.get('/api/user');

In large applications with dozens of endpoints, that manual check becomes repetitive boilerplate. Axios removes most of it by default.

2. Built-In Request and Response Interceptors

This is the feature most developers cite when choosing Axios. Interceptors let you attach logic — auth tokens, logging, error normalization — once, globally, without touching individual requests.

axios.interceptors.request.use(config => {
  config.headers.Authorization = `Bearer ${getToken()}`;
  return config;
});

axios.interceptors.response.use(
  response => response,
  error => {
    if (error.response?.status === 401) redirectToLogin();
    return Promise.reject(error);
  }
);

With Fetch, you can simulate this by wrapping fetch() in a custom function. But that wrapper isn’t composable, isn’t stackable, and you’re maintaining it yourself.

3. Shared Configuration with Axios Instances

Axios lets you create isolated instances with preset base URLs, headers, and timeouts — a pattern that’s genuinely useful when your app talks to multiple APIs.

const apiClient = axios.create({
  baseURL: 'https://api.example.com',
  timeout: 8000,
  headers: { 'X-App-Version': '2.1.0' },
});

Replicating this cleanly with Fetch requires a wrapper class or factory function. Doable, but it’s scope you’re taking on.

4. Upload Progress Tracking

Fetch still has no standardized native upload progress API in browsers. Axios exposes onUploadProgress directly, backed by XMLHttpRequest under the hood in browsers.

await axios.post('/upload', formData, {
  onUploadProgress: e => {
    if (e.total) {
      console.log(`${Math.round((e.loaded / e.total) * 100)}%`);
    }
  },
});

If you need upload progress in a Fetch-only setup, you’re back to raw XMLHttpRequest. That’s a real regression.

5. Timeout Configuration Without AbortController Boilerplate

Axios accepts a timeout option directly. Fetch requires you to wire up AbortController and setTimeout manually — which works, but adds noise.

// Axios
await axios.get('/api/data', { timeout: 5000 });

// Fetch equivalent
const controller = new AbortController();
const id = setTimeout(() => controller.abort(), 5000);
try {
  const res = await fetch('/api/data', { signal: controller.signal });
} finally {
  clearTimeout(id);
}

Modern environments also support AbortSignal.timeout(), which shortens this considerably, and browser support is now broadly available.

Quick Comparison: Axios Features vs Fetch API

Conclusion

Fetch is not inadequate. For simple JavaScript HTTP clients — a few endpoints, no shared auth logic, no upload progress — it’s the right default. No dependency, no overhead.

But Axios earns its place when your frontend API requests grow in complexity. Interceptors, shared instances, automatic error handling, and upload progress aren’t features you’ll miss until you need them — and then you’ll want them built in, not hand-rolled. That’s what Axios still gives you.

FAQs

Complete picture for complete understanding

Capture every clue your frontend is leaving so you can instantly get to the root cause of any issue with OpenReplay — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data.

Check our GitHub repo and join the thousands of developers in our community.