📣 This post originally appeared as Use the Node.js HTTP Module to Make a Request on The Bearer Blog.
The ecosystem around making requests in Node.js applications is huge. With countless libraries available, it can be helpful to understand why they exist. This helps to improve your understanding of Node.js as a whole, and makes choosing an HTTP client easier.
In the first post in this series, we looked at creating servers using Node's http
module. In this post, we will explore making a request using the http.request
method and handling the response. This is the underlying component used by most, if not all, Node.js request libraries.
http.request basics
The request
method is part of Node's built-in http
module. This module handles much of the low-level functionality needed to create servers, receive requests, send responses, and keep connections open. The request
implementation, like most core implementations, is rather verbose and harder to work with than the abstractions that many libraries implement. It is also event-driven, and relies on streams to handle data. This doesn't mean it isn't usable. In fact, many parts of it will look familiar to third-party libraries as they have drawn inspiration from it. Let's start with a basic request.
const http = require("http")
http
.request(
{
hostname: "postman-echo.com",
path: "/status/200"
},
res => {
let data = ""
res.on("data", d => {
data += d
})
res.on("end", () => {
console.log(data)
})
}
)
.end()
This code block makes a GET
request to http://postman-echo.com/status/200
and logs the response to the console. The request
method can take a variety of configuration options. In this example, we are passing it the hostname and path. We didn't set a method, because GET
is the default. The callback takes the response—res
in the example—which can listen for events that fire during the response.
This example focuses on two key events. The data
event and the end
event. Because the response comes as a readable stream, we need to assemble it. For stringified responses you can build a string. Alternately, it may be a good idea to push to an array and then use a buffer to assemble the result like we do in the createServer article.
Each time the data
event fires we append to a string. Finally, when the end
event fires we log the result. At the end of the call, we chain the end()
method. This is a required part of the request, and without it the API call will not fire.
Let's look at another implementation of the same code.
const http = require("http")
let options = new URL("https://postman-echo.com/status/200")
let myRequest = http.request(options, res => {
// Same as previos example
res.on('data' d=> {
//...
})
//... etc
})
myRequest.on("error", console.error)
myRequest.end()
In this version of the code, we create a URL
with our desired API endpoint. The request
can now take this URL object as the first argument. We also assign the whole code block to myRequest
. This gives myRequest
the ability to control the request listeners rather than chaining them to the end.
You may be tempted to try and call myRequest()
, but the action that fires the request is .end()
.
Shorthand requests with http.get
While http.request
can handle all the major HTTP methods, GET
has a dedicated shorthand method. It works exactly the same, except it accepts a url string, removes the need for .end()
, and sets the method to GET
. For example, our first example would look as follows with http.get
:
const http = require("http")
http.get("https://postman-echo.com/status/200", res => {
let data = ""
res.on("data", d => {
data += d
})
res.on("end", () => {
console.log(data)
})
})
While not a major difference, this syntax makes handling GET
requests easier.
POSTing to an API
With common GET
request handled, let's look at POST
. The syntax is mostly the same.
const http = require("http")
let body = JSON.stringify({
title: "Make a request with Node's http module"
})
let options = {
hostname: "postman-echo.com",
path: "/post",
method: "POST",
headers: {
"Content-Type": "application/json",
"Content-Length": Buffer.byteLength(body)
}
}
http
.request(options, res => {
let data = ""
res.on("data", d => {
data += d
})
res.on("end", () => {
console.log(data)
})
})
.on("error", console.error)
.end(body)
First we need to set up the body and options. Since we want to send JSON, we stringify the object and set it to body
. Next, configure options
with the necessary properties and headers. Note that we are telling the server the size of our payload with the Content-Length
header, as well as the type of data with Content-Type
.
The http.request
portion looks mostly the same as in the earlier examples. We chain an on("error")
listener. We also pass the body into the end()
. This could also be written as .write(body).end()
.
Things to watch out for
While the code examples above are average use-cases, there are a few quirks to be aware of. Here are a few best practices and tips for working with http.request
.
HTTPS
In the examples we use http
, but for secure connections requiring HTTPS, you can use the https
module in the same way. It is compatible with all the functionality of http
.
Watch for empty responses
Empty responses won't fire a data
event. This means if your response.on('end')
event expects something from the data listener, you may run into problems for some responses like those from redirects. Make sure to perform any checks before relying on data coming from the data
listener.
Make requests from inside the server
The host
property in the options object defaults to localhost
. This is nice for quick local experiments and instances where you want to call a server from within itself. For example:
let server = http.createServer()
server.listen(3000, error => {
http.request({
port: 3000,
path: "/endpoint"
}, res => {
// handle the response
})
})
Using this technique, you can make calls upon the server from inside the listen
method's callback.
Error handling
One of the earlier examples briefly shows error handling, but it is worth mentioning again. The request itself, not the response, can fire an error
event. You can listen for it by chaining .on('error', (error) => {})
onto a request before calling .end()
or if you have set the request to a variable, you can listen on the variable.
let call = http.request(options, handleResponse)
call.on("error", handleError)
call.end()
This is also a good use case for building a custom error type to handle specific responses.
Cancelling requests
The req.abort()
method allows you to cancel requests if used before the connection completes. In our example where the request is named call
, this would be call.abort()
.
Wrapping up
So should you use http.request
on it's own? In most cases it is a better choice to use one of the many libraries available on NPM. Especially one that supports promises and async/await. That said, know that beneath them all is the http
module. You can take advantage of its features to built functionality on top of the requests that your application makes.
At Bearer, we use the underlying functionality of http.request
to actively monitor and control calls made to third-party APIs and web services. Explore the rest of the Bearer Blog for more on Node.js and interacting with APIs.
Top comments (0)