How to nested archive extractor online
- Step 1Open the tool on a Pro account — Go to /archive-tools/nested-archive-extractor. This tool has a minimum tier of Pro — on the free tier the page shows an upgrade overlay (
Nested Archive Extractor requires the Pro plan.) instead of the dropzone. - Step 2Drop the outer archive — Drag one archive into the dropzone (single file — this tool does not take a folder or a batch). The outer layer can be any format the suite reads: zip, gz, tar, tgz, bz2, xz, 7z, rar, or iso.
- Step 3Set the recursion depth — Adjust maxDepth if needed. Default is 3 (outer + two inner layers). Min 1, max 10. The schema note is honest: depths beyond 5 raise memory pressure sharply because every layer is decompressed fully into memory before the next is opened.
- Step 4Run — Click Process. The tool unpacks the outer archive, detects inner archives by file extension, and recurses depth by depth. There is no progress bar per layer — large or deep inputs simply take longer.
- Step 5Read the metrics — The result panel reports Recursion depth, Archives unpacked (how many nested archives were opened), and Entries (total leaf files in the output). Compare Entries against your tier's entry limit if the output looks short.
- Step 6Download the flattened ZIP — Click Download to save
<archive>-flattened.zip. Every file sits at its nested path, e.g.backup.zip/2026-06/logs.tar.gz/app.log. Re-import it anywhere, or run path-prefix-remover to drop the leading folder names.
What the tool reads at each layer
Inner archives are detected by file extension, then opened with whichever engine supports the format. libarchive formats are read-only — the output is always a ZIP regardless of input format.
| Format (extension) | Read engine | Unpacked when nested? | Notes |
|---|---|---|---|
ZIP (.zip) | fflate (or @zip.js/zip.js if any entry is encrypted) | Yes | Plaintext ZIPs unpack via fflate. Encrypted entries need a password the nested tool cannot supply — see edge cases. |
GZIP (.gz) | fflate | Yes | Single-member gzip; the inner filename is read from the GZIP header when present, else derived from the .gz name. |
TAR (.tar) | fflate tar parser | Yes | Uncompressed tar. A .tar.gz is opened as gz first, then the inner .tar recurses on the next layer. |
TGZ (.tgz) | magic-byte fallback (gz, then tar) | Yes | .tgz is listed as an archive extension and decoded by content, not by the literal .tgz name. |
7-Zip (.7z) | libarchive WASM | Yes (read only) | Read-only. The 7z's contents are extracted and re-packed into the output ZIP — the output is never a true 7z. |
RAR (.rar) | libarchive WASM | Yes (read only) | Read-only via libarchive. Encrypted/solid RARs may fail to open and are then preserved as raw bytes. |
BZ2 / XZ (.bz2, .xz) | libarchive WASM | Yes (read only) | Detected by magic bytes when opened; the decompressed payload is added to the output ZIP. |
Depth, output and tier facts
Real defaults and limits read from the option schema, processor, and tier table. This tool requires Pro or higher to run.
| Property | Value | Source / behaviour |
|---|---|---|
| maxDepth default | 3 | Outer archive + two inner layers. Member at depth > maxDepth is stored unexpanded. |
| maxDepth range | 1 to 10 | Clamped in code: Math.max(1, Math.min(10, maxDepth)). The schema warns memory pressure rises sharply past 5. |
| Output format | ZIP (DEFLATE level 6) | Always a single flattened ZIP, regardless of input format. Filename: <stem>-flattened.zip. |
| Path layout | <archive>/<inner>/<file> | Each nested archive contributes a path prefix so leaf files keep their full lineage. |
| Minimum tier | Pro | Free tier shows a Pro upgrade overlay and cannot run the tool. |
| File size cap | Pro 500 MB · Pro-media / Developer 2 GB | Per-job input cap by tier (free 50 MB, but free cannot run this tool). |
| Entry-count cap | Pro 50,000 · Pro-media / Developer 500,000 | Counts every leaf file flattened into the output — deep trees inflate this fast. |
Cookbook
Real nested-archive shapes and exactly what the flattened output looks like. Paths shown are the actual prefixing the tool applies.
ZIP of ZIPs — the classic backup bundle
A backup archive whose top level is just more ZIPs. With default depth 3, the outer and both inner layers unpack; leaf files land at their full path.
Input: backup.zip
2026-05.zip
invoices/may.csv
2026-06.zip
invoices/jun.csv
Run: maxDepth = 3 (default)
Output: backup-flattened.zip
2026-05.zip/invoices/may.csv
2026-06.zip/invoices/jun.csv
Metrics: Recursion depth 3 · Archives unpacked 3 · Entries 2tar.gz inside a zip inside a zip
Mixed formats across layers. The .gz is opened, then the inner .tar recurses on the next layer, so the compressed log bundle is fully flattened.
Input: release.zip
artifacts.zip
logs.tar.gz (gzip of a tar)
build/out.log
build/err.log
Run: maxDepth = 4
Output: release-flattened.zip
artifacts.zip/logs.tar.gz/build/out.log
artifacts.zip/logs.tar.gz/build/err.log
Metrics: Archives unpacked 4 (zip + zip + gz + tar)A 7z buried two levels deep
fflate cannot read 7z, but the libarchive bridge can. The 7z is read and its files are re-packed into the output ZIP — the output stays a ZIP.
Input: vendor.zip
drop/payload.7z
config/settings.json
config/keys.txt
Run: maxDepth = 3 (default)
Output: vendor-flattened.zip
drop/payload.7z/config/settings.json
drop/payload.7z/config/keys.txt
Note: output is a ZIP, never a 7z (libarchive is read-only here).Depth limit stops a deep tree early
Lower the depth to keep deeply buried inner archives sealed. Anything past maxDepth is stored as the raw archive file rather than recursed.
Input: nest.zip -> a.zip -> b.zip -> c.zip -> secret.txt Run: maxDepth = 2 Output: nest-flattened.zip a.zip/b.zip <- stored unexpanded (depth limit hit) Raise to maxDepth = 4 to reach secret.txt.
One corrupt member, the rest still extract
A truncated inner ZIP would abort most extractors. Here the failing member is preserved as raw bytes and every other file still comes through.
Input: dump.zip good.zip -> data/ok.csv broken.zip -> (truncated, fails to open) Output: dump-flattened.zip good.zip/data/ok.csv broken.zip <- raw bytes, not unpacked Metrics: Archives unpacked 2 (outer + good.zip)
Edge cases and what actually happens
Free tier opens the page
Pro requiredNested Archive Extractor has a minimum tier of Pro. On the free tier the page renders a Pro upgrade overlay (Nested Archive Extractor requires the Pro plan.) and the dropzone never appears. Earlier copy claiming a free 50 MB tier was wrong — the free per-job byte cap exists in the table but free accounts cannot run this specific tool.
Encrypted inner ZIP
Preserved (raw)This tool exposes only a maxDepth option — there is no password field. A password-protected inner ZIP or 7z fails to open during recursion, so the catch path stores it as raw bytes in the output. Decrypt it first with multi-format-extractor, which does take a password, then re-run nesting on the decrypted result.
Depth exceeds maxDepth
By designWhen recursion reaches depth > maxDepth, the current archive is written to the output unexpanded (its raw bytes under the accumulated path prefix) instead of being opened. Raise maxDepth to go deeper — the hard ceiling is 10.
Member is not actually an archive despite its name
Preserved (raw)Detection during recursion is by file extension. A file named notes.zip that is really plain text will be handed to the extractor, fail, and be preserved as raw bytes. No data is lost; it simply is not flattened.
Real archive with no archive-style extension
Not recursedThe recursion only re-opens entries whose name ends in a known archive extension. A nested tar saved as payload.bin is treated as a leaf file and copied through verbatim — it will not be unpacked even though libarchive could read it.
Zero-byte inner archive
Not recursedAn entry is only recursed when its byte length is greater than zero. A 0-byte empty.zip placeholder is written straight to the output as a leaf rather than being opened.
Output entry count over the tier cap
Limit reachedFlattening multiplies entries — a tree of many small archives can produce tens of thousands of leaf files. Pro caps at 50,000 entries; Pro-media and Developer at 500,000. Past the cap, lower maxDepth or split the input and use batch-extraction-manager for the outer layer.
Input over the per-job size limit
Rejected (limit)If the dropped file exceeds your tier's byte cap (Pro 500 MB, Pro-media/Developer 2 GB) the run is blocked with File "<name>" exceeds the <tier> tier per-job limit. The check is on the input archive size, before any decompression.
Duplicate paths across nested archives
Last write winsLeaf files are collected into one map keyed by full path. Two different inner archives that produce the same prefixed path would collide; in practice the path prefix (<archive>/...) keeps them distinct, but identically-named sibling files inside the same inner archive map to the same key and the later one wins.
Browser extension blocks WebAssembly
Fails to loadlibarchive runs as WASM. A strict content blocker or locked-down CSP that disallows wasm-eval will stop the 7z/rar/bz2/xz path from loading. ZIP/GZIP/TAR via fflate still work; allow WebAssembly for the tab to unlock the libarchive formats.
Frequently asked questions
Is the Nested Archive Extractor free?
No. Its minimum tier is Pro. On the free tier the tool page shows a Pro upgrade overlay instead of the dropzone, so a free account cannot run it. Pro raises the per-job cap to 500 MB / 50,000 entries; Pro-media and Developer go to 2 GB / 500,000 entries.
Does it upload my files?
No. The whole pipeline runs in your browser through fflate, @zip.js/zip.js, and libarchive WASM. There is no server-side path for archive tools. Open DevTools → Network during a run and you will see zero outbound requests carrying your data.
How deep does it go?
As deep as maxDepth, which defaults to 3 (outer + two inner layers) and can be set from 1 to 10. Anything beyond the limit is stored unexpanded rather than recursed. The schema warns that depths past 5 raise memory pressure sharply because each layer is fully decompressed in memory.
What formats can it unpack?
At each layer it re-opens entries ending in .zip, .gz, .tar, .tgz, .bz2, .7z, .rar, or .xz. ZIP/GZIP/TAR use fflate; 7z/rar/bz2/xz/iso use libarchive WASM (read-only). Encrypted ZIPs route through @zip.js/zip.js but only when a password is available — which this tool does not collect.
What does the output look like?
Always a single flattened ZIP named <archive>-flattened.zip, DEFLATE level 6. Every leaf file keeps its full nested path, e.g. backup.zip/2026-06/logs.tar.gz/app.log. The output is a ZIP even when the input contained 7z or rar members.
Can it produce a 7z or rar?
No. libarchive in the browser reads those formats but does not write them here. A nested 7z is read and its contents are re-packed into the output ZIP. The suite's archive-format-converter only writes zip, tar.gz, or gz — no JAD archive tool writes true 7z or rar in-browser.
An inner archive is password-protected — what happens?
This tool has no password field, so an encrypted inner archive fails to open during recursion and is preserved as raw bytes in the output. Decrypt it first with multi-format-extractor (which accepts a password), then run nesting on the result.
Why is a file not getting unpacked even though it is an archive?
Recursion is triggered by file extension. If the nested archive has a non-archive extension (e.g. payload.bin), or is zero bytes, it is treated as a leaf and copied through unchanged. Rename it to a recognised extension, or extract that layer separately first.
What if a member is corrupt?
The run does not abort. The failing member is caught and written to the output as raw bytes, and every other file still extracts. The metrics panel's Archives unpacked count will be lower than the number of nested archives present.
Can I extract several archives at once?
Not with this tool — it takes a single input file. For many separate archives in one pass, use batch-extraction-manager; to flatten nesting inside each, run them through this tool individually.
Does it have an API or CLI?
No public API — apiAvailable is false for archive tools because they depend on browser WASM (Pro+ tiers can run them through a headless-browser runner). For scripted depth-limited unpacking, a shell loop over unzip/7z is the equivalent; see the developer-workflow guide.
Which browsers work?
Any browser with WebAssembly: Chrome, Edge, Firefox, Safari, Brave, Opera, plus mobile Chrome/Safari. Very large or deep archives can exceed mobile device memory because every layer is decompressed in full before the next opens.
Privacy first
Every JAD Archive tool runs entirely in your browser using fflate, @zip.js/zip.js, and the libarchive WASM bridge. Your archives never leave your device — verified by zero outbound network requests during processing.