The http Module

Reviewed & published by Brayan K

The http module is Node's built-in toolkit for working with the HyperText Transfer Protocol — it can both make outgoing requests and provide the building blocks (request and response objects, status codes, headers) for receiving them.

Part of the free Node.js course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

This lesson focuses on understanding HTTP and making requests, which is what you'll do most often. We'll keep server creation light and end with a tiny preview, because the very next lesson builds a real server from the ground up.

What You'll Learn in This Lesson

• What HTTP is: methods, status codes, and headers
• How the request/response cycle actually works
• Making requests with the modern global fetch (Node 18+)
• Parsing JSON responses and checking res.ok
• The lower-level http.request and http.get alternatives
• A first peek at http.createServer before the next lesson

1️⃣ What HTTP Actually Is

HTTP (HyperText Transfer Protocol) is the language clients and servers use to talk over the web. Every interaction is one round trip: a client sends a request, the server sends back a response. Three pieces of vocabulary describe almost everything that happens:

• • Methods say what you want to do: GET (read), POST (create), PUT (update/replace), DELETE (remove).
• • Status codes say how it went: 200 OK, 201 Created, 404 Not Found, 500 Server Error. The first digit groups them: 2xx success, 4xx your fault, 5xx the server's fault.
• • Headers are key/value metadata that ride along, like Content-Type: application/json, telling the other side how to interpret the body.

The little script below isn't a network call yet — it just turns that vocabulary into data you can see, so the terms stick before we make a real request.

// HTTP is built from a few simple ideas. Here they are as plain data,
// so the vocabulary sticks before we make any real network calls.

// 1) METHODS describe the *intent* of a request.
const methods = ["GET", "POST", "PUT", "DELETE"];
console.log("Methods:", methods.join(", "));   // -> GET, POST, PUT, DELETE

// 2) STATUS CODES describe how a request *turned out*.
const statuses = { ok: 200, created: 201, notFound: 404, serverError: 500 };
console.log("200 means:", "OK");                // success
console.log("404 means:", "Not Found");         // the resource is missing
console.log("500 means:", "Server Error");      // something broke server-side

// 3) HEADERS are key/value metadata that travel with the request/response.
const headers = { "Content-Type": "application/json" };
console.log("Header:", `Content-Type: ${headers["Content-Type"]}`);

// The full cycle: client SENDS a request (method + path + headers),
// the server SENDS BACK a response (status + headers + body).
console.log(`Cycle: GET /users -> ${statuses.ok} OK`);

2️⃣ Making a Request with fetch

Since Node 18, a global fetch() is built in — the same one you may know from the browser, with no import and no install. It's the modern, recommended way to make outgoing requests. Because the network takes time, fetch returns a Promise, so you await it inside an async function.

There are two awaits, and beginners trip on the second one: await fetch(...) gives you a Response object (status, headers, ok), and a separate await res.json() reads and parses the body. Read the comments closely.

// In Node 18+ a global fetch() is built in — no import, no install.
// fetch returns a Promise, so we await it inside an async function.

async function getUser() {
  // 1) Send the request and wait for the response object.
  const res = await fetch("https://api.example.com/users/1");

  // 2) res.ok is true for 200–299. Always check it before trusting the body.
  if (!res.ok) {
    throw new Error(`Request failed: ${res.status}`);
  }

  // 3) res.json() reads the body stream and parses it — also a Promise.
  const data = await res.json();

  console.log("Status:", res.status);   // -> Status: 200
  console.log("Name:", data.name);      // -> Name: Ada Lovelace

  // For reference, the whole parsed body this example assumes:
  //   { "id": 1, "name": "Ada Lovelace",
  //     "email": "ada@example.com", "active": true }
  // Only the two lines above are printed — the object itself is not, which
  // is why it belongs in a comment rather than in the output panel.
  return data;
}

getUser();

Before fetch existed, you used the http module's own lower-level helpers — http.get(url, cb) for simple GETs and http.request(options, cb) for everything else. They're event-based: you listen for "data" chunks and an "end" event, then assemble the body yourself. They still work and give you fine control, but fetch is far less code for everyday use, so we'll favor it here.

Your turn. The program below works once you fill in the two blanks marked ___. Follow the 👉 hints, then run it and compare with the expected output.

// 🎯 YOUR TURN — replace each ___ then run it (Node 18+).

async function checkStatus() {
  // 1) Send a request to this real, free test endpoint.
  //    fetch returns a Promise, so don't forget to ___ it!
  const res = ___ fetch("https://jsonplaceholder.typicode.com/todos/1");

  // 2) Log the numeric status code the server sent back.
  console.log("Status:", res.___);   // 👉 the property holding 200, 404, etc.

  // ✅ Expected output:
  //    Status: 200
}

checkStatus();

3️⃣ A Tiny Server Preview

The same http module can also receive requests by creating a server. http.createServer(fn) takes a callback that runs once per incoming request, handing you a request object (req) and a response object (res) you write the reply into. This is just a teaser — the next lesson is dedicated to building servers properly.

// A taste of the next lesson: the http module can also CREATE a server.
// createServer takes a callback that runs for every incoming request,
// giving you a request object (req) and a response object (res).
const http = require("node:http");

const server = http.createServer((req, res) => {
  // Set the status code and a header, then end the response with a body.
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello\n");
});

// Start listening on port 3000. We'll go much deeper next lesson.
server.listen(3000, () => {
  console.log("Server running at http://localhost:3000/");
});

Run it, then hit it from another terminal to see the response come back:

# Save the code as server.js and start it:
node server.js
# -> Server running at http://localhost:3000/

# In a second terminal, send it a request with curl:
curl http://localhost:3000/
# -> Hello

Mini-Challenge: Fetch and Report

No blanks this time — just a brief and an outline to keep you on track. Write it yourself, run it on Node 18+, and check your output against the example in the comments. This is the everyday pattern you'll use constantly.

// 🎯 MINI-CHALLENGE: fetch and report
// 1. Write an async function called getTitle().
// 2. await fetch() this URL:
//      https://jsonplaceholder.typicode.com/posts/1
// 3. Check res.ok — if it's false, log "Request failed" and stop.
// 4. Parse the body with await res.json().
// 5. Log the post's title (the data.title field).
//
// ✅ Example output:
//    Status: 200
//    Title: sunt aut facere repellat provident occaecati...

async function getTitle() {
  // your code here
}

getTitle();

Common Errors (and the fix)

• Forgetting to await fetch — Without await (or .then) you get a pending Promise, not a Response. res.status comes back undefined. Always await fetch(url) inside an async function.
• Forgetting to await res.json() — The body is a second Promise. Logging res.json() directly prints Promise { <pending> }. Write const data = await res.json().
• Not checking res.ok — fetch only rejects on network failure, not on 404 or 500. A "missing" response still resolves. Guard with if (!res.ok) { ... } before reading the body.
• Mixing up request vs response — In a server, req is what came in (read it) and res is what you send back (write it). Calling req.end() or setting headers on the wrong one is a classic slip.
• Worrying about CORS in Node — CORS is a browser security rule, not part of HTTP. fetch() in Node can call any URL freely; you only configure CORS on a server when browser code calls it.
• Unhandled promise rejection on network errors — A dropped connection makes fetch reject. Without a try/catch (or .catch) it crashes the process with an UnhandledPromiseRejection. Wrap awaits in try/catch.

Pro Tips

• 💡 Always check the status: a quick if (!res.ok) throw new Error(res.status) turns silent 404s into loud, fixable errors.
• 💡 Pick the body reader to match: res.json() for JSON, res.text() for plain text or HTML. Reading the body twice throws — read it once.
• 💡 Use a real test API like jsonplaceholder.typicode.com while learning — it returns predictable JSON with no signup.

📋 Quick Reference — http & fetch

🎉 Lesson Complete!

• ✅ HTTP is a request/response cycle described by methods, status codes, and headers
• ✅ await fetch(url) makes a request and returns a Response object
• ✅ await res.json() parses the body; res.status and res.ok tell you how it went
• ✅ The lower-level http.get / http.request still exist for fine control
• ✅ http.createServer(fn) turns the same module into a server
• ✅ CORS is a browser concept — it doesn't apply to fetch() running in Node

Practice quiz

Continue this course

• Previous: Streams & Buffers
• Next: Building a Server — Create your own HTTP server with createServer and handle requests
• Quick reference: Node.js cheat sheet › Common Patterns

Frequently asked questions

Should I use the built-in fetch or the http module to make requests in Node?

For making outgoing requests, prefer the global fetch() available in Node 18 and later — it's promise-based, concise, and matches the API you already know from the browser. The lower-level http.request and http.get still work and give you fine-grained control over streaming and connection settings, but they use callbacks and events, which are more verbose. Reach for the http module directly when you need to build a server or need that low-level control; otherwise fetch is the simpler choice.

Do I need to install anything to use fetch in Node?

No. Since Node 18, fetch() is a global, just like in the browser — there's no import and no npm install. Check your version with node --version. On Node 16 or older you'd need a package like node-fetch, but on any modern Node you can call fetch() directly.

Why does my fetch return a Response object instead of the data?

fetch resolves to a Response object that describes the reply (its status, headers, and ok flag) but does not yet contain the parsed body. The body arrives as a stream, so you take a second step: await res.json() for JSON, or await res.text() for plain text. Forgetting that second await — or logging res directly — is the most common beginner surprise.

Do I have to worry about CORS in Node like I do in the browser?

No. CORS (Cross-Origin Resource Sharing) is a security rule enforced by web browsers to protect users, not a rule of the HTTP protocol itself. Node is a server-side runtime with no browser sandbox, so fetch() in Node can call any URL without CORS errors. You only deal with CORS when browser JavaScript calls your Node server — and then you configure it on the server's response headers.