http — HTTP Server

Building HTTP servers in Node.js without frameworks — createServer, req/res objects, routing, status codes, and HTTPS.

What it is, in plain English: The http module (built into Node.js) lets you create HTTP servers from scratch. http.createServer() takes a callback that receives every request. The req object contains the method, URL, headers, and body. The res object sends the response — status code, headers, and body. This is what every web framework (Express, Fastify, Hono) wraps under the hood.

Your first HTTP server without a framework

Every web framework — Express, Fastify, Hono — sits on top of Node's built-in http module. Understanding the raw http module shows you what frameworks are actually doing.

The simplest possible server

import { createServer } from "http";

const server = createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello World!");
});

server.listen(3000, () => {
  console.log("Running at http://localhost:3000");
});

Reading the request

const server = createServer((req, res) => {
  console.log(req.method);   // "GET", "POST", "PUT", "DELETE" etc.
  console.log(req.url);      // "/api/users?page=2"
  console.log(req.headers);  // { "content-type": "application/json", ... }

  // Parse URL and query string:
  const url    = new URL(req.url, "http://localhost");
  console.log(url.pathname);         // "/api/users"
  console.log(url.searchParams.get("page")); // "2"
});

Sending responses

function sendJSON(res, statusCode, data) {
  res.writeHead(statusCode, {
    "Content-Type":                "application/json",
    "Access-Control-Allow-Origin": "*",   // CORS
  });
  res.end(JSON.stringify(data));
}

const server = createServer((req, res) => {
  if (req.method === "GET" && req.url === "/api/ping") {
    sendJSON(res, 200, { ok: true, ts: Date.now() });
    return;
  }
  sendJSON(res, 404, { error: "Not found" });
});

Reading the request body (POST/PUT)

// The body arrives as a stream — collect chunks:
function readBody(req) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    req.on("data",  chunk => chunks.push(chunk));
    req.on("end",   ()    => resolve(Buffer.concat(chunks).toString()));
    req.on("error", reject);
  });
}

const server = createServer(async (req, res) => {
  if (req.method === "POST" && req.url === "/api/users") {
    try {
      const raw  = await readBody(req);
      const user = JSON.parse(raw);
      // ... save user ...
      sendJSON(res, 201, { ...user, id: Date.now() });
    } catch {
      sendJSON(res, 400, { error: "Invalid JSON body" });
    }
  }
});

Try It Yourself

// http.createServer — building an HTTP server from scratch
// This is what Express, Fastify, and Hono all wrap

// In real Node.js:
// import { createServer } from "http";

// What a complete minimal HTTP server looks like:
const SERVER_CODE = `
import { createServer } from "http";

const server = createServer((req, res) => {
  // req = IncomingMessage (the request)
  // res = ServerResponse (your response)

console.log(req.method, req.url);  // e.g. "GET /api/users"

// ── Routing ────────────────────────────────────────
  if (req.method === "GET" && req.url === "/") {
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end("Hello World!");
    return;
  }

if (req.method === "GET" && req.url === "/api/users") {
    const users = [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }];
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify(users));
    return;
  }

if (req.method === "POST" && req.url === "/api/users") {
    // Collect request body (comes in chunks):
    let body = "";
    req.on("data", chunk => { body += chunk.toString(); });
    req.on("end", () => {
      try {
        const user = JSON.parse(body);
        console.log("New user:", user);
        res.writeHead(201, { "Content-Type": "application/json" });
        res.end(JSON.stringify({ ...user, id: Date.now() }));
      } catch {
        res.writeHead(400, { "Content-Type": "application/json" });
        res.end(JSON.stringify({ error: "Invalid JSON" }));
      }
    });
    return;
  }

// 404 fallback:
  res.writeHead(404, { "Content-Type": "application/json" });
  res.end(JSON.stringify({ error: "Not found" }));
});

server.listen(3000, () => {
  console.log("Server running at http://localhost:3000");
});
`;

// Request body reading:
async function readBody(req) {
  return new Promise((resolve, reject) => {
    let data = "";
    req.on("data", chunk => { data += chunk.toString(); });
    req.on("end",  () => resolve(data));
    req.on("error", reject);
  });
}

// Common status codes:
const CODES = {
  200: "OK",           201: "Created",       204: "No Content",
  301: "Moved",        302: "Found",         304: "Not Modified",
  400: "Bad Request",  401: "Unauthorized",  403: "Forbidden",
  404: "Not Found",    405: "Method Not Allowed",
  409: "Conflict",     422: "Unprocessable", 429: "Too Many Requests",
  500: "Server Error", 503: "Service Unavail"
};
Object.entries(CODES).forEach(([code, text]) => console.log(`${code} ${text}`));

Routing, middleware, and HTTPS

A minimal router

// Build a simple route table without a framework:
class Router {
  #routes = [];

  on(method, path, handler) {
    this.#routes.push({ method: method.toUpperCase(), path, handler });
    return this;
  }

  get(path, handler)    { return this.on("GET",    path, handler); }
  post(path, handler)   { return this.on("POST",   path, handler); }
  put(path, handler)    { return this.on("PUT",    path, handler); }
  delete(path, handler) { return this.on("DELETE", path, handler); }

  async handle(req, res) {
    const url   = new URL(req.url, "http://localhost");
    const route = this.#routes.find(r =>
      r.method === req.method && r.path === url.pathname
    );
    if (route) return route.handler(req, res, url);
    res.writeHead(404); res.end("Not Found");
  }
}

const router = new Router()
  .get("/",     (req, res) => { res.end("Home"); })
  .get("/api",  (req, res) => { res.end("API"); })
  .post("/api/users", async (req, res) => { /* ... */ });

createServer((req, res) => router.handle(req, res)).listen(3000);

HTTPS server

import { createServer as createHTTPS } from "https";
import { readFileSync } from "fs";

const server = createHTTPS({
  key:  readFileSync("key.pem"),   // TLS private key
  cert: readFileSync("cert.pem"),  // TLS certificate
}, (req, res) => {
  res.end("Secure!");
});

server.listen(443);

// For local dev — use mkcert to generate trusted self-signed certs:
// mkcert localhost 127.0.0.1 ::1
// → creates localhost.pem and localhost-key.pem

Making HTTP requests from Node.js

// Use the built-in fetch (Node.js 18+) — same as browser:
const res  = await fetch("https://api.example.com/data");
const data = await res.json();

// Or the http.request API for lower-level control:
import { request } from "https";
const req = request("https://api.example.com/data", (res) => {
  let body = "";
  res.on("data", chunk => body += chunk);
  res.on("end", () => console.log(JSON.parse(body)));
});
req.on("error", console.error);
req.end();

HTTP/2, keep-alive, and the http spec

// HTTP/2 server (requires TLS):
import { createSecureServer } from "http2";

const server = createSecureServer({ key, cert }, (req, res) => {
  // Works like http/https but multiplexes streams over one connection
  res.stream.respond({ ":status": 200, "content-type": "text/html" });
  res.stream.end("<h1>HTTP/2!</h1>");
});

// Server push (HTTP/2 only — proactively send resources):
server.on("stream", (stream, headers) => {
  if (headers[":path"] === "/") {
    stream.pushStream({ ":path": "/style.css" }, (err, pushStream) => {
      pushStream.respond({ ":status": 200, "content-type": "text/css" });
      pushStream.end("body { margin: 0; }");
    });
    stream.respond({ ":status": 200 });
    stream.end("<html>...</html>");
  }
});

// Keep-alive: Node.js HTTP/1.1 servers enable Connection: keep-alive by default.
// Tune with server.keepAliveTimeout (ms) and server.headersTimeout.

Official Sources

The Codex links only to official documentation and the ECMAScript specification. No third-party tutorials.