staticdata.dev
Menu
Datasets About Contact

Node.js Built-in Modules

A curated list of the 43 top-level public Node.js core modules in Node.js 26 (current as of October 2026), including their canonical module names, human-readable descriptions, and whether the module has reached stable API status. Covers everything from foundational modules like fs, path, and http to newer additions like test, sea and sqlite.

v1.0.0 MIT 43 records Updated 2026-10-05 stable Source:  Node.js Documentation — Built-in Modules

Quick fetch

Stable URL. CORS-enabled. No auth.

bash 
curl https://staticdata.dev/v1/node-builtin-modules.json

Or use as a typed import: import { nodeBuiltinModules } from "https://staticdata.dev/v1/node-builtin-modules.ts"

Formats

  • JSON 7.3 KB

    /v1/node-builtin-modules.json

    Open

    min: 6.3 KB · /v1/node-builtin-modules.min.json

  • CSV 4.9 KB

    /v1/node-builtin-modules.csv

    Open
  • TypeScript 7.5 KB

    /v1/node-builtin-modules.ts

    export const nodeBuiltinModules

    type NodeModule = (typeof nodeBuiltinModules)[number]

    Open

Schema

Each record in the dataset has the following shape.

Schema
Field Type Description Example
name string Module name as used in require() or import fs
description string Short description of the module's purpose Provides an API for interacting with the file system.
stable boolean Whether the module's API has stable status true

Preview

First 10 records.

Data preview
namedescriptionstable
assertProvides a set of assertion functions for verifying invariants in tests and application code.true
async_hooksTracks asynchronous resources and their lifetimes; provides hooks for async context propagation.false
bufferHandles binary data directly, providing the Buffer class for raw memory allocation outside the V8 heap.true
child_processSpawns child processes (sync and async), enabling shell commands and subprocess communication via IPC.true
clusterEnables creating child worker processes that all share server ports, for multi-core CPU utilization.true
consoleProvides a simple debugging console similar to the JavaScript console mechanism browsers provide.true
cryptoOffers cryptographic functionality including hashes, HMAC, ciphers, digital signatures, and key derivation.true
dgramImplements UDP datagram sockets for sending and receiving UDP packets.true
diagnostics_channelProvides an API to create named channels for reporting diagnostic messages from modules.true
dnsEnables DNS lookups and name resolution via the operating system's DNS facilities or the c-ares library.true

Showing 10 of 43. View full data:  JSON · CSV

Fetch examples

Drop-in snippets in five languages.

curl 
curl -sSL https://staticdata.dev/v1/node-builtin-modules.json | jq '.[0]'
JavaScript 
import type { NodeModule } from "https://staticdata.dev/v1/node-builtin-modules.ts";

const res = await fetch("https://staticdata.dev/v1/node-builtin-modules.min.json");
if (!res.ok) throw new Error(`Fetch failed: ${res.status}`);
const nodeBuiltinModules: NodeModule[] = await res.json();
console.log(nodeBuiltinModules[0]);
Python 
import urllib.request, json

with urllib.request.urlopen("https://staticdata.dev/v1/node-builtin-modules.min.json") as r:
    nodeBuiltinModules = json.load(r)

print(nodeBuiltinModules[0])
Go 
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("https://staticdata.dev/v1/node-builtin-modules.min.json")
	if err != nil { panic(err) }
	defer resp.Body.Close()

	var data []map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		panic(err)
	}
	fmt.Println(data[0])
}
Rust 
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = ureq::get("https://staticdata.dev/v1/node-builtin-modules.min.json").call()?.into_string()?;
    let data: Vec<Value> = serde_json::from_str(&body)?;
    println!("{:?}", data.first());
    Ok(())
}

Sources and methodology

This dataset is curated from the official Node.js documentation as of October 2026 (Node.js 26). It includes the top-level public core modules that ship as part of the Node.js runtime — accessible via require('fs') or import 'node:fs' — without installing any npm packages. The stable field reflects whether the module is marked as Stability 2 (Stable) in the official docs; modules marked as deprecated (Stability 0) or experimental (Stability 1, including 1.1 active development and 1.2 release candidate) are flagged with stable: false.

Not included: subpath modules such as fs/promises, stream/web or timers/promises; the deprecated constants and sys aliases; internal underscore-prefixed modules (_http_agent and so on); and experimental modules that must be enabled with a CLI flag (for example node:ffi, node:vfs, node:quic).

Module names use the short form (e.g., fs, path, http) which is compatible with both the legacy require('fs') syntax and the recommended node: prefix import style (e.g., import 'node:fs'). Both forms resolve to the same built-in module in Node.js 14.18+. The exceptions are sea, sqlite and test, which are only available with the node: prefix (require('node:test')); the dataset lists them by their short name for consistency.

This dataset is useful for build tools, linters, IDE plugins, and documentation generators that need to distinguish Node.js built-in modules from npm packages — for example, to correctly classify bare import specifiers, generate type stubs, or validate dependency graphs.

Versioning

URLs under /v1/ are stable: field names and types will not change in a way that breaks consumers. Values can be corrected or records added when the upstream source changes; schema-incompatible updates ship under a new version path. See the node-builtin-modules changelog for this dataset's history.

More Code datasets