How to Send HTTP Requests in Node.js Without Using an External Library

In the world of Node.js, sending HTTP requests is a common task, whether you’re fetching data from an API or submitting form data. While many developers rely on third-party libraries like Axios or Got, there are scenarios where using the native Node.js modules is preferable. This blog post will guide you through sending HTTP requests in Node.js without relying on external libraries, ensuring your code remains lightweight and dependency-free.

---

Sending a GET Request

To send a GET request, you can use the https.get method. Here’s an example:

const https = require('https');

https.get('https://jsonplaceholder.typicode.com/posts', (res) => {
  let data = '';
  res.on('data', (chunk) => {
    data += chunk;
  });
  res.on('end', () => {
    console.log(JSON.parse(data));
  });
}).on('error', (err) => {
  console.error('Error:', err.message);
});

In this example, we:

• Use the https.get method to fetch data from an API.
• Collect the response data in chunks and parse it once the request completes.
• Handle errors using the error event.

This approach is straightforward and works well for simple GET requests.

---

Sending a POST Request

For POST requests, you’ll need to use the https.request method. Here’s how to send a JSON payload:

const https = require('https');

const data = JSON.stringify({
  title: 'foo',
  body: 'bar',
  userId: 1,
});

const options = {
  hostname: 'jsonplaceholder.typicode.com',
  port: 443,
  path: '/posts',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length,
  },
};

const req = https.request(options, (res) => {
  let responseData = '';
  res.on('data', (chunk) => {
    responseData += chunk;
  });
  res.on('end', () => {
    console.log(JSON.parse(responseData));
  });
});

req.on('error', (err) => {
  console.error('Error:', err.message);
});

req.write(data);
req.end();

Key points:

• Define the request options, including the hostname, path, method, and headers.
• Use req.write to send the payload and req.end to finalize the request.
• Handle the response and errors similarly to the GET request example.

---

Handling Different Content Types

When sending POST requests, you may need to handle different content types, such as application/x-www-form-urlencoded or multipart/form-data. Here’s an example for application/x-www-form-urlencoded:

const querystring = require('querystring');
const https = require('https');

const postData = querystring.stringify({
  'key1': 'value1',
  'key2': 'value2',
});

const options = {
  hostname: 'example.com',
  port: 443,
  path: '/submit',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': postData.length,
  },
};

const req = https.request(options, (res) => {
  let responseData = '';
  res.on('data', (chunk) => {
    responseData += chunk;
  });
  res.on('end', () => {
    console.log(responseData);
  });
});

req.on('error', (err) => {
  console.error('Error:', err.message);
});

req.write(postData);
req.end();

This approach is useful for form submissions or APIs that expect URL-encoded data.

---

Error Handling and Timeouts

Native modules don’t provide built-in timeout functionality, but you can implement it using setTimeout:

const req = https.request(options, (res) => {
  // Handle response
});

req.setTimeout(5000, () => {
  req.abort();
  console.error('Request timed out');
});

req.on('error', (err) => {
  console.error('Error:', err.message);
});

This ensures your application doesn’t hang indefinitely if the server fails to respond.

---

When to Use Native Modules vs. Libraries

While native modules are powerful, they require more boilerplate code compared to libraries like Axios or Got. Use native modules when:

• You want to avoid external dependencies.
• You need fine-grained control over request handling.
• Your project is small and doesn’t require advanced features like interceptors or automatic retries.

For larger projects or when you need advanced features, consider using libraries like Axios or Got.

---

Conclusion

Sending HTTP requests in Node.js without external libraries is entirely possible using the native http and https modules. While this approach requires more code, it offers greater control and reduces dependencies. By following the examples in this post, you can confidently handle GET and POST requests, manage different content types, and implement error handling.

For more advanced use cases, explore libraries like Axios or Got, but remember that native modules are always a reliable fallback.

---

Resources:

1. Node.js HTTPS Documentation
2. Stack Overflow: How to Make an HTTP POST Request in Node.js
3. LogRocket Blog: 5 Ways to Make HTTP Requests in Node.js