Choosing the Right HTTP Client: axios vs got vs node-fetch vs @hyper-fetch/core

Making HTTP requests is a daily task for JavaScript developers, but the tool you choose shapes your code's readability, error handling, and deployment strategy. While fetch is now native in modern Node.js and browsers, the ecosystem offers specialized tools like axios, got, node-fetch, and @hyper-fetch/core to solve specific pain points. Let's break down how they differ in real-world scenarios.

🌍 Environment Support: Universal vs Node-Only vs Standard

The first decision is where your code runs. Some libraries bridge the gap between browser and server, while others double down on server-specific features.

axios is universal. It uses XMLHttpRequest in the browser and the native http module in Node.js, giving you the same API everywhere.

// axios: Works in Browser and Node.js
import axios from 'axios';

const response = await axios.get('/api/users');
console.log(response.data); // Automatically parsed JSON

got is strictly for Node.js. It leverages Node-specific streams and events, making it impossible to use directly in the browser.

// got: Node.js only
import got from 'got';

const response = await got.get('https://api.example.com/users');
console.log(response.body); // Automatically parsed JSON

node-fetch brings the browser fetch API to older Node.js versions (pre-18). It mimics the standard web API exactly.

// node-fetch: Node.js implementation of Web Standard
import fetch from 'node-fetch';

const response = await fetch('https://api.example.com/users');
const data = await response.json(); // Manual JSON parsing

@hyper-fetch/core wraps the native fetch (or node-fetch) to add structure. It assumes you are comfortable with the standard fetch API but need help managing it at scale.

// @hyper-fetch/core: Enhances native fetch
import { createFetcher } from '@hyper-fetch/core';

const fetcher = createFetcher({ baseURL: 'https://api.example.com' });
const response = await fetcher.get('/users');
const data = await response.json(); // Follows standard fetch response

📦 Data Handling: Automatic vs Manual Parsing

How much work do you want to do to get your data? Some libraries guess what you want; others make you explicit.

axios automatically transforms JSON responses. You access data via the .data property. This saves lines of code but can sometimes hide network errors if the content type is wrong.

// axios: Auto-parsing
try {
  const res = await axios.post('/login', { user: 'alice' });
  console.log(res.data.token); // Direct access
} catch (error) {
  console.error(error.response.status);
}

got also auto-parses JSON by default but gives you more control over the raw body if needed. It returns a unified response object.

// got: Auto-parsing with options
try {
  const res = await got.post('https://api.example.com/login', {
    json: { user: 'alice' } // Auto-serializes body
  });
  console.log(res.body.token);
} catch (error) {
  console.error(error.response.statusCode);
}

node-fetch and @hyper-fetch/core follow the standard: you must manually call .json() on the response. This is more verbose but makes the data flow explicit and predictable.

// node-fetch: Manual parsing
const res = await fetch('https://api.example.com/login', {
  method: 'POST',
  body: JSON.stringify({ user: 'alice' }),
  headers: { 'Content-Type': 'application/json' }
});
const data = await res.json(); // Explicit step
console.log(data.token);

// @hyper-fetch/core: Manual parsing (Standard compliant)
const res = await fetcher.post('/login', { 
  body: { user: 'alice' } // Helper handles headers/serialization
});
const data = await res.json(); // Explicit step
console.log(data.token);

🛡️ Error Handling and Retries

Networks are unreliable. How a library handles failures determines how much boilerplate you write in your app.

axios throws errors for 4xx and 5xx status codes automatically. You catch them in a standard try/catch block, but implementing retries requires external plugins or custom interceptors.

// axios: Throws on HTTP errors
try {
  await axios.get('/unstable-endpoint');
} catch (err) {
  if (err.response) {
    // Handle server error
    console.log(`Status: ${err.response.status}`);
  }
}

got shines here. It has built-in retry logic with exponential backoff and detailed error classes that tell you exactly what went wrong (timeout, DNS error, HTTP error).

// got: Built-in retries
try {
  const res = await got.get('https://unstable-api.com/data', {
    retry: {
      limit: 3,
      methods: ['GET']
    }
  });
} catch (err) {
  // err.code tells you specifically why it failed
  console.log(`Failed after retries: ${err.code}`);
}

node-fetch does NOT throw on HTTP errors (like 404). It only throws on network failures. You must manually check res.ok.

// node-fetch: Manual error checking
const res = await fetch('https://api.example.com/missing');
if (!res.ok) {
  throw new Error(`HTTP error! status: ${res.status}`);
}

@hyper-fetch/core is designed to solve the node-fetch verbosity problem. It allows you to define global strategies for errors and retries, wrapping the standard API to enforce rules across your whole app.

// @hyper-fetch/core: Centralized error/retry strategy
const fetcher = createFetcher({
  strategies: {
    retry: { attempts: 3, delay: 1000 },
    errors: { throwOn: [400, 500] } // Force throw on specific codes
  }
});

// Now behaves more like axios/got regarding errors
await fetcher.get('/unstable-endpoint'); 

⚙️ Advanced Configuration: Interceptors vs Hooks

Large apps often need to modify requests (add auth tokens) or responses (log data) globally.

axios uses interceptors. They are powerful and easy to set up for things like attaching JWT tokens.

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

got uses hooks. These are granular and run at specific stages of the request lifecycle (before request, before redirect, after response).

// got: Hooks
const client = got.extend({
  hooks: {
    beforeRequest: [
      options => {
        options.headers.authorization = `Bearer ${getToken()}`;
      }
    ]
  }
});

node-fetch has no built-in interceptor system. You typically wrap fetch in your own helper function, which can lead to inconsistent implementations across a team.

// node-fetch: Manual wrapper pattern
async function authFetch(url, options = {}) {
  const token = getToken();
  return fetch(url, {
    ...options,
    headers: { ...options.headers, Authorization: `Bearer ${token}` }
  });
}

@hyper-fetch/core provides a formalized system for this. It lets you define "strategies" that act like interceptors but are typed and enforced, preventing the "wild west" of custom wrappers.

// @hyper-fetch/core: Strategy-based configuration
const fetcher = createFetcher({
  strategies: {
    request: [
      (req) => {
        req.headers.set('Authorization', `Bearer ${getToken()}`);
        return req;
      }
    ]
  }
});

🚫 Deprecation and Maintenance Status

It is critical to note the current status of these packages before starting a new project.

• node-fetch: While still widely used, note that Node.js 18+ includes a global native fetch. For new projects targeting modern Node versions, you likely do not need to install node-fetch anymore unless you need specific polyfill behavior for older environments. The package itself is in maintenance mode.
• axios, got, and @hyper-fetch/core are actively maintained and safe for new projects.

📊 Summary: Key Differences

💡 The Big Picture

axios remains the safe, universal choice. If you need one library to rule both client and server, or if your team relies on its automatic JSON handling and mature interceptor system, it is still a solid pick. It removes friction for standard CRUD apps.

got is the power user's choice for Node.js. If you are building backend services, CLI tools, or serverless functions, got offers a superior developer experience with better error messages, built-in retries, and a cleaner API than axios. Do not use it in the browser.

node-fetch (or the native fetch in Node 18+) is for purists. If you want to write code that looks exactly like browser code and keep dependencies minimal, this is the way. Be prepared to write more boilerplate for error handling and retries.

@hyper-fetch/core is the architect's choice for scaling fetch. If you love the standard fetch API but hate repeating error handling, retry logic, and header management across hundreds of files, this library provides the guardrails you need. It turns fetch from a simple tool into an enterprise-grade solution without abandoning web standards.

Final Thought: For modern greenfield projects, the trend is shifting toward native fetch (enhanced by tools like @hyper-fetch/core if needed) for frontend and got for backend. axios remains relevant for universal codebases, but understanding its abstraction cost is key.