5 Ways to Make HTTP Requests in Node.js

Introduction

Node.js powers the backend of modern web applications, and at the heart of this capability lies HTTP communication. Whether you're integrating with payment processors, fetching data from third-party APIs, or orchestrating microservices, choosing the right HTTP client impacts your application's performance, maintainability, and scalability.

This guide explores five powerful approaches to making HTTP requests in Node.js, from the foundational native modules to the bleeding-edge performance of Undici. Understanding these options is essential for any developer working with JavaScript fundamentals and building production-ready applications.

Native http and https Modules: The Foundation

The built-in http and https modules form the bedrock of HTTP communication in Node.js. These modules provide low-level access without requiring any external dependencies, making them ideal for minimal environments or performance-critical applications.

Why Use Native Modules

• Zero dependencies -- one less package to install and update
• Complete control over headers, timeouts, and streaming
• Native stream integration for efficient large file handling
• Minimal memory footprint for serverless and constrained environments

Axios: The Developer-Friendly Powerhouse

Axios has established itself as the de facto standard for HTTP requests in Node.js, combining a promise-based API with a rich feature set that simplifies common tasks.

Why Developers Choose Axios

• Automatic JSON transformation -- no more repetitive .then(response => response.json())
• Request and response interceptors for global modifications
• Configurable timeouts to prevent hanging requests
• Cancelable requests via AbortController
• Identical API in Node.js and browsers

node-fetch: The Familiar Fetch API

The Fetch API represents the modern standard for HTTP requests in web browsers, and node-fetch brings this familiar interface to Node.js environments. For developers transitioning from frontend work, this library provides consistency across environments and works seamlessly with React components for isomorphic applications.

Key Advantages of node-fetch

• Matches browser Fetch API -- seamless isomorphic development
• Lightweight (~4KB) -- minimal dependency footprint
• Full streams support for efficient large file handling
• WHATWG Fetch specification compliance for predictable behavior
• ESM native support in version 3+

Got: The Human-Friendly HTTP Client

Got distinguishes itself as a feature-rich, developer-friendly HTTP request library designed specifically for Node.js.

Standout Features of Got

• Human-readable error messages for easier debugging
• Automatic retry with exponential backoff for transient failures
• Request pagination support for paginated APIs
• Built-in cache support to reduce unnecessary network calls
• Progress reporting for uploads and downloads
• Extensive hooks system for deep customization

Undici: The High-Performance Contender

Undici (Italian for "eleven") represents the future of HTTP clients in Node.js, developed by the Node.js core team with a focus on performance, correctness, and standards compliance.

Performance Advantages of Undici

According to DEV Community benchmarks, Undici achieves approximately 18,000 requests per second compared to 3,200 for the native http module, with p99 latency dropping from 450ms to 85ms. Memory usage decreases significantly under load.

These improvements come from smarter connection pooling, zero-copy optimization, and proper HTTP/1.1 pipelining support. For high-performance Node.js applications, Undici offers the fastest HTTP client available.

Best Practices Across All Methods

Regardless of which HTTP client you choose, these practices improve reliability and maintainability:

1. Always handle errors -- network failures are inevitable
2. Set timeouts -- prevent hanging requests
3. Validate responses -- check status codes and content
4. Use connection pooling for multiple requests to the same host
5. Implement retry logic for transient failures
6. Monitor request metrics in production
7. Respect rate limits of external APIs

// Generic error handling pattern
async function safeRequest(requestFn) {
 try {
 const response = await requestFn();
 if (response.status >= 400) {
 throw new Error(`HTTP ${response.status}`);
 }
 return response.data;
 } catch (error) {
 if (error.code === 'ENOTFOUND') {
 // DNS resolution failure
 } else if (error.code === 'ECONNRESET') {
 // Connection reset by peer
 }
 throw error;
 }
}

Conclusion

Mastering HTTP request methods in Node.js is fundamental to building robust applications:

• Use native modules when you need absolute control and zero dependencies
• Choose Axios for enterprise applications requiring rich features
• Pick node-fetch when you want the familiar Fetch API
• Select Got for production systems needing reliability
• Adopt Undici for maximum performance in modern Node.js applications

The best Node.js developers don't just know one method -- they understand when and why to use each. Start with the one that suits your project's immediate needs, then expand your expertise over time.

Building API integrations and microservices effectively requires understanding these HTTP clients. Our custom web development services help teams architect scalable, performant solutions that leverage the right tools for each use case.

Sources

1. Carmatec: 5 Node.js HTTP Request Methods Every Developer Should Master
2. LogRocket: Axios vs Fetch (2025 update)
3. DEV Community: Why undici is Faster Than Node.js's Core http Module