ZIP Archive Handling in Node.js and the Browser
These libraries provide tools for creating, reading, and manipulating ZIP archives in JavaScript environments. adm-zip, archiver, jszip, node-zip, zip-a-folder, and zip-lib each offer different approaches to compression, ranging from synchronous file manipulation to streaming pipelines and browser-compatible async APIs. Developers choose between them based on whether they need server-side streaming, client-side compatibility, or simple synchronous access to zip contents.
Npm Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
ZIP Archive Handling in Node.js and the Browser
Managing ZIP files is a common requirement in web development, whether you are generating reports on a server or letting users download assets in a browser. The ecosystem offers several tools like adm-zip, archiver, jszip, node-zip, zip-a-folder, and zip-lib, but they solve different problems. Some focus on streaming large files, while others prioritize browser compatibility or synchronous simplicity. Let's compare how they handle real-world tasks.
šļø Creating Archives: Streaming vs In-Memory
archiver is built for streaming.
- It pipes data directly to a file or HTTP response.
- Best for large files because it does not load everything into RAM.
// archiver: Stream to file
const archiver = require('archiver');
const output = fs.createWriteStream('archive.zip');
const archive = archiver('zip');
archive.pipe(output);
archive.file('file1.txt', { name: 'file1.txt' });
archive.finalize();
adm-zip works in memory synchronously.
- It loads the whole archive into memory before writing.
- Simple for small scripts but blocks the event loop.
// adm-zip: Write to file synchronously
const AdmZip = require('adm-zip');
const zip = new AdmZip();
zip.addLocalFile('file1.txt');
zip.writeZip('archive.zip');
jszip works in memory asynchronously.
- It builds the archive in RAM then generates a blob or buffer.
- Great for browsers where streaming to disk is not possible.
// jszip: Generate async buffer
const JSZip = require('jszip');
const zip = new JSZip();
zip.file('file1.txt', 'content');
const content = await zip.generateAsync({ type: 'nodebuffer' });
fs.writeFileSync('archive.zip', content);
node-zip creates archives synchronously.
- It takes a string or buffer and returns a ZIP buffer.
- Limited flexibility compared to modern streaming tools.
// node-zip: Create from string
const zip = require('node-zip');
const z = new zip();
z.file('file1.txt', 'content');
const data = z.generate({ base64: false });
fs.writeFileSync('archive.zip', data, 'binary');
zip-a-folder targets directory archiving.
- It simplifies zipping a whole folder recursively.
- Less control over individual file entries.
// zip-a-folder: Zip entire folder
const zipFolder = require('zip-a-folder');
await zipFolder.zip('./source-folder', './archive.zip');
zip-lib offers a direct API for compression.
- It provides functions to zip files or folders directly.
- Similar to
adm-zipbut with a different method structure.
// zip-lib: Zip files
const zip = require('zip-lib');
await zip.archive(['file1.txt'], 'archive.zip');
š„ Extracting Content: Sync vs Async
adm-zip extracts files synchronously.
- You can read entries or extract all at once.
- Fast for small archives but blocks execution.
// adm-zip: Extract all
const zip = new AdmZip('archive.zip');
zip.extractAllTo('./destination', true);
archiver does not handle extraction.
- It is designed only for creating archives.
- You need a different library like
unzipperfor reading.
// archiver: N/A (Creation only)
// Developers typically pair archiver with unzipper for extraction
jszip extracts data asynchronously.
- You load the file then access entries via promises.
- Works consistently in Node and browser environments.
// jszip: Read content async
const JSZip = require('jszip');
const zip = await JSZip.loadAsync(fs.readFileSync('archive.zip'));
const file = await zip.file('file1.txt').async('string');
node-zip reads data synchronously.
- It parses the ZIP buffer into an object.
- Limited support for complex archive structures.
// node-zip: Read entries
const z = new zip(fs.readFileSync('archive.zip'));
const content = z.files['file1.txt'].data;
zip-a-folder does not handle extraction.
- It is a utility specifically for creating zips from folders.
- Use
adm-ziporjszipif you need to unzip.
// zip-a-folder: N/A (Creation only)
// No built-in extraction methods provided
zip-lib supports extraction asynchronously.
- It provides an
extractfunction for unpacking archives. - Handles promises for better flow control.
// zip-lib: Extract files
const zip = require('zip-lib');
await zip.extract('archive.zip', './destination');
š Environment Support: Node vs Browser
adm-zip runs on Node.js only.
- It relies on Node's file system module.
- Cannot be used in frontend code without bundling shims.
// adm-zip: Node.js only
const AdmZip = require('adm-zip'); // Fails in browser
archiver runs on Node.js only.
- It depends on Node streams and file handles.
- Strictly a backend library for server tasks.
// archiver: Node.js only
const archiver = require('archiver'); // Fails in browser
jszip runs everywhere.
- It has no dependencies on Node-specific APIs.
- The go-to choice for frontend ZIP manipulation.
// jszip: Universal
const JSZip = require('jszip'); // Works in Node and Browser
node-zip runs on Node.js only.
- It was built for server-side JavaScript.
- Not suitable for client-side applications.
// node-zip: Node.js only
const zip = require('node-zip'); // Fails in browser
zip-a-folder runs on Node.js only.
- It uses Node's file system to traverse folders.
- Designed for build scripts or server utilities.
// zip-a-folder: Node.js only
const zipFolder = require('zip-a-folder'); // Fails in browser
zip-lib runs on Node.js only.
- It interacts with the file system directly.
- Best for backend automation tasks.
// zip-lib: Node.js only
const zip = require('zip-lib'); // Fails in browser
ā ļø Maintenance and Stability
adm-zip is stable and widely used.
- It receives updates for security and bug fixes.
- A safe choice for long-term Node.js projects.
archiver is actively maintained.
- It is the industry standard for streaming archives.
- Highly recommended for production server code.
jszip is actively maintained.
- It supports modern JavaScript features.
- The best option for cross-environment compatibility.
node-zip is deprecated.
- It has not seen significant updates in years.
- Do not use for new projects; switch to
adm-ziporarchiver.
zip-a-folder has limited maintenance.
- It is a niche utility with fewer contributors.
- Use with caution for critical infrastructure.
zip-lib has moderate maintenance.
- It is less popular than
archiverorjszip. - Verify current issue tracking before adopting.
š Summary: Capabilities Overview
| Package | Environment | API Style | Streaming | Extraction | Status |
|---|---|---|---|---|---|
adm-zip | Node | Sync | ā | ā | Stable |
archiver | Node | Stream | ā | ā | Stable |
jszip | Both | Async | ā | ā | Stable |
node-zip | Node | Sync | ā | ā | Deprecated |
zip-a-folder | Node | Async | ā | ā | Niche |
zip-lib | Node | Async | ā | ā | Moderate |
š” Final Recommendation
archiver is the top pick for backend servers š„ļø ā use it when you need to stream large files to a user without crashing your memory. It pairs well with Express or similar frameworks for download endpoints.
jszip is the top pick for frontend apps š ā use it when you need to create or read ZIPs directly in the browser. It is the only robust choice that works universally.
adm-zip is the top pick for simple scripts š ā use it for quick build tools or local CLI commands where streaming is not needed and simplicity is key.
Avoid node-zip š« ā it is outdated and lacks the features of modern alternatives. Stick to the actively maintained options for security and reliability.
How to Choose: adm-zip vs archiver vs jszip vs node-zip vs zip-a-folder vs zip-lib
- adm-zip:
Choose
adm-zipif you need a pure JavaScript solution for Node.js that works synchronously with local files. It is ideal for scripts that need to quickly read or extract small to medium-sized archives without managing streams. Avoid it for large files or server responses where memory usage and blocking the event loop are concerns. - archiver:
Choose
archiverif you are building a server-side application that needs to stream ZIP files directly to a response or disk. It handles large datasets efficiently by processing data in chunks rather than loading everything into memory. It is the standard choice for backend APIs that generate downloadable archives on the fly. - jszip:
Choose
jszipif your code needs to run in both the browser and Node.js environments. It offers a flexible async API that works well for manipulating archive contents in memory before saving or downloading. It is perfect for frontend tools that let users upload, modify, and download ZIP files without server interaction. - node-zip:
Avoid
node-zipfor new projects as it is largely considered deprecated and unmaintained compared to modern alternatives. It was historically used for basic ZIP creation but lacks the streaming capabilities and active support ofarchiveroradm-zip. Evaluateadm-ziporarchiverinstead for better long-term stability. - zip-a-folder:
Choose
zip-a-folderif you have a very specific need to recursively zip an entire directory structure with minimal configuration. It acts as a utility wrapper that simplifies the process of archiving folders without writing boilerplate code. Use it for quick scripts where fine-grained control over the archive stream is not required. - zip-lib:
Choose
zip-libif you need a lightweight library focused on specific compression tasks in Node.js. It provides a straightforward API for zipping and unzipping files but has a smaller ecosystem thanarchiverorjszip. Verify its maintenance status before adopting it for critical production infrastructure.
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 });
.
.
.