SingleFileZ vs Chrome Save Page: Which Keeps More of the Webpage?

Short answer: the available documentation does not establish that SingleFileZ always keeps more of a webpage than Chrome’s built-in Save Page command. SingleFileZ is designed to package a page and resources into a self-extracting ZIP-style file, and its FAQ describes resources it can include. The reviewed sources do not provide an authoritative equivalent description of Chrome Save Page or a controlled comparison. Which file preserves more depends on the page, what has loaded, capture settings, and browser restrictions.

If you need a defensible answer for your own pages, save the same pages with both methods and compare the resulting files and offline behavior. For a documented option set and trade-offs, SingleFile’s current documentation is the stronger reference; that does not establish that its output is more complete in every case. SingleFileZ’s repository says its functionality has been merged into SingleFile.

1. What “keeps more” means

A saved page can preserve some parts of the original while losing others. Decide which kinds of completeness matter to you before comparing:

Visible content: text and images visible when you save.
Resources: stylesheets, fonts, images, and content inside frames.
Deferred content: images or frames that load only after scrolling or interacting.
Hidden content: elements present in the page but not currently displayed.
Behavior: scripts, forms, maps, carousels, and other interactive elements.
Portability: whether the file opens on another machine and browser without an extension or special setup.

These are separate questions. A file can be visually close to the original yet lack working scripts, or include more resources while being slower to open. No single file-size or “looks right” check proves that every resource was preserved.

2. What the sources establish about SingleFileZ

SingleFileZ is described as a web extension that saves a webpage as a self-extracting ZIP-style file. The project says that feature has been merged into SingleFile; in SingleFile, look in the file-format options for a self-extracting format. The SingleFileZ FAQ says the capture can include images, CSS, frame contents, and fonts, including resources present in the page but not displayed or already cached. This describes the project’s intended capability, not a guarantee that every site’s resources will be captured.

There are several important qualifications:

SingleFile removes scripts by default. Its FAQ says scripts can change rendering and may not work offline. Maps, carousels, and expandable or folding content can therefore behave differently in a saved file.
Options affect the result. Disabling frame removal or saving deferred images can avoid some missing content, while disabling removal of hidden elements and unused styles can reduce processing time and CPU use.
SingleFile’s FAQ says some pages cannot be saved because browsers restrict extension access on certain domains.
Some sites require an HTTP Referer header to retrieve images. SingleFile does not enable passing it by default for privacy reasons; its FAQ describes an option to enable it after a cross-origin request error.
SingleFileZ says its files can take longer to save and open. Its FAQ also explains that opening behavior depends on format and browser; Chrome may need the extension or a command-line switch for some SingleFileZ files. Check the current format’s documentation and test the target browser.

See the SingleFileZ FAQ and the SingleFile FAQ for the project’s explanations of these limits and settings. The SingleFile project says it is not intended as a professional web-archiving tool; if you need archival preservation, use a workflow designed for that purpose.

3. What is not established about Chrome Save Page

The sources reviewed for this comparison do not establish which resources Chrome’s built-in Save Page command preserves, how it treats frames or deferred images, or what exact formats it currently offers. They also do not provide a controlled head-to-head test against SingleFileZ. So claims such as “Chrome saves only what is visible” or “SingleFileZ always captures the whole page” would go beyond the evidence here.

Use Chrome Save Page as one side of a practical comparison, but record the Chrome version and the exact save option or format you chose. The browser may change; observations from a particular version and page should not be generalized into a universal winner.

4. Run a fair comparison on your pages

Choose representative pages. Include a simple article, a long page with lazy-loaded images, a page with embedded frames, and a page with interactive elements if those are relevant to your use case.
Prepare each page consistently. Use the same browser profile, wait for the same content to load, and scroll through the same areas. If content requires a click to load, apply the same interaction before each save.
Save both ways. Use Chrome’s built-in Save Page command and the SingleFile self-extracting format. Note the browser version, selected format, and relevant SingleFile settings.
Inspect the saved files offline. Disconnect from the network or otherwise ensure the page cannot silently fetch missing resources. Open each file in the intended browser and check the same content areas.
Check more than appearance. Compare text, images, frames, fonts and layout; then test the specific interactions you need. Record missing or broken items rather than scoring the file by size alone.
Repeat failures. A single run can be affected by timing, access restrictions, or resources that had not loaded. Repeat a page when results differ unexpectedly.

A useful results sheet is simple:

Check	Chrome Save Page	SingleFile self-extracting
Browser/version and selected format	Record exact details	Record exact details
Text and visible images	Present / missing; note items	Present / missing; note items
Scrolled or deferred content	Present / missing; note items	Present / missing; note items
Frames and embedded content	Present / missing; note items	Present / missing; note items
Offline appearance and interactions	Record what works	Record what works
Open on another target browser	Record result	Record result and any extension requirement
Save/open time and output size	Measure on your setup	Measure on your setup

This produces evidence for your pages and requirements, not a universal completeness percentage. Do not infer preservation quality from file size alone: different packaging and compression can change size without establishing which relevant resources survived.

5. Choosing between them

Your need	Practical choice
You want a documented, configurable self-contained capture and can use a browser extension	Try SingleFile’s self-extracting format; verify its output and settings on your pages.
You want a built-in browser workflow with no extension setup	Try Chrome Save Page, then inspect its offline output against your needs. The reviewed sources do not establish its resource-by-resource behavior.
You need scripts and interactions to keep working offline	Test the exact interactions. SingleFile removes scripts by default, and its FAQ cautions that saved scripts may not work offline.
You need reliable long-term web archiving	Do not treat either ordinary page-saving workflow as archival proof. SingleFile itself says it is not intended for professional web archiving; evaluate a WARC-based archival workflow.
You need a screenshot image or PDF rather than an offline HTML page	A browser save and a screenshot solve different problems. Use a screenshot capture workflow when a fixed visual record is the goal.

6. Troubleshooting missing or broken content

Images are absent from the saved page

Check whether the image had loaded before capture and whether it was deferred until scrolling. SingleFile’s documentation describes an option to save deferred images. Some sites require a Referer header for cross-origin image requests; its FAQ says passing that header is not enabled by default for privacy reasons. Also check whether the browser blocked extension access on that domain.

Frames or embedded sections are missing

Check the SingleFile frame-related settings and whether the frame content had loaded. The FAQ warns that disabling frame capture or removing frames can leave content out. Repeat the capture after the embedded section has loaded.

A map, carousel, or expandable section no longer works

SingleFile removes scripts by default because they may change rendering and may not work offline. A saved static representation can therefore look different or lose interactivity. The SingleFile FAQ describes settings related to blocked scripts, hidden elements, unused styles, and raw page content; changing these can affect output and should be tested on a copy.

A SingleFileZ file will not open in Chrome

Check which self-extracting format was selected and consult the current SingleFile format help. The SingleFileZ FAQ documents a Chrome limitation for its files unless the extension is installed or Chrome is started with a command-line switch. Try the documented universal format where appropriate, or open the file in a supported setup.

The saved version differs between runs

Dynamic pages can change while loading. Repeat the capture after the same content has loaded, with the same scroll and interaction steps, and record the settings. The comparison dossier does not establish a general timing guarantee for either method.

7. Performance, reliability, and cost

For local page saving, the cost is primarily your setup and time: install or configure an extension where needed, wait for resources, and inspect output. SingleFileZ’s FAQ notes that self-extracting files can take longer to save and open. It says turning off removal of hidden elements and unused styles can improve speed, while turning off frame handling or deferred-image saving can cause omissions. Treat those as trade-offs and confirm the result on representative pages.

Reliability depends on whether the browser can access the page and resources, whether deferred content has loaded, and whether the saved format opens in the browser you plan to use. Neither the supplied research nor the cited project documentation provides a controlled completeness benchmark against Chrome Save Page. There is no supported capture percentage or universal “keeps more” score to report.

8. Screenshot an online page instead

If your goal is a visual record rather than an offline HTML copy, ScreenshotNeo is a website screenshot API and MCP server for developers. A screenshot preserves a rendered image or PDF, not the page’s original interactive behavior or a browsable offline copy.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(({ writeFile }) => writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

See the ScreenshotNeo API documentation for request options and setup.

Or skip the browser setup

One GET request returns a screenshot image or PDF. Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Frequently asked questions

Has SingleFileZ been discontinued?

The repository says SingleFileZ has been merged into SingleFile and points users to SingleFile’s file-format options for self-extracting output. Check that repository for current project guidance.

Does a self-contained webpage save preserve the original site’s behavior?

Not necessarily. A saved page is a local copy, and scripts or network-dependent features may not work offline. Test the specific behavior you depend on.

Can I say SingleFileZ is the winner?

Not from the reviewed evidence. Run and document a controlled comparison on the pages and browser versions that matter to you.