How to troubleshooting file type breakdown
- Step 1Check the size and entry caps first — Free rejects archives over 50 MB or with more than 500 entries; Pro allows 500 MB / 50,000; Pro-media and Developer 2 GB / 500,000. Both checks run before processing, so a rejection here is immediate and is the most common cause of 'it did nothing'.
- Step 2Confirm the real format — Run auto-format-detector on the file. The tool detects format by magic bytes, so a renamed file (a RAR saved as
.zip) is read by its true type — but if detection fails entirely, the file may be corrupt or not an archive. - Step 3Sanity-check a surprising ratio — A 0.0% ratio everywhere means the input is not a ZIP. Only ZIP exposes per-entry compressed sizes; all other formats are decompressed first, so compressed equals uncompressed. This is correct behaviour, not an error.
- Step 4Sanity-check a single-row result — A lone row usually means you fed a bare
.gz, which holds exactly one member. If you expected many types, the file is probably a.tar.gzmislabelled.gz— rename and retry, or treat it as a tarball. - Step 5Rule out browser extensions for 7z/RAR/xz/iso — These need WebAssembly. If processing stalls only for those formats, a privacy extension may be blocking WASM. Retry in a private/incognito window with extensions disabled.
- Step 6Pick the right tool if the breakdown is not it — Need per-file detail? Use file-listing-generator. Need folder rollups? archive-size-analyzer. Need raw, case-preserving entries? archive-metadata-extractor.
Symptom to cause to fix
The most common File Type Breakdown problems mapped to their root cause and resolution. Most are tier or format issues, not tool faults.
| Symptom | Likely cause | Fix |
|---|---|---|
| Rejected before processing, size message | Archive over the tier size cap (50 MB free) | Upgrade tier, or split the archive before profiling |
| Rejected before processing, entry message | Over the per-archive entry cap (500 free) | Upgrade tier (50,000 Pro; 500,000 higher), or reduce entries |
| Every ratio reads 0.0% | Input is not a ZIP (tar.gz/7z/etc. decompressed first) | Expected — profile a ZIP for real per-type ratios |
| Only one row in the CSV | Bare .gz holds a single member | Correct for .gz; if it should be many, it is likely a mislabelled .tar.gz |
| .JPG and .jpg merged unexpectedly | Extensions are lower-cased before grouping | Expected — use archive-metadata-extractor for case-preserving entries |
| Count lower than unzip -l shows | Directories are excluded from the tally | Expected — the tool counts files only |
| Stalls on 7z/RAR/xz/iso only | Browser extension blocking WebAssembly | Retry in incognito with extensions disabled |
| Errors out entirely | Corrupt archive / unreadable directory | Confirm format with auto-format-detector; try repair for ZIP |
Tier limits for the archive family
File Type Breakdown is an analysis tool, so the binding limits are usually the per-archive entry count and the file-size cap — both checked before processing starts. Limits are shared across every archive tool.
| Tier | Max archive size | Max entries per archive | Files per run |
|---|---|---|---|
| Free | 50 MB | 500 entries | 1 |
| Pro | 500 MB | 50,000 entries | 20 |
| Pro-media | 2 GB | 500,000 entries | 100 |
| Developer | 2 GB | 500,000 entries | unlimited |
Input formats and which size columns are meaningful
ZIP is read straight from the central directory, so both size columns are real and the ratio is accurate. Every other format is decompressed first, after which the compressed total equals the uncompressed total and the ratio reads 0.0%.
| Input format | Read engine | compressedSize accurate? | ratio meaningful? |
|---|---|---|---|
.zip (incl. AES / ZipCrypto encrypted) | Central-directory parser (no fflate needed for metadata) | Yes — real per-entry compressed size | Yes |
.gz (single member) | fflate gunzip | No — one row only, compressed = uncompressed | No (reads 0.0%) |
.tar | fflate tar parser | No — tar stores files uncompressed | No (0.0%) |
.tar.gz / .tgz | fflate | No — sizes are post-decompression | No (0.0%) |
.tar.bz2, .tar.xz, .bz2, .xz, .7z, .rar, .iso | libarchive WASM (read-only) | No — sizes are post-decompression | No (0.0%) |
Cookbook
Diagnose-and-fix walkthroughs for the failures support sees most. Each pairs the symptom with the concrete resolution.
Diagnosing a tier-limit rejection
A 90 MB archive does nothing on the free tier. The size cap is the cause — the check runs before any parsing, so there is no partial output.
Symptom: drop a 90 MB .zip on Free, nothing processes. Cause: free tier cap is 50 MB / 500 entries. Fix options: - Upgrade to Pro (500 MB / 50,000 entries) or higher - Split the archive and profile each part - Profile a smaller subset for a quick look The size and entry checks both run before processing begins.
0.0% ratio across the whole CSV
Someone reports the ratio column 'is broken' on a TAR.GZ. It is working as designed — only ZIP exposes per-entry compressed sizes.
Symptom: every row shows 0.0% on logs.tar.gz. extension,count,uncompressedSize,compressedSize,ratio log,1204,1875432110,1875432110,0.0% json,4,221044,221044,0.0% Cause: tar.gz is decompressed before counting; compressed == uncompressed. Fix: this is expected. For real ratios, profile a ZIP, or use compression-ratio-calculator for an overall figure.
One row from a .gz that should have many
A .gz returns a single extension row. A bare gzip holds exactly one file; the user actually had a .tar.gz saved with the wrong name.
Symptom: backup.gz -> one row: tar,1,... Cause: .gz is a single-member container. The inner file is a TAR. The breakdown sees one entry (the .tar), hence one row. Fix: rename backup.gz -> backup.tar.gz (or .tgz) and re-run; the tool then expands the tar and reports the real per-type rows.
A renamed archive failing to parse as expected
A file named data.zip errors or reads oddly. auto-format-detector reveals it is actually a RAR. The breakdown reads it by magic bytes, but confirming the format clears up the confusion.
Symptom: data.zip behaves like it is not a zip. Step 1: run auto-format-detector on data.zip Detected: RAR (magic 52 61 72 21) Resolution: it is a RAR; the breakdown reads it via libarchive. If detection says 'unknown', the file may be corrupt or not an archive.
WASM stall on a 7z file
A 7z file spins forever while ZIPs work fine. A privacy extension is blocking WebAssembly, which 7z/RAR/xz/iso require.
Symptom: .zip files process; .7z hangs on 'processing'. Cause: 7z/RAR/xz/iso use a libarchive WASM module. An extension blocking WebAssembly stalls the worker. Fix: open a private/incognito window (extensions off) and retry. ZIP/GZIP/TAR do not need WASM, which is why they still worked.
Edge cases and what actually happens
Archive over the tier size cap
Rejected (tier limit)Free caps inputs at 50 MB, Pro at 500 MB, Pro-media and Developer at 2 GB. The check is up front, so an oversized archive simply will not start. Split it or upgrade.
Archive over the entry-count cap
Rejected (entry limit)Separately from size, archives are capped at 500 entries (Free), 50,000 (Pro), or 500,000 (higher). A bundle of many tiny files can hit this before the size cap. Reduce the entry count or upgrade.
Every ratio is 0.0%
ExpectedThe input is not a ZIP. Non-ZIP formats are decompressed before counting, so compressed equals uncompressed and the ratio is 0.0%. Counts and uncompressed sizes are still accurate.
Single-row result from a .gz
ExpectedA bare gzip stores one member, so the breakdown returns one row. If you expected many, the file is almost certainly a .tar.gz mislabelled .gz — rename and retry.
Mixed-case extensions merged
By designExtensions are lower-cased before grouping, so .JPG, .Jpg, and .jpg collapse into one jpg row. For case-preserving raw entries, use archive-metadata-extractor.
Total entries lower than unzip -l
ExpectedDirectory entries are excluded from the count, and the tool does not include unzip -l's summary line. A files-only total that is lower than the raw listing is correct.
7z/RAR/xz/iso stalls but ZIP works
Error (WASM blocked)Those formats need the libarchive WebAssembly module; a privacy extension blocking WASM stalls the worker. ZIP/GZIP/TAR do not use WASM. Retry in incognito with extensions disabled.
Corrupt or non-archive input
ErrorIf the ZIP central directory is unreadable and the libarchive fallback also fails, the run errors. Confirm the format with auto-format-detector; for a damaged ZIP, try a repair tool before profiling.
Encrypted ZIP, no password
SupportedThe breakdown reads the unencrypted central directory, so it succeeds without a password — extension counts and sizes are available even when the payload is locked. Only file contents would need the key.
Nested archive not expanded
By designAn inner .zip/.7z is counted as one entry of that extension; its contents are not recursed. Extract it with multi-format-extractor and run the breakdown on the inner archive.
Frequently asked questions
Why did nothing happen when I dropped my file?
Almost always a tier limit. Free rejects archives over 50 MB or with more than 500 entries, before any processing. Check the file size and entry count against your tier (Pro: 500 MB / 50,000; higher: 2 GB / 500,000).
Why is every ratio 0.0%?
Your input is not a ZIP. Only ZIP stores per-entry compressed sizes that the tool can read without decompressing. TAR.GZ, 7z, RAR, XZ, and the rest are decompressed first, so compressed equals uncompressed and the ratio is 0.0%. It is expected, not broken.
Why did my .gz return only one row?
A bare .gz holds a single file, so there is one extension to report. If you expected several types, the file is likely a .tar.gz saved with a .gz name — rename it to .tar.gz (or .tgz) and re-run so the tar is expanded.
Why are .JPG and .jpg counted together?
Extensions are lower-cased before grouping, by design, so case variants merge. If you need them separated, use the archive-metadata-extractor to get the raw, case-preserving entry list.
Why is the entry count lower than unzip -l?
The tool excludes directory entries and does not count unzip -l's summary line — it reports files only. A lower number than the raw listing is correct. Add a directory filter to your CLI pipeline to compare like for like.
It stalls on a 7z or RAR but works on ZIPs — why?
7z, RAR, XZ, BZ2, and ISO are read via a libarchive WebAssembly module. A privacy or security extension that blocks WebAssembly can hang the worker. Retry in a private/incognito window with extensions disabled. ZIP/GZIP/TAR do not need WASM.
It says the file is corrupt or fails entirely — now what?
Run auto-format-detector first to confirm the file really is an archive and which format. If the ZIP directory is damaged, try a repair tool. If detection reports 'unknown', the file may not be an archive at all.
Can it open my password-protected ZIP?
For the breakdown, yes — without the password. The central directory (filenames, sizes) is unencrypted, so the type profile works regardless. Only the file contents need a key, and this tool does not read them.
Why are there fewer types than I expected?
Either case-folding merged variants (.JPG/.jpg), or the archive genuinely has low extension diversity (common for minified bundles). Check the Distinct types metric and, if needed, view raw entries with the metadata extractor.
Does it look inside files inside nested archives?
No. A nested .zip/.7z/tarball is counted as one entry of that extension; its contents are not expanded. Extract the inner archive with multi-format-extractor and run the breakdown on it.
Is there a setting I configured wrong?
No — File Type Breakdown has no options. It always produces the same fixed CSV with no checkboxes or presets, so a wrong result is a format/tier/expectation issue rather than a misconfiguration.
What if I actually need per-folder or per-file numbers?
File Type Breakdown is type-only. For folder rollups use archive-size-analyzer; for a per-file listing use file-listing-generator. Both take the same archives.
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.