A simple, fast, in-memory caching module for Node.js with set, get, and delete methods. Works like memcached but runs entirely in-process. Keys support automatic expiration via TTL.

This is an actively maintained fork of the original node-cache by @mpneuried. The original project is no longer maintained. This fork continues development with bug fixes, a full TypeScript rewrite, and performance improvements while keeping the public API fully backward-compatible.

This fork (v6.0.0) includes the following improvements over the last published original (v5.1.2):

• TypeScript rewrite -- Full rewrite from CoffeeScript to TypeScript. Type definitions are now generated from source, not hand-maintained.
• Bug fixes -- set() no longer throws ECACHEFULL when updating an existing key at maxKeys capacity. flushStats() no longer breaks maxKeys enforcement.
• Performance -- TTL expiry rewritten from O(n) linear scan to O(log n) min-heap (~4x-8x faster at 100K keys in local runs). New enableStats option allows stats to be disabled when beneficial (measure in your workload).
• Security -- Reduced dev dependency vulnerabilities from 20 to 2 by removing grunt, coveralls, and upgrading the entire toolchain. Production dependencies have 0 known vulnerabilities. Total package count cut from 910 to 362.
• Modern Node.js -- Minimum Node.js version raised to 20 LTS. CI tested on Node 20, 22, and 24.
• Removed legacy -- enableLegacyCallbacks option removed (deprecated since v5.0.0).

The public API (15 methods + 5 events) is unchanged. require("node-cache") is a drop-in replacement.

The original v5.1.2 ships with vulnerable versions of minimatch, form-data, qs, tough-cookie, debug, js-yaml, diff, and others via its grunt/coveralls/mocha dependency tree. This fork eliminated all but 2 (both serialize-javascript inside mocha, dev-only).

See CHANGELOG.md for full details.

npm install node-cache --save

const NodeCache = require( "node-cache" );
const myCache = new NodeCache();

// set a key with 100 second TTL
myCache.set( "myKey", { name: "foo" }, 100 );

// retrieve it
const value = myCache.get( "myKey" );
// { name: "foo" }

const myCache = new NodeCache( { stdTTL: 100, checkperiod: 120 } );

Keys can be string or number (cast to string internally). Other types throw an error.

myCache.set( key, value, [ ttl ] )

Sets a key-value pair. Optional TTL in seconds. Returns true on success.

myCache.set( "myKey", { my: "Special", variable: 42 }, 10000 );
// true

If the key expires based on its TTL, it is deleted entirely from the internal data object.

myCache.mset( [ { key, val, ttl? }, ... ] )

Sets multiple key-value pairs at once. Returns true on success.

myCache.mset([
	{ key: "myKey", val: obj, ttl: 10000 },
	{ key: "myKey2", val: obj2 },
]);

myCache.get( key )

Returns the cached value, or undefined if not found or expired.

const value = myCache.get( "myKey" );
if ( value === undefined ) {
	// handle miss
}

myCache.mget( [ key1, key2, ... ] )

Returns an object of found key-value pairs. Missing or expired keys are omitted.

const values = myCache.mget( [ "myKeyA", "myKeyB" ] );
// { "myKeyA": ..., "myKeyB": ... }

myCache.take( key )

Gets the cached value and deletes the key. Equivalent to get(key) + del(key). Useful for single-use values like OTPs.

myCache.set( "otp", "123456" );
const otp = myCache.take( "otp" ); // "123456", key is now deleted

myCache.del( key ) or myCache.del( [ key1, key2, ... ] )

Deletes one or more keys. Returns the number of deleted entries.

myCache.del( "A" );       // 1
myCache.del( [ "B", "C" ] ); // 2

myCache.ttl( key, [ ttl ] )

Redefines the TTL of a key. Returns true if the key exists, false otherwise. If ttl is omitted, the default TTL is used. A ttl < 0 deletes the key.

myCache.ttl( "existentKey", 100 ); // true
myCache.ttl( "missingKey", 100 );  // false

myCache.getTtl( key )

Returns the expiration timestamp (ms) for a key, 0 if no TTL is set, or undefined if the key doesn't exist.

myCache.getTtl( "myKey" );     // 1456000600000
myCache.getTtl( "noTtlKey" );  // 0
myCache.getTtl( "missing" );   // undefined

myCache.keys()

Returns an array of all existing keys.

myCache.keys(); // [ "all", "my", "keys" ]

myCache.has( key )

Returns true if the key exists in the cache, false otherwise.

myCache.has( "myKey" ); // true or false

myCache.getStats()

Returns cache statistics.

myCache.getStats();
// { keys: 0, hits: 0, misses: 0, ksize: 0, vsize: 0 }

myCache.flushAll()

Deletes all cached data and resets statistics.

myCache.flushStats()

Resets hit/miss/size statistics without deleting data.

myCache.close()

Stops the automatic expiry check interval. Call this when you're done with the cache to allow the process to exit cleanly.

Fired when a key is added or changed.

myCache.on( "set", function( key, value ) {
	// ...
});

Fired when a key is removed manually or due to expiry.

myCache.on( "del", function( key, value ) {
	// ...
});

Fired when a key expires.

myCache.on( "expired", function( key, value ) {
	// ...
});

Fired when the cache is flushed.

myCache.on( "flush", function() {
	// ...
});

Fired when the cache stats are flushed.

myCache.on( "flush_stats", function() {
	// ...
});

Benchmark results and charts are available in docs/BENCHMARK_CHARTS.md.

npm run bench        # full suite (median/p95/range)
npm run bench:heap   # heap vs linear comparison (median/range)

Key results (Node v24.12.0 on Windows x64, 7 runs per scenario):

Full TypeScript rewrite. Public API unchanged. Internal functions and names have changed -- if you depend on internal APIs (prefixed with _), review CHANGELOG.md before upgrading. enableLegacyCallbacks removed. Node.js 20+ required.

Callbacks deprecated. Available via enableLegacyCallbacks option (now removed in v6.x). Node.js 8+ required.

Values are cloned by default. Disable with useClones: false.

.get() returns the value directly instead of { key: value }.

See CHANGELOG.md for the complete history.

Contributions are welcome. See CONTRIBUTING.md for the process, RELEASE_POLICY.md for versioning, and MAINTENANCE.md for project scope.

Originally created by @mpneuried and sponsored by Team Centric Software. This fork is maintained by @alexanderpoliser.

Original repository: github.com/node-cache/node-cache

MIT -- Copyright (c) 2019 Mathias Peter and the node-cache maintainers

See LICENSE for the full text.