How to archive previewer vs unzip / 7z cli / winrar
- Step 1Decide what you actually need — Just the file list and shape? The previewer is faster to reach. Need exact 7Z compressed sizes or to script across 500 archives? A CLI fits better.
- Step 2For a one-off, use the previewer — Drop the archive into archive-previewer and press Process. No flags to remember, no per-format tool to pick.
- Step 3For ZIP detail, compare like-for-like — The previewer's ZIP table mirrors
unzip -l: name, size, compressed, method, CRC, timestamp — all from the central directory, no extraction. - Step 4For non-ZIP compressed sizes, use the CLI —
7z l archive.7zandtar -tvzf archive.tar.gzsurface per-entry compressed sizes and timestamps the previewer doesn't expose for those formats. - Step 5For batch or pipelines, script the CLI — or the runner — Loop
7z lin a shell for many files, or on Pro+ drive the previewer through the local @jadapps/runner for a scripted, still-local browser run. - Step 6Share the result — From the previewer, Download the HTML report. From a CLI, redirect output to a file (
unzip -l x.zip > list.txt). The HTML keeps the tree structure intact.
Feature matrix: Archive Previewer vs the CLIs
Listing-only comparison (none of these extract in this workflow). 'ZIP detail' means name, real compressed size, method, CRC and per-entry timestamp.
| Capability | Archive Previewer | unzip -l | 7z l | tar -tvf | WinRAR |
|---|---|---|---|---|---|
| Install required | None (browser) | Usually preinstalled | p7zip / 7-Zip | Preinstalled (Unix) | Windows install |
| ZIP listing | Yes (central dir) | Yes | Yes | No | Yes |
| 7Z / RAR / XZ / ISO listing | Yes (libarchive WASM) | No | 7Z/some; RAR no | No | 7Z/RAR yes |
| TAR / GZIP listing | Yes (fflate) | No | Some | Yes | Yes |
| Real compressed size (non-ZIP) | No (= Size) | n/a | Yes | Yes (-v) | Yes |
| Per-entry timestamp (non-ZIP) | No (file date) | n/a | Yes | Yes (-v) | Yes |
| Detect by magic bytes | Yes | By content | By content | By content | By content |
| Shareable output file | HTML download | Redirect text | Redirect text | Redirect text | Manual |
| Scriptable / batch | Via runner (Pro+) | Yes | Yes | Yes | Limited |
What each surfaces for a ZIP entry
For ZIP specifically the previewer reads the same central-directory fields the CLIs do — the parity is real here.
| Field | Archive Previewer (ZIP) | unzip -l | 7z l |
|---|---|---|---|
| Entry name | Yes | Yes | Yes |
| Uncompressed size | Yes | Yes | Yes |
| Compressed size | Yes (real) | No (use -v) | Yes |
| Compression method | Yes (Deflate/Stored/LZMA/AES…) | No | Yes |
| CRC-32 | Parsed | No (use -v) | Yes |
| Timestamp | Yes (DOS date/time) | Yes | Yes |
| Encryption flag | Yes | Implicit | Yes |
What the previewer reads per format
Format is detected from the file's magic bytes (the first 8 bytes), not the extension. ZIP is parsed from its central directory with zero decompression; every other format is decoded in full to enumerate entries, which changes which columns are accurate.
| Input format | Detected by | Engine | Decompresses to list? | Per-entry detail available |
|---|---|---|---|---|
ZIP (.zip, .jar, .apk, .docx…) | PK (50 4B) | Raw central-directory parse | No — metadata only | Name, real compressed + uncompressed size, method (Deflate/Stored/BZIP2/LZMA/XZ/PPMd/AES), CRC-32, per-entry timestamp, encryption flag, comment |
TAR (.tar) | ustar at offset 257 | fflate | Yes (in memory) | Name + uncompressed size; compressed column mirrors size; timestamp falls back to the archive file's date |
GZIP (.gz) | 1F 8B | fflate | Yes | Single inner file; original name read from the GZIP header when present |
7Z (.7z) | 37 7A BC AF 27 1C | libarchive WASM | Yes | Name + uncompressed size; no real compressed size, method, or CRC surfaced |
RAR (.rar) | Rar! (52 61 72 21) | libarchive WASM | Yes | Name + uncompressed size; many RAR4/RAR5 archives read, some encrypted RAR5 do not |
| BZIP2 / XZ / ISO | magic bytes | libarchive WASM | Yes | Name + uncompressed size only |
Cookbook
Concrete head-to-heads — the same archive through the previewer and through a CLI, so you can see where they agree and where they diverge.
ZIP listing — previewer vs unzip -l
For ZIP the two agree on the substance. The previewer additionally shows the compression method without a verbose flag.
$ unzip -l build.zip
Length Date Time Name
--------- ---------- ----- ----
41234 2026-05-01 09:12 app.js
2110 2026-05-01 09:12 index.html
Previewer (build.zip — 2 entries (ZIP)):
Name Size Compressed Method
app.js 40.3 KB 12.1 KB Deflate
index.html 2.1 KB 0.9 KB Deflate7Z compressed sizes — CLI wins
This is the previewer's honest gap. For 7Z it lists names and uncompressed sizes; 7z l shows the real compressed sizes per entry.
$ 7z l backup.7z Date Time Attr Size Compressed Name ---- ---- ---- ------ ---------- ---- 2026-05-01 ... ....A 28.6M 3.1M access.log Previewer (backup.7z — 1 entry (7Z)): Name Size Compressed Method access.log 28.6 MB 28.6 MB (blank) → Compressed mirrors Size; method not surfaced.
Inspect a .7z with no software installed
On a machine with no 7-Zip and no admin rights, the CLI route is a dead end. The previewer's WASM engine reads it anyway.
$ 7z l backup.7z bash: 7z: command not found Previewer: backup.7z — 1,902 entries (7Z) Full tree + top-200 table render in the browser. No install, no admin rights needed.
Format detection on a mislabelled file
A file saved with the wrong extension trips up extension-based assumptions but not the previewer's magic-byte sniff.
$ unzip -l data.bin Archive: data.bin cannot find zipfile directory ... (extension-confused) Previewer: data.bin — 318 entries (ZIP) → magic bytes (PK) win; extension ignored.
Shareable artifact vs terminal text
Sending a colleague the structure of an archive is one click from the previewer; from a CLI you redirect and paste.
CLI: unzip -l release.zip > listing.txt (flat text, tree lost) Previewer: Download → release-preview.html Opens in any browser, keeps the nested folder tree, no archive shared — just the listing.
Edge cases and what actually happens
You need real 7Z/RAR compressed sizes
Use a CLIThe previewer surfaces real compressed size only for ZIP. For 7Z/RAR/TAR it shows uncompressed size in both columns. 7z l or tar -tvzf is the right tool when you need true per-entry compression numbers.
You need per-entry timestamps for a 7Z
Use a CLINon-ZIP previews fall back to the archive file's date for every entry. 7z l and tar -tvf print real modification times. The previewer is accurate here only for ZIP.
Batch-listing hundreds of archives
CLI / runnerA shell loop over 7z l is the simplest way to list many archives. On Pro+ you can instead drive the previewer through the local @jadapps/runner, but a one-liner CLI loop is usually less ceremony for pure listing.
No software can be installed
Previewer winsOn a restricted machine with no unzip/7z/unrar and no admin rights, the CLIs simply aren't available. The browser previewer reads ZIP, 7Z, RAR, TAR and more with nothing to install.
Untrusted, possibly malicious archive
Previewer saferListing an untrusted archive with a native binary runs that binary against attacker-controlled bytes. The previewer parses inside the browser sandbox and never decompresses ZIP at all, reducing the surface for a malformed-header exploit.
Archive over your tier's size cap
BlockedA CLI lists archives of any size your disk holds. The previewer enforces 50 MB (Free) / 500 MB (Pro) / 2 GB (Pro + Media, Developer). Past those, use a CLI or upgrade.
Encrypted-header 7Z that needs a password to list
May failSome 7Z archives encrypt the header itself, so even listing needs the password; libarchive may fail to enumerate without it. 7z l will prompt for the password. ZIP headers stay readable regardless.
You want a saved, structured report
Previewer winsThe previewer's Download gives a self-contained HTML tree+table. CLIs give flat redirected text that loses the nesting. For an audit trail, the HTML or a file-listing-generator CSV/JSON is cleaner.
Frequently asked questions
Is the previewer faster than `unzip -l`?
For ZIP, comparably fast and sometimes faster, because both read only the central directory — no decompression. For 7Z/RAR/TAR the previewer must fully decode the archive to enumerate entries, so for those formats a native 7z l (which reads the 7Z header index) can be quicker on very large files. The previewer's win is access, not raw speed.
Does the previewer match `unzip -l` exactly for ZIP?
On substance, yes — same entry names, uncompressed sizes, and timestamps from the same central directory. It additionally shows the compression method and real compressed size that unzip -l only prints with the -v verbose flag, and it lays the result out as a tree plus table rather than flat text.
Why does `7z l` show compressed sizes the previewer doesn't?
7-Zip reads the 7Z format's internal index, which carries per-entry compressed sizes. The previewer decodes 7Z via libarchive to list entries but only reports uncompressed length, so its Compressed column mirrors Size for 7Z. For real ratios use compression-ratio-calculator.
Can I script the previewer like a CLI?
On Pro and above you can dispatch it through the local @jadapps/runner — a short-lived headless Chromium on your own machine — so it runs without a server and without a UI. For pure listing across many files, though, a shell loop over unzip -l / 7z l is often simpler. There is no public HTTP API; archive tools are browser-only.
Which is more private — browser or CLI?
Both keep your bytes local. The CLI runs a native binary you trust; the previewer runs a browser parse in a sandbox and, for ZIP, never decompresses at all. For an untrusted or possibly malicious archive, the sandboxed browser path has a smaller blast radius than feeding it to a native unarchiver.
Does the previewer extract or decompress my archive?
For ZIP, no. It reads only the central directory — the index ZIP keeps at the end of the file — so a 1 GB ZIP with 50,000 entries lists in well under a second because no compressed bytes are touched. For every other format (7Z, RAR, TAR, GZIP, BZIP2, XZ, ISO) it must decode the whole archive in memory to enumerate entries, because those containers have no detached index a browser can parse. Nothing is written to disk and nothing is uploaded either way.
Why is the Compressed column equal to the Size column for my 7Z or TAR?
Because the previewer only has the real per-entry compressed size for ZIP, which it reads straight from the central directory. For 7Z, RAR, TAR, GZIP and the libarchive-handled formats it decodes the entries and reports the uncompressed byte length in both columns. So treat the Compressed column as meaningful for ZIP only. If you need true compressed-vs-original numbers for a non-ZIP archive, use compression-ratio-calculator.
Are timestamps in the tree accurate?
For ZIP, yes — each entry's DOS date/time is decoded from the central directory. For non-ZIP formats the previewer does not surface per-entry timestamps; it falls back to the archive file's own last-modified date for every entry. To normalise or inspect ZIP timestamps specifically, see timestamp-normalizer.
Can it preview password-protected archives?
For ZIP, yes — filenames in a ZIP central directory are stored in the clear even when the file data is AES-256 or ZipCrypto encrypted, so the tree and table render fine and the entry simply shows an encryption flag. The previewer never asks for or needs the password because it does not decompress ZIP data. Encrypted 7Z/RAR that libarchive cannot open without a password may fail to enumerate. To actually unlock and pull files, use multi-format-extractor.
Is there any options panel to configure?
No. The previewer has zero options — you drop one archive and press Process. There is no glob filter, no sort toggle, no depth slider. If you need to filter the listing by pattern, generate a CSV/JSON listing, or limit recursion, those are separate sibling tools: selective-extractor, file-listing-generator, and nested-archive-extractor.
How is the format detected — by extension?
By magic bytes, not extension. The first eight bytes are checked: PK for ZIP, 1F 8B for GZIP, BZh for BZIP2, the XZ and 7Z signatures, Rar! for RAR, and ustar at offset 257 for TAR. A .zip renamed to .bin still previews correctly; a corrupt header that matches nothing falls through to a best-effort ZIP attempt and otherwise errors.
Why do only 200 files show in the table?
The flat table is capped at the 200 largest files by uncompressed size so the HTML stays responsive. The folder tree above it is not capped — it renders every entry — and the header line reports the true total entry count. If you need a complete machine-readable listing of all entries, run file-listing-generator for CSV, JSON, or a full text tree.
Do my files get uploaded?
No. Archive tools are browser-only — there is no server-side path. The bytes are read by FileReader, parsed by fflate / libarchive WASM locally, and the result is rendered in the same tab. The result panel shows a 0 bytes uploaded badge. On Pro and above, scripted runs go through the local @jadapps/runner (a short-lived headless Chromium on your own machine), still without leaving your hardware.
When should I just use WinRAR or 7-Zip?
When you need to extract, repair, set passwords on, or batch-process archives on the desktop, or when you need exact non-ZIP compressed sizes and timestamps. For a fast, no-install, shareable look at what's inside — especially on a machine where you can't install anything — the previewer is the lighter path.
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.