2017通訊大賽「聯發科技物聯網開發競賽」決賽團隊29強出爐！作品都在11月24日頒獎典禮進行展示

LAST UPDATED 1ST NOVEMBER 2018 BY VALENTINO GAGLIARDI

4 + 1 ways for making HTTP requests with Node.js: async/await edition

Start your journey to DevOps with CircleCI.ADS VIA CARBON

HTTP requests with Node.js are a means for fetching data from a remote source. It could be an API, a website, or something else: at one point you will need some code to get meaningful data from one of those remote sources.

During your career as a Web Developer you will work with HTTP requests all the time. This is why in the following post I want to introduce you to some different ways for making HTTP requests in Node.js.

Starting from the easier one we will explore the “classic way” for doing HTTP requests all the way through libraries which support Promises.

I will focus mostly on GET requests in order to keep things simple and understandable.

Table of Contents

• What you will learn
• Requirements
• Making HTTP requests with Node.js: why?
• Making HTTP requests with Node.js: old school HTTP requests with callbacks
• Making HTTP requests with Node.js: http.get and https.get
• Making HTTP requests with Node.js: the request module
• Making HTTP requests with Node.js: I Promise I’ll be async
• Making HTTP requests with Node.js: the node-fetch module
• Making HTTP requests with Node.js: the r2 module
• Making HTTP requests with Node.js: the axios module
• Making HTTP requests with Node.js: in conclusion
• A small note about “Making HTTP requests with Node.js”
• But! … I want more!

What you will learn

1. How to make HTTP requests in Node.js with various modules
2. The prons and cons of every module

Requirements

To follow along you should have a basic understanding of Javascript and ES6.

Also, make sure to have one of the latest versions of Node. In the following post I’ll make use of the async/await pattern, introduced into Node 7.6.0.

Making HTTP requests with Node.js: why?

At this point you might be asking yourself “Why would I ever do a HTTP request?”.

The answer is simple: as a Javascript developer you will interact every day with remote APIs and webservers. Almost everything today is available in the form of an API: weather forecasts, geolocation services and so on.

Node.js can be used to serve a vaste range of purposes: you can build a command line tool, a proxy, a webserver, and in its simplest form it can be used just for querying a remote API and returning the output to the user.

In the next examples we’ll be making HTTP requests with Node.js by querying the Google Maps API  a convenient “fake” API: the JSON Placeholder API.

(Google Maps API does not accept unauthenticated requests anymore).

Making HTTP requests with Node.js: old school HTTP requests with callbacks

To start, create an empty directory named making-http-requests-node-jsand run:

1. npm init -y

to initialize package.json. The -y flag configures package.json with the default values rather than asking us any questions.

There are two simple ways for making HTTP requests with Node.js as of today: by using a library which follows the classic callback pattern or even better by using a library which supports Promises.

Working with Promises means you could also use the async/await keywords.

Let’s start with callbacks!

Making HTTP requests with Node.js: http.get and https.get

The documentation for http.get

http.get or https.get (for HTTPS requests), are the first choices for making requests in Node.js. If you just need to GET something from an API, stick with them.

PROS:

1. native API, there is no need to install third party modules
2. the response is a stream*

CONS:

1. a bit verbose
2. the response is a stream*
3. no support for promises

To test things out create a new file named https-native.js:

1. const https = require("https");
3. const url = "https://jsonplaceholder.typicode.com/posts/1";
5. https.get(url, res => {
6. res.setEncoding("utf8");
7. let body = "";
8. res.on("data", data => {
9. body += data;
10. });
11. res.on("end", () => {
12. body = JSON.parse(body);
13. console.log(body);
14. });
15. });

Now if you run this code with:

1. node https-native.js

you should be able to see the following output:

1. { userId: 1,
2. id: 1,
3. title:
4. 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit',
5. body:
6. 'quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerumest autem sunt rem eveniet architecto' }

https.get expects an url as a first argument and a callback as a second argument. The returned response is an http.ClientRequest object. That means, in order to manipulate the body of the response you have to listen for events: notice the res.on() in the above example.

Now, in this example I’m just logging the response to the console. In a real program you may want to pass the response to a callback.

*The http.ClientRequest object emits some events that you can listen to. And that’s both good and “bad”: good because you will be tempted to dig further into the Node.js internals to learn more and “bad” because you are forced to do a lot of manipulation if you want to extract the JSON response.

In the end, working with http.get could be slightly more verbose compared to other libraries but that shouldn’t be necessarily considered a drawback because in the process you will learn more about Node.js internals.

Making HTTP requests with Node.js: the request module

The request NPM module

request is one of the most popular NPM module for making HTTP requests with Node.js. It supports both HTTP and HTTPS and follows redirects by default.

PROS:

1. ease of use

CONS:

1. no support for promises
2. too many dependencies

To install the module run:

1. npm i request

inside your project folder.

To test out the example create a new file named request-module.js:

1. const request = require("request");
3. const url = "https://jsonplaceholder.typicode.com/posts/1";
5. request.get(url, (error, response, body) => {
6. let json = JSON.parse(body);
7. console.log(body);
8. });

By running the code with:

1. node request-module.js

you should be able to see the same output as in the previous example.

request.get expects an url as a first argument and a callback as a second argument.

Working with the request module is pleasing. As you can see in the example, it is much more concise than http.get.

There’s a drawback though: request carries 22 dependencies. Now, I wouldn’t consider this a real problem but if your goal is to make just an HTTP GET request, sticking with http.get will be enough to get the job done.

The request module does not support promises. It could be promisified with util.promisify or even better you could use request-promise, a request version which returns promises (and has less dependencies).

Making HTTP requests with Node.js: I Promise I’ll be async

So far we’ve seen how to make HTTP requests in the most basic way with callbacks.

But there is a better (sometimes) way to handle async code: by using Promises alongside with the new async/await keywords.

In the next examples we’ll see how to use a bunch of Node.js modules which support Promises out of the box.

Making HTTP requests with Node.js: the node-fetch module

The node-fetch module

node-fetch is an implementation of the native Fetch API for Node.js. It’s basically the same as window.fetch so if you’re accustomed to use the original it won’t be difficult to pick the Node.js implementation.

PROS:

1. support for promises
2. same API as window.fetch
3. few dependencies

CONS:

1. same API as window.fetch

To install the module run:

1. npm i node-fetch

To test out the example create a new file named node-fetch.js:

1. const fetch = require("node-fetch");
3. const url = "https://jsonplaceholder.typicode.com/posts/1";
5. const getData = async url => {
6. try {
7. const response = await fetch(url);
8. const json = await response.json();
9. console.log(json);
10. } catch (error) {
11. console.log(error);
12. }
13. };
15. getData(url);

By running the code with:

1. node node-fetch.js

you should be able to see the same output again.

If you paid attention I’ve listed “same API as window.fetch” both in Pros and Cons.

That’s because not everybody likes the Fetch API. Some people can’t stand out the fact that in order to manipulate the response you have to call json() (and some other quirks).

But in the end it’s a matter of getting the job done: use whichever library you prefer.

Making HTTP requests with Node.js: the r2 module

The request module for Node.js was written by Mikeal Rogers back in 2010. In 2017 he is back with the r2 module.

The r2 module uses Promises and is another implementation of the browser’s Fetch API. That means r2 depends on node-fetch.

At first it wasn’t clear to me why would I consider using r2 over node-fetch. But I thought the module is worth a mention.

PROS:

1. support for promises
2. same API as window.fetch
3. few dependencies

CONS:

1. it depends on node-fetch

To install the module run:

1. npm i r2

To test things out create a new file named r2-module.js:

1. const r2 = require("r2");
3. const url = "https://jsonplaceholder.typicode.com/posts/1";
5. const getData = async url => {
6. try {
7. const response = await r2(url).json;
8. console.log(response);
9. } catch (error) {
10. console.log(error);
11. }
12. };
14. getData(url);

Run the code with:

1. node r2-module.js

and you should be able to see (again).

By comparing r2 to node-fetch I can see it is less verbose. I saved 1 line of code.

In all honesty I didn’t take the time to look at r2 in details. Maybe because it is almost the same as node-fetch. But I’m sure it has more to offer.

Making HTTP requests with Node.js: the axios module

The axios NPM module

Axios is another super popular NPM module for making HTTP requests. It supports Promises by default.

Axios can be used both for the front-end and the back-end and one of its core feature is the ability to transform both the request and the response.

Plus you don’t need to explicitly process the response in order to get the JSON as you did with node-fetch: axios will do it automagically.

PROS:

1. support for promises
2. ease of use
3. 2 dependencies

CONS:

1. ??

Run:

1. npm i axios

to install axios inside your project folder.

To test out the example create a new file named axios-module.js:

1. const axios = require("axios");
3. const url = "https://jsonplaceholder.typicode.com/posts/1";
5. const getData = async url => {
6. try {
7. const response = await axios.get(url);
8. const data = response.data;
9. console.log(data);
10. } catch (error) {
11. console.log(error);
12. }
13. };
15. getData(url);

Again, by running the above code you should be able to see the same output of the previous examples.

I really can’t find any drawback in axios. It’s super simple to use, highly configurable and intuitive. Last but not least it has only 2 dependencies.

Making HTTP requests with Node.js: in conclusion

All the above libraries share one common denominator: each of them produces the same result. As with almost everything with Javascript sometimes picking one module over another it’s a matter of personal preferences.

In the end, I feel that by using the native API methods you can learn more about the Node.js internals, and that’s both great and educational.

My rule of thumb is to pick the smallest library with the fewer dependencies possible based on what I want to do.

If I were to make a super simple GET request I wouldn’t install neither axios nor node-fetch.

In contrast, using a third party module could save you a lot of coding when in need for more complex functions: i.e. request and response manipulation.

A small note about “Making HTTP requests with Node.js”

A lot has changed since the first version of this blog post. I’ve received a lot of useful comments plus some recommendations.

In the meantime async/await became a thing so I thought it would be nice to update the article with modern examples. Plus, since I care about my own blog, better to bring the article back where it belongs: here.

Thanks for reading!

But! … I want more!

Looking for more articles about Node.js? Fear not, I’ve got you covered: take a look at How to inspect the memory usage of a process in Node.Js and Going real time with Socket.IO, Node.Js and React

Valentino Gagliardi

Obsessed with test-driven development, I’m well versed in a variety of programming languages. Besides writing code these days I help busy people to learn Web Development and JavaScript.

Let’s get in touch!