got vs request vs axios vs node-fetch
HTTP Client Libraries for Node.js and Frontend
Search packages..
gotrequestaxiosnode-fetchSimilar Packages:

HTTP Client Libraries for Node.js and Frontend

axios, got, node-fetch, and request are tools for making HTTP requests in JavaScript. axios works in both browsers and Node.js. got and node-fetch are built for Node.js environments. request is an older library that is no longer maintained. These tools help developers connect their applications to APIs, download files, and send data to servers.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
got42,182,36614,953488 kB03 days agoMIT
request12,479,40925,489-1447 years agoApache-2.0
axios0109,3011.98 MB992 months agoMIT
node-fetch08,848107 kB2493 years agoMIT

Axios vs Got vs Node-Fetch vs Request: HTTP Clients Compared

Making HTTP requests is a daily task for JavaScript developers. Whether you are fetching data for a website or calling a microservice on the server, you need a reliable tool. axios, got, node-fetch, and request have all been popular choices, but they serve different needs today. Let's compare how they handle real-world tasks.

⚠️ Maintenance Status: Safe vs Deprecated

Before writing any code, you must know which tools are safe to use. This is the most critical difference in this group.

request is officially deprecated.

  • The maintainers stopped working on it in 2020.
  • It will not receive security fixes or bug updates.
  • Using it puts your project at risk.
// request: DEPRECATED - Do not use in new projects
const request = require('request');
// This library is no longer maintained

axios, got, and node-fetch are actively maintained.

  • They receive regular updates for security and features.
  • They support modern JavaScript standards like Promises and async/await.
  • Safe for production use today.
// axios, got, node-fetch: Actively maintained
import axios from 'axios';
import got from 'got';
import fetch from 'node-fetch';
// All safe for current development

🌍 Environment Support: Browser vs Node.js

Where your code runs matters. Some tools work everywhere, while others are built specifically for the server.

axios works in both browsers and Node.js.

  • You can use the same code on the frontend and backend.
  • Great for universal apps or shared utility libraries.
// axios: Works everywhere
import axios from 'axios';
// Runs in Chrome, Firefox, Node.js, etc.
const response = await axios.get('/api/data');

got is for Node.js only.

  • It uses Node-specific features like streams.
  • It will not work if you try to bundle it for the browser.
// got: Node.js only
import got from 'got';
// Will fail if bundled for browser
const response = await got.get('/api/data');

node-fetch is for Node.js only.

  • It brings the browser fetch API to the server.
  • Modern Node.js (v18+) now has fetch built-in, reducing the need for this package.
// node-fetch: Node.js only
import fetch from 'node-fetch';
// Modern Node has global fetch built-in
const response = await fetch('/api/data');

request was for Node.js only.

  • It was never designed to run in the browser.
  • Another reason to avoid it for modern full-stack projects.
// request: Node.js only (Legacy)
const request = require('request');
// Cannot be used in browser environments

πŸ“₯ Making a Basic GET Request

How much code do you need to fetch simple data? Syntax clarity impacts daily development speed.

axios returns the data directly in a data property.

  • It automatically parses JSON for you.
  • The response object wraps the actual content.
// axios: Auto JSON parse
const response = await axios.get('/api/users');
console.log(response.data); // The actual JSON content

got also returns the body directly by default.

  • It behaves similarly to axios for simple cases.
  • Very concise for standard API calls.
// got: Auto JSON parse
const response = await got.get('/api/users');
console.log(response.body); // The actual JSON content

node-fetch returns a Response object.

  • You must manually call .json() to parse the data.
  • This matches the browser standard exactly.
// node-fetch: Manual JSON parse
const response = await fetch('/api/users');
const data = await response.json(); // Must parse manually
console.log(data);

request uses callbacks instead of Promises.

  • This leads to nested code or requires extra wrappers.
  • Much harder to read than modern async/await syntax.
// request: Callback based (Legacy)
request('/api/users', (error, response, body) => {
  const data = JSON.parse(body); // Manual parse
  console.log(data);
});

🚨 Error Handling: Automatic vs Manual

What happens when the server returns a 404 or 500 error? Some tools throw errors for you, while others make you check manually.

axios throws an error for bad status codes.

  • You can wrap calls in try/catch blocks.
  • You do not need to check status codes manually.
// axios: Throws on 4xx/5xx
try {
  await axios.get('/api/broken');
} catch (error) {
  console.log('Request failed automatically');
}

got also throws an error for bad status codes.

  • Similar behavior to axios.
  • Makes error handling consistent and predictable.
// got: Throws on 4xx/5xx
try {
  await got.get('/api/broken');
} catch (error) {
  console.log('Request failed automatically');
}

node-fetch does NOT throw on bad status codes.

  • You must check response.ok yourself.
  • Easy to forget, which can hide bugs in production.
// node-fetch: Does NOT throw on HTTP error
const response = await fetch('/api/broken');
if (!response.ok) {
  throw new Error('Request failed'); // Must check manually
}

request passes errors to the callback.

  • You have to check the error argument first.
  • Mixing network errors with HTTP errors can be confusing.
// request: Callback error handling
request('/api/broken', (error, response, body) => {
  if (error) {
    console.log('Network error'); // Check error arg
  }
});

πŸ”„ Advanced Features: Interceptors and Hooks

Large applications often need to modify requests or responses globally. This is useful for adding auth tokens or logging.

axios has built-in interceptors.

  • You can run code before every request or after every response.
  • Very popular for adding authentication headers automatically.
// axios: Interceptors
axios.interceptors.request.use(config => {
  config.headers.Authorization = 'Bearer token';
  return config;
});

got uses hooks for similar functionality.

  • Hooks allow you to modify options or handle responses.
  • Powerful and flexible for backend services.
// got: Hooks
const client = got.extend({
  hooks: {
    beforeRequest: [
      options => {
        options.headers.authorization = 'Bearer token';
      }
    ]
  }
});

node-fetch has no built-in interceptor system.

  • You must create your own wrapper function.
  • Requires extra code to achieve the same result.
// node-fetch: Manual wrapper
async function fetchWithAuth(url) {
  return fetch(url, {
    headers: { Authorization: 'Bearer token' }
  });
}

request used plugins and jars.

  • This approach is outdated compared to modern interceptors.
  • Another reason why it feels old compared to new tools.
// request: Plugins (Legacy)
// Required external libraries for complex logic
// No native interceptor concept like axios

πŸ“Š Summary: Key Differences

Featureaxiosgotnode-fetchrequest
Statusβœ… Activeβœ… Activeβœ… Active❌ Deprecated
Environment🌐 Browser + NodeπŸ–₯️ Node OnlyπŸ–₯️ Node OnlyπŸ–₯️ Node Only
Promise Basedβœ… Yesβœ… Yesβœ… Yes❌ Callbacks
Auto JSONβœ… Yesβœ… Yes❌ Manual❌ Manual
Error Handlingβœ… Throwsβœ… Throws❌ Check .ok⚠️ Callback
Interceptorsβœ… Built-inβœ… Hooks❌ Manual❌ Plugins

πŸ’‘ The Big Picture

axios is the safe bet for full-stack teams 🧰. It works everywhere and handles common tasks automatically. Choose it if you want to write less code and share logic between frontend and backend.

got is the power tool for Node.js backends πŸ”§. It offers the best performance and features for server-side scripts. Choose it if you are building microservices or CLI tools.

node-fetch is the lightweight standard πŸͺΆ. It mimics the browser API perfectly. Choose it if you want minimal dependencies and your team already knows the fetch API.

request is history πŸ›‘. It is deprecated and should not be used. If you see it in an old project, plan to replace it soon.

Final Thought: For most new projects, start with axios for versatility or got for pure Node.js power. Avoid request entirely, and consider using native fetch if you are on Node.js 18 or higher.

How to Choose: got vs request vs axios vs node-fetch

  • got:

    Choose got if you are building backend services in Node.js. It offers the best developer experience for server-side code with strong stream support. It is not suitable for browser applications.

  • request:

    Do not choose this package. It is deprecated and no longer receives security updates. You should migrate existing projects to axios, got, or native fetch.

  • axios:

    Choose axios if you need one library for both browser and server code. It handles JSON automatically and has built-in request interceptors. Good for teams wanting consistency across platforms without switching tools.

  • node-fetch:

    Choose node-fetch if you want a lightweight API that matches the browser fetch standard. It is ideal for simple Node.js scripts where you do not need advanced features like automatic JSON parsing.

Similar Npm Packages to got

got is a popular HTTP request library for Node.js, designed to simplify the process of making HTTP requests while providing a rich set of features. It supports promises and async/await syntax, making it easy to work with asynchronous code. got is known for its performance, ease of use, and built-in support for advanced features like retries, timeouts, and streaming. It is an excellent choice for developers looking to make HTTP requests in a Node.js environment.

While got is a powerful option, there are several alternatives available that also provide robust HTTP request capabilities. Here are a few notable ones:

  • axios is a widely-used promise-based HTTP client for both the browser and Node.js. It offers a simple API and supports features such as interceptors, request cancellation, and automatic JSON data transformation. axios is particularly popular for frontend applications but can also be used effectively in server-side code. If you need a versatile HTTP client that works seamlessly in both environments, axios is a great choice.

  • node-fetch is a lightweight module that brings the fetch API to Node.js. It is designed to be a minimalistic and straightforward implementation of the fetch API, making it easy for developers familiar with the browser's fetch to make HTTP requests in a Node.js environment. If you prefer a simple and native-like API for making requests, node-fetch is an excellent alternative.

  • request was once a popular HTTP request library for Node.js, known for its simplicity and ease of use. However, it has been deprecated in favor of more modern alternatives like got and axios. While it is still available, it is recommended to use more actively maintained libraries for new projects.

To see how got compares with axios, node-fetch, and request, check out the comparison: Comparing axios vs got vs node-fetch vs request.

Similar Npm Packages to request

request is a popular HTTP client library for Node.js that simplifies making HTTP requests. It provides a straightforward API for sending requests and handling responses, making it a go-to choice for many developers. However, as the JavaScript ecosystem evolves, several alternatives have emerged that offer similar or enhanced functionality. Here are a few notable alternatives:

  • axios is a promise-based HTTP client for both the browser and Node.js. It has gained popularity due to its ease of use and powerful features, such as interceptors, automatic JSON data transformation, and the ability to cancel requests. Axios is particularly well-suited for applications that require a robust and flexible HTTP client, making it a great alternative to request for modern web development.

  • got is a lightweight and powerful HTTP request library for Node.js. It is designed to be simple and efficient, providing a rich set of features such as retries, timeouts, and streaming support. Got is particularly well-suited for applications that require high performance and flexibility in handling HTTP requests, making it a strong contender against request.

  • node-fetch is a lightweight module that brings window.fetch to Node.js, allowing developers to use the Fetch API in their server-side applications. It is designed to be simple and minimalistic, making it a great choice for those who prefer the Fetch API's syntax and behavior. Node-fetch is an excellent alternative for developers looking for a modern and straightforward way to make HTTP requests in Node.js.

To see how request compares with axios, got, and node-fetch, check out the comparison: Comparing axios vs got vs node-fetch vs request.

Similar Npm Packages to axios

axios is a popular promise-based HTTP client for both the browser and Node.js. It simplifies making HTTP requests and handling responses, providing a clean and intuitive API. Axios supports features such as request and response interception, automatic JSON data transformation, and the ability to cancel requests. It is widely used in web applications for interacting with RESTful APIs and is known for its ease of use and flexibility. However, there are several alternatives to axios that developers may consider based on their specific needs:

  • node-fetch is a lightweight module that brings window.fetch to Node.js. It is a simple and minimalistic implementation of the Fetch API, allowing developers to make HTTP requests using a familiar API. Node-fetch is particularly useful for server-side applications or when working with APIs in a Node.js environment. It supports promises and is a great choice for those who prefer the Fetch API's syntax and behavior over traditional XMLHttpRequest or other libraries.
  • request was once one of the most popular HTTP request libraries for Node.js. It provided a simple and flexible API for making HTTP requests and handling responses. However, it has been deprecated and is no longer actively maintained. While it may still be found in legacy projects, developers are encouraged to use more modern alternatives like axios or node-fetch for new applications.
  • superagent is another powerful HTTP request library for Node.js and browsers. It offers a flexible and expressive API for making HTTP requests, supporting features like chaining, automatic content type handling, and file uploads. Superagent is particularly useful for developers who need a more feature-rich alternative to axios or want to work with a library that provides a more expressive syntax.

For a comprehensive comparison of these libraries, check out the following link: Comparing axios vs node-fetch vs request vs superagent.

Similar Npm Packages to node-fetch

node-fetch is a lightweight module that brings window.fetch to Node.js, allowing developers to make HTTP requests in a simple and familiar way. It is particularly useful for server-side applications that need to interact with APIs or fetch resources over the network. While node-fetch is a popular choice for making HTTP requests in Node.js, there are several alternatives that also provide robust solutions. Here are a few noteworthy alternatives:

  • axios is a widely-used promise-based HTTP client for both the browser and Node.js. It offers a rich feature set, including automatic JSON data transformation, request and response interceptors, and the ability to cancel requests. Axios is known for its simplicity and ease of use, making it a go-to choice for many developers when it comes to making HTTP requests. If you need a powerful and flexible HTTP client that works seamlessly in both environments, axios is an excellent option.
  • got is another popular HTTP request library for Node.js that focuses on simplicity and performance. It provides a rich set of features, including retries, timeouts, and streaming support. Got is designed to be a more modern and user-friendly alternative to the built-in http module in Node.js, making it a great choice for developers who want a straightforward and efficient way to handle HTTP requests. If you are building a Node.js application and need a feature-rich HTTP client, got is worth considering.
  • isomorphic-fetch is a library that provides a universal fetch API for both the browser and Node.js. It is built on top of the native fetch API and aims to provide a consistent interface across different environments. This makes it a suitable choice for applications that need to run both on the server and the client without changing the code for making HTTP requests. If you are looking for a solution that works seamlessly in both environments, isomorphic-fetch can be a good fit.

To see how node-fetch compares with axios, got, and isomorphic-fetch, check out the comparison: Comparing axios vs got vs isomorphic-fetch vs node-fetch.

README for got



Got



Sindre's open source work is supported by the community.
Special thanks to:



Fame Helsinki Fame Helsinki



Depot logo
Fast remote container builds and GitHub Actions runners.









Human-friendly and powerful HTTP request library for Node.js

Downloads Install size

See how Got compares to other HTTP libraries

You probably want Ky instead, by the same people. It's smaller, works in the browser too, and is more stable since it's built on Fetch. Or fetch-extras for simple needs.

Support questions should be asked here.

Install

npm install got

Warning: This package is native ESM and no longer provides a CommonJS export. If your project uses CommonJS, you will have to convert to ESM. Please don't open issues for questions regarding CommonJS / ESM.

Got v11 is no longer maintained and we will not accept any backport requests.

Take a peek

A quick start guide is available.

JSON mode

Got has a dedicated option for handling JSON payload.
Furthermore, the promise exposes a .json<T>() function that returns Promise<T>.

import got from 'got';

const {data} = await got.post('https://httpbin.org/anything', {
	json: {
		hello: 'world'
	}
}).json();

console.log(data);
//=> {"hello": "world"}

For advanced JSON usage, check out the parseJson and stringifyJson options.

For more useful tips like this, visit the Tips page.

Highlights

Documentation

By default, Got will retry on failure. To disable this option, set options.retry.limit to 0.

Main API

Timeouts and retries

Advanced creation

Cache, Proxy and UNIX sockets

Integration

Migration guides

Got plugins

  • got4aws - Got convenience wrapper to interact with AWS v4 signed APIs
  • gh-got - Got convenience wrapper to interact with the GitHub API
  • gl-got - Got convenience wrapper to interact with the GitLab API
  • gotql - Got convenience wrapper to interact with GraphQL using JSON-parsed queries instead of strings
  • got-fetch - Got with a fetch interface
  • got-scraping - Got wrapper specifically designed for web scraping purposes
  • got-ssrf - Got wrapper to protect server-side requests against SSRF attacks

Comparison

gotnode-fetchkyaxiossuperagent
HTTP/2 support:heavy_check_mark::x::heavy_check_mark::x::heavy_check_mark:**
Browser support:x::heavy_check_mark:*:heavy_check_mark::heavy_check_mark::heavy_check_mark:
Promise API:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:
Stream API:heavy_check_mark:Node.js only:x::x::heavy_check_mark:
Pagination API:heavy_check_mark::x::x::x::x:
Request aborting:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:
RFC 7234 caching:heavy_check_mark::x::x::x::x:
Cookies (out-of-the-box):heavy_check_mark::x::x::x::x:
Follows redirects:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:
Retries on failure:heavy_check_mark::x::heavy_check_mark::x::heavy_check_mark:
Progress events:heavy_check_mark::x::heavy_check_mark:Browser only:heavy_check_mark:
Handles gzip/deflate:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:
Advanced timeouts:heavy_check_mark::x::x::x::x:
Timings:heavy_check_mark::x::x::x::x:
Errors with metadata:heavy_check_mark::x::heavy_check_mark::heavy_check_mark::x:
JSON mode:heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark::heavy_check_mark:
Custom defaults:heavy_check_mark::x::heavy_check_mark::heavy_check_mark::x:
Composable:heavy_check_mark::x::x::x::heavy_check_mark:
Hooks:heavy_check_mark::x::heavy_check_mark::heavy_check_mark::x:
Issues open
Issues closed
Downloads
CoverageTBD
Build
Bugs
Dependents
Install size
GitHub stars
TypeScript support
Last commit

* It's almost API compatible with the browser fetch API.
** Need to switch the protocol manually. Doesn't accept PUSH streams and doesn't reuse HTTP/2 sessions.
:sparkle: Almost-stable feature, but the API may change. Don't hesitate to try it out!
:grey_question: Feature in early stage of development. Very experimental.

Click here to see the install size of the Got dependencies.

Maintainers

Sindre SorhusSzymon Marczak
Sindre SorhusSzymon Marczak
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.