The Node http module

Updated Oct 5, 2026

A reference to the Node.js http module for networking, covering properties like METHODS and STATUS_CODES, methods like createServer(), and its core classes.

~~~

The HTTP core module is a key module to Node networking.

Properties
Methods
Classes

It can be included using

const http = require('node:http')

The module provides some properties and methods, and some classes.

Properties

http.METHODS

This property lists all the HTTP methods supported. This is the list in Node 24, the Active LTS release (Node 26 is the Current release):

> require('node:http').METHODS
[ 'ACL',
  'BIND',
  'CHECKOUT',
  'CONNECT',
  'COPY',
  'DELETE',
  'GET',
  'HEAD',
  'LINK',
  'LOCK',
  'M-SEARCH',
  'MERGE',
  'MKACTIVITY',
  'MKCALENDAR',
  'MKCOL',
  'MOVE',
  'NOTIFY',
  'OPTIONS',
  'PATCH',
  'POST',
  'PROPFIND',
  'PROPPATCH',
  'PURGE',
  'PUT',
  'QUERY',
  'REBIND',
  'REPORT',
  'SEARCH',
  'SOURCE',
  'SUBSCRIBE',
  'TRACE',
  'UNBIND',
  'UNLINK',
  'UNLOCK',
  'UNSUBSCRIBE' ]

http.STATUS_CODES

This property lists all the HTTP status codes and their description:

> require('node:http').STATUS_CODES
{ '100': 'Continue',
  '101': 'Switching Protocols',
  '102': 'Processing',
  '200': 'OK',
  '201': 'Created',
  '202': 'Accepted',
  '203': 'Non-Authoritative Information',
  '204': 'No Content',
  '205': 'Reset Content',
  '206': 'Partial Content',
  '207': 'Multi-Status',
  '208': 'Already Reported',
  '226': 'IM Used',
  '300': 'Multiple Choices',
  '301': 'Moved Permanently',
  '302': 'Found',
  '303': 'See Other',
  '304': 'Not Modified',
  '305': 'Use Proxy',
  '307': 'Temporary Redirect',
  '308': 'Permanent Redirect',
  '400': 'Bad Request',
  '401': 'Unauthorized',
  '402': 'Payment Required',
  '403': 'Forbidden',
  '404': 'Not Found',
  '405': 'Method Not Allowed',
  '406': 'Not Acceptable',
  '407': 'Proxy Authentication Required',
  '408': 'Request Timeout',
  '409': 'Conflict',
  '410': 'Gone',
  '411': 'Length Required',
  '412': 'Precondition Failed',
  '413': 'Payload Too Large',
  '414': 'URI Too Long',
  '415': 'Unsupported Media Type',
  '416': 'Range Not Satisfiable',
  '417': 'Expectation Failed',
  '418': 'I\'m a teapot',
  '421': 'Misdirected Request',
  '422': 'Unprocessable Entity',
  '423': 'Locked',
  '424': 'Failed Dependency',
  '425': 'Too Early',
  '426': 'Upgrade Required',
  '428': 'Precondition Required',
  '429': 'Too Many Requests',
  '431': 'Request Header Fields Too Large',
  '451': 'Unavailable For Legal Reasons',
  '500': 'Internal Server Error',
  '501': 'Not Implemented',
  '502': 'Bad Gateway',
  '503': 'Service Unavailable',
  '504': 'Gateway Timeout',
  '505': 'HTTP Version Not Supported',
  '506': 'Variant Also Negotiates',
  '507': 'Insufficient Storage',
  '508': 'Loop Detected',
  '509': 'Bandwidth Limit Exceeded',
  '510': 'Not Extended',
  '511': 'Network Authentication Required' }

http.globalAgent

Points to the global instance of the Agent object, which is an instance of the http.Agent class.

It’s used to manage connections persistence and reuse for HTTP clients, and it’s a key component of Node HTTP networking. Since Node 19 it has keepAlive set to true by default, so connections stay open and get reused.

More in the http.Agent class description later on.

Methods

http.createServer()

Return a new instance of the http.Server class. I walk through a full example in build an HTTP server.

Usage:

const server = http.createServer((req, res) => {
  //handle every single request with this callback
})

http.request()

Makes an HTTP request to a server, creating an instance of the http.ClientRequest class. See making HTTP requests with Node for examples.

http.get()

Similar to http.request(), but automatically sets the HTTP method to GET, and calls req.end() automatically.

Classes

The HTTP module provides 5 classes:

http.Agent
http.ClientRequest
http.Server
http.ServerResponse
http.IncomingMessage

http.Agent

Node creates a global instance of the http.Agent class to manage connections persistence and reuse for HTTP clients, a key component of Node HTTP networking.

The agent keeps a pool of sockets for each host and port. With keep-alive on (the default for http.globalAgent since Node 19), a socket goes back to the pool when its request is done, and the next request to the same server reuses it instead of opening a new connection.

Requests wait in a queue only when the agent reaches its maxSockets limit for that host, which is unlimited by default. This is key for performance reasons.

http.ClientRequest

An http.ClientRequest object is created when http.request() or http.get() is called.

When a response is received, the response event is called with the response, with an http.IncomingMessage instance as argument.

The returned data of a response can be read in 2 ways:

you can call the response.read() method
in the response event handler you can setup an event listener for the data event, so you can listen for the data streamed into.

http.Server

This class is commonly instantiated and returned when creating a new server using http.createServer().

Once you have a server object, you have access to its methods:

close() stops the server from accepting new connections
listen() starts the HTTP server and listens for connections

http.ServerResponse

Created by an http.Server and passed as the second parameter to the request event it fires.

Commonly known and used in code as res:

const server = http.createServer((req, res) => {
  //res is an http.ServerResponse object
})

The method you’ll always call in the handler is end(), which closes the response, the message is complete and the server can send it to the client. It must be called on each response.

These methods are used to interact with HTTP headers:

getHeaderNames() get the list of the names of the HTTP headers already set
getHeaders() get a copy of the HTTP headers already set
setHeader('headername', value) sets an HTTP header value
getHeader('headername') gets an HTTP header already set
removeHeader('headername') removes an HTTP header already set
hasHeader('headername') return true if the response has that header set
headersSent is true if the headers have already been sent to the client (it’s a boolean property, not a method)

After processing the headers you can send them to the client by calling response.writeHead(), which accepts the statusCode as the first parameter, the optional status message, and the headers object.

To send data to the client in the response body, you use write(). It will send buffered data to the HTTP response stream.

If the headers were not sent yet using response.writeHead(), it will send the headers first, with the status code and message that’s set in the request, which you can edit by setting the statusCode and statusMessage properties values:

response.statusCode = 500
response.statusMessage = 'Internal Server Error'

http.IncomingMessage

An http.IncomingMessage object is created by:

http.Server when listening to the request event
http.ClientRequest when listening to the response event

It can be used to access the response:

status using its statusCode and statusMessage properties
headers using its headers or rawHeaders properties
HTTP method using its method property
HTTP version using the httpVersion property
URL using the url property
underlying socket using the socket property

They’re all properties, not methods. statusCode and statusMessage are only set on responses you get from an http.ClientRequest, while method and url are only set on requests received by an http.Server.

The data is accessed using streams, since http.IncomingMessage implements the Readable Stream interface.

Tagged: Node.js · All topics

Follow @flaviocopes

Want me to talk about your product? You can sponsor this site.

~~~