JavaScript ZIP Libraries for File Compression and Archiving
adm-zip, archiver, jszip, yazl, zip-lib, and zip-stream are JavaScript libraries for creating, reading, and manipulating ZIP archives. They differ significantly in their architecture: some are designed for in-browser use, others for Node.js; some support streaming for memory efficiency, while others load entire archives into memory; and not all support both creation and extraction. These differences make each library better suited for specific scenarios, such as serving dynamic ZIPs from a server, processing large files without memory spikes, or enabling ZIP manipulation directly in a web application.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
JavaScript ZIP Libraries Compared: adm-zip, archiver, jszip, yazl, zip-lib, and zip-stream
When you need to create or extract ZIP files in a JavaScript environment — whether in Node.js or the browser — choosing the right library can make a big difference in performance, memory use, and code clarity. The six packages under review (adm-zip, archiver, jszip, yazl, zip-lib, and zip-stream) all handle ZIP operations but with very different design goals, APIs, and trade-offs. Let’s break down what each does well and where it falls short.
📦 Core Capabilities: Creation vs Extraction vs Streaming
adm-zip: Full-featured ZIP reader/writer for Node.js
adm-zip supports both reading and writing ZIP files, including extracting entries to disk and adding files from buffers or paths. It loads the entire archive into memory, which makes it simple but unsuitable for large files.
// Read and extract
const zip = new AdmZip("./archive.zip");
zip.extractAllTo("./output/");
// Add file and write
zip.addFile("new.txt", Buffer.from("Hello"));
zip.writeZip("./updated.zip");
archiver: High-level streaming ZIP (and TAR) creator
archiver is built on streams and excels at creating ZIPs incrementally without loading everything into memory. It supports compression, directory recursion, and piping to any writable stream (like HTTP responses). However, it cannot read or extract ZIPs.
const archive = archiver('zip');
const output = fs.createWriteStream('archive.zip');
archive.pipe(output);
archive.file('file.txt', { name: 'file.txt' });
archive.finalize();
jszip: Browser-first ZIP manipulation with limited Node support
jszip works well in browsers and can load, modify, and generate ZIPs from memory. In Node.js, it requires additional setup (e.g., using fs.promises to read files as buffers). It doesn’t support streaming and holds everything in RAM.
// Load and add
const zip = await JSZip.loadAsync(fs.readFileSync('input.zip'));
zip.file('new.txt', 'Hello');
const buffer = await zip.generateAsync({ type: 'nodebuffer' });
fs.writeFileSync('output.zip', buffer);
yazl: Low-level, streaming ZIP generator only
yazl (Yet Another Zip Library) is a minimal, streaming-only ZIP writer. It gives fine control over entry metadata and compression but provides no extraction capability. Ideal when you need predictable memory usage and full control over the ZIP structure.
const zipfile = new yazl.ZipFile();
zipfile.addBuffer(Buffer.from('Hello'), 'hello.txt');
zipfile.end();
zipfile.outputStream.pipe(fs.createWriteStream('out.zip'));
zip-lib: Simple promise-based ZIP utility (Node.js only)
zip-lib wraps lower-level libraries to offer a clean promise API for basic tasks like compressing directories or decompressing archives. It’s easy to use but lacks advanced features like streaming or fine-grained entry control.
// Compress a folder
await zipLib.compress('./folder', './archive.zip');
// Extract
await zipLib.extract('./archive.zip', './output');
zip-stream: Barebones streaming ZIP core (used by archiver)
zip-stream is the underlying engine that powers archiver’s ZIP functionality. It’s a transform stream that converts input entries into ZIP format. You typically won’t use it directly unless you’re building your own archiving tool.
const zip = new ZipStream();
const output = fs.createWriteStream('out.zip');
zip.pipe(output);
zip.entry('Hello', { name: 'hello.txt' }, () => {
zip.finish();
});
⚖️ Memory and Performance Trade-offs
- Streaming vs In-Memory:
archiver,yazl, andzip-streamuse streams and scale to large datasets.adm-zip,jszip, andzip-libload everything into memory — avoid them for files >100MB. - Extraction Support: Only
adm-zip,jszip, andzip-libcan extract ZIPs. If you need to read archives, rule outarchiver,yazl, andzip-stream. - Browser Compatibility: Only
jszipis designed for the browser. The others are Node.js-only (they rely onfs,stream, or native modules).
🔧 Real-World Use Cases
Need to serve dynamic ZIPs from an Express route?
Use archiver — it streams directly to the HTTP response without buffering.
app.get('/download', (req, res) => {
res.setHeader('Content-Type', 'application/zip');
const archive = archiver('zip');
archive.pipe(res);
archive.file('report.pdf', { name: 'report.pdf' });
archive.finalize();
});
Building a web app that lets users upload and inspect ZIP contents?
Use jszip — it runs in the browser and handles in-memory archives cleanly.
// In browser
const arrayBuffer = await file.arrayBuffer();
const zip = await JSZip.loadAsync(arrayBuffer);
const text = await zip.file('readme.txt').async('text');
Processing massive log directories into ZIPs on a server?
Use yazl or archiver — both stream and avoid memory spikes.
Just need to zip/unzip a config folder in a CLI tool?
Use zip-lib — its promise API keeps your script concise.
🚫 Deprecated or Limited Packages?
As of 2024:
adm-zipis actively maintained but has known security issues in older versions; always use the latest release.zip-libappears minimally maintained but still functional for basic tasks.- None of the listed packages are officially deprecated, but
yazlandzip-streamare low-level tools best used indirectly viaarchiverunless you need their specific control.
📊 Summary Table
| Package | Create ZIP | Extract ZIP | Streaming | Browser | Best For |
|---|---|---|---|---|---|
adm-zip | ✅ | ✅ | ❌ | ❌ | Simple Node scripts needing full read/write |
archiver | ✅ | ❌ | ✅ | ❌ | Server-side dynamic ZIP generation |
jszip | ✅ | ✅ | ❌ | ✅ | Browser-based ZIP manipulation |
yazl | ✅ | ❌ | ✅ | ❌ | Low-level, high-control ZIP writing |
zip-lib | ✅ | ✅ | ❌ | ❌ | Quick CLI zipping/unzipping |
zip-stream | ✅ | ❌ | ✅ | ❌ | Building custom archiving pipelines |
💡 Final Guidance
- For most Node.js servers: Start with
archiver— it’s robust, streaming, and well-documented. - For browser apps:
jszipis your only realistic choice. - Avoid in-memory libraries (
adm-zip,jszip,zip-lib) when handling user-uploaded or large files. - Don’t use
yazlorzip-streamdirectly unless you’re replacingarchiverfor a specific reason (e.g., bundle size or custom logic).
Choose based on your environment (Node vs browser), data size (small vs large), and whether you need to read, write, or both.
How to Choose: adm-zip vs archiver vs jszip vs yazl vs zip-lib vs zip-stream
- adm-zip:
Choose
adm-zipif you're working in a Node.js environment and need a straightforward, synchronous API for both reading and writing small ZIP files entirely in memory. Avoid it for large archives or streaming scenarios due to its memory footprint. - archiver:
Choose
archiverwhen you need to generate ZIP files dynamically in Node.js with streaming support—ideal for web servers that must pipe ZIPs directly to HTTP responses without buffering everything in memory. Note that it cannot extract or read existing ZIPs. - jszip:
Choose
jszipfor browser-based applications where users need to upload, inspect, or download ZIP files entirely client-side. It also works in Node.js but requires manual file I/O and isn't suitable for large files due to its in-memory model. - yazl:
Choose
yazlonly if you require fine-grained, low-level control over ZIP creation in Node.js with streaming output and want to avoid higher-level abstractions. It’s a good fit for custom tooling but overkill for typical use cases already covered byarchiver. - zip-lib:
Choose
zip-libfor simple command-line or scripting tasks in Node.js where you need a clean promise-based API to compress folders or extract archives quickly. It’s not suitable for streaming, large files, or browser environments. - zip-stream:
Choose
zip-streamonly if you're building your own archiving pipeline and need the raw streaming ZIP engine that powersarchiver. For almost all practical purposes,archiveris a more complete and user-friendly alternative.
Popular Comparisons
README for adm-zip
ADM-ZIP for NodeJS
ADM-ZIP is a pure JavaScript implementation for zip data compression for NodeJS.
Installation
With npm do:
$ npm install adm-zip
Electron file system support described below.
What is it good for?
The library allows you to:
- decompress zip files directly to disk or in memory buffers
- compress files and store them to disk in .zip format or in compressed buffers
- update content of/add new/delete files from an existing .zip
Dependencies
There are no other nodeJS libraries that ADM-ZIP is dependent of
Examples
Basic usage
var AdmZip = require("adm-zip");
// reading archives
var zip = new AdmZip("./my_file.zip");
var password = "1234567890";
var zipEntries = zip.getEntries(); // an array of ZipEntry records - add password parameter if entries are password protected
zipEntries.forEach(function (zipEntry) {
console.log(zipEntry.toString()); // outputs zip entries information
if (zipEntry.entryName == "my_file.txt") {
console.log(zipEntry.getData().toString("utf8"));
}
});
// outputs the content of some_folder/my_file.txt
console.log(zip.readAsText("some_folder/my_file.txt"));
// extracts the specified file to the specified location
zip.extractEntryTo(/*entry name*/ "some_folder/my_file.txt", /*target path*/ "/home/me/tempfolder", /*maintainEntryPath*/ false, /*overwrite*/ true);
// extracts everything
zip.extractAllTo(/*target path*/ "/home/me/zipcontent/", /*overwrite*/ true);
// creating archives
var zip = new AdmZip();
// add file directly
var content = "inner content of the file";
zip.addFile("test.txt", Buffer.from(content, "utf8"), "entry comment goes here");
// add local file
zip.addLocalFile("/home/me/some_picture.png");
// get everything as a buffer
var willSendthis = zip.toBuffer();
// or write everything to disk
zip.writeZip(/*target file name*/ "/home/me/files.zip");
// ... more examples in the wiki
For more detailed information please check out the wiki.
Electron original-fs
ADM-ZIP has supported electron original-fs for years without any user interractions but it causes problem with bundlers like rollup etc. For continuing support original-fs or any other custom file system module. There is possible specify your module by fs option in ADM-ZIP constructor.
Example:
const AdmZip = require("adm-zip");
const OriginalFs = require("original-fs");
// reading archives
const zip = new AdmZip("./my_file.zip", { fs: OriginalFs });
.
.
.