Make HTTP Requests in Node.js: 5 Essential Methods

Mastering HTTP Requests in Node.js: A Comprehensive Guide

When it comes to building robust and efficient applications, making HTTP requests is a crucial aspect of Node.js development. With multiple ways to achieve this, it can be overwhelming to choose the right approach. In this article, we’ll delve into the world of HTTP requests in Node.js, exploring the native HTTPS module, Fetch API, and popular npm packages like Axios, Got, superagent, and node-fetch.

Prerequisites

Before we begin, make sure you have:

• Node.js installed on your machine (as a Docker container or locally)
• Familiarity with npm commands like npm init and npm install <module-name>
• Knowledge of JavaScript callbacks, promises, and async/await
• The example RESTful API we’ll be using is the JSONPlaceholder API, which returns data for 10 users

Native Node.js HTTP(S) Module

Node.js comes with built-in HTTP and HTTPS modules, allowing you to make requests without additional dependencies. Let’s create a GET request to the JSONPlaceholder API using the HTTPS module:

“`javascript
const https = require(‘https’);

https.get(‘https://jsonplaceholder.typicode.com/users’, (res) => {
let data = ”;
res.on(‘data’, (chunk) => {
data += chunk;
});
res.on(‘end’, () => {
const users = JSON.parse(data);
users.forEach((user) => {
console.log(User ID: ${user.id}, Name: ${user.name});
});
});
}).on(‘error’, (err) => {
console.error(err);
});
“`

Built-in Fetch API

Introduced in Node.js v16.15.0, the Fetch API offers a browser-compatible implementation for making HTTP requests. This native API eliminates the need for additional dependencies, minimizing security concerns and bundle size issues.

javascript
fetch('https://jsonplaceholder.typicode.com/users')
.then((res) => res.json())
.then((users) => {
users.forEach((user) => {
console.log(`User ID: ${user.id}, Name: ${user.name}`);
});
})
.catch((err) => {
console.error(err);
});


Axios

Axios is a popular promise-based request library for Node.js, offering features like request and response data interception and automatic JSON transformation.

“`javascript
const axios = require(‘axios’);

axios.get(‘https://jsonplaceholder.typicode.com/users’)
.then((res) => {
const users = res.data;
users.forEach((user) => {
console.log(User ID: ${user.id}, Name: ${user.name});
});
})
.catch((err) => {
console.error(err);
});
“`

Got

Got is another feature-rich HTTP request library for Node.js, providing a promise-based API and HTTP/2 support.

“`javascript
const got = require(‘got’);

got(‘https://jsonplaceholder.typicode.com/users’, { responseType: ‘json’ })
.then((res) => {
const users = res.body;
users.forEach((user) => {
console.log(User ID: ${user.id}, Name: ${user.name});
});
})
.catch((err) => {
console.error(err);
});
“`

superagent

superagent is a mature and battle-tested HTTP request library for Node.js, offering both callback- and promise-based APIs.

“`javascript
const superagent = require(‘superagent’);

superagent.get(‘https://jsonplaceholder.typicode.com/users’)
.then((res) => {
const users = res.body;
users.forEach((user) => {
console.log(User ID: ${user.id}, Name: ${user.name});
});
})
.catch((err) => {
console.error(err);
});
“`

node-fetch

node-fetch is a lightweight module that brings the Fetch API to Node.js, offering consistency with the browser-based window.fetch.

“`javascript
const fetch = require(‘node-fetch’);

fetch(‘https://jsonplaceholder.typicode.com/users’)
.then((res) => res.json())
.then((users) => {
users.forEach((user) => {
console.log(User ID: ${user.id}, Name: ${user.name});
});
})
.catch((err) => {
console.error(err);
});
“`

Comparison of Node HTTP Request Methods

When choosing an HTTP request library, consider factors like popularity, install size, and features. Here’s a brief overview of the libraries we’ve explored:

| Library | Weekly Downloads | Install Size | Features |
| — | — | — | — |
| Axios | 11.42M | 4.45MB | Promise-based, request/response data interception, automatic JSON transformation |
| Got | 3.53M | 2.45MB | Promise-based, HTTP/2 support, pagination API |
| superagent | 2.35M | 3.21MB | Callback- and promise-based, mature and battle-tested |
| node-fetch | 50.12M | 7.45MB | Lightweight, consistent with browser-based window.fetch |

Implementing HTTP Services with Express.js

Express.js is a fast, minimal, and feature-rich Node.js framework for creating HTTP servers. Here’s an example of creating an Express instance and listening for HTTP connections:

“`javascript
const express = require(‘express’);
const app = express();

app.listen(3000, () => {
console.log(‘Server listening on port 3000’);
});
“`

Handling Node HTTPS POST Requests

When handling POST requests in a Node.js server, you’ll need to parse the request body, validate and sanitize the data, and possibly send back a response. Here’s an example using Express.js and the built-in express.urlencoded() middleware:

“`javascript
const express = require(‘express’);
const app = express();

app.use(express.urlencoded({ extended: true }));

app.post(‘/’, (req, res) => {
const { name, email } = req.body;
console.log(Name: ${name}, Email: ${email});
res.send(‘Form submitted successfully!’);
});
“`

In conclusion, mastering HTTP requests in Node.js is crucial for building robust and efficient applications. By exploring the native HTTPS module, Fetch API, and popular npm packages like Axios, Got, superagent, and node-fetch, you’ll be well-equipped to handle HTTP requests with ease.