How to Use SingleFile with Pages Behind a Login

To save a page behind a login with SingleFile, sign in to the site in your browser, open the page you are authorized to view, wait for it to finish loading, then click the SingleFile toolbar button. SingleFile captures the current browser tab; it does not provide credentials or bypass the site’s access controls. The saved HTML file can include page resources such as styles, images, fonts, and frames, but dynamic content and interactive behavior may not be preserved exactly.

What you need

SingleFile installed and enabled in a supported browser. The project lists browser extension distribution channels for Chrome, Firefox, Safari, and Edge.
An active, authorized session for the site, with the exact page visible in the tab you want to save.
Enough time for the page and any important content that appears after navigation to load.

Use the browser extension for this workflow. SingleFile also has a command-line tool, but the steps here rely on the page already being open in your signed-in browser session.

Step-by-step: save the page

Install and enable SingleFile. Get it from the official extension store for your browser, then confirm the extension is enabled and its toolbar button is available. See the SingleFile project instructions.
Sign in normally. Complete the site’s own login process in the browser. Do not copy credentials into SingleFile; the extension acts on the tab that the browser can access.
Open the exact page. Navigate to the content you are authorized to view. Check that you see the intended page rather than a login screen, expired-session notice, or access challenge.
Wait for loading to finish. Let the initial page load complete, and wait for important images or content that appears after navigation. The Chrome Web Store instructions specifically advise waiting until the page is fully loaded before clicking SingleFile.
Click the SingleFile toolbar button. It processes the current tab and saves a single HTML file. The default save location follows your browser’s download-folder setting.
Open the downloaded file and inspect it. Check key text, images, and layout. Keep the original browser page available if you need to verify anything the saved copy does not contain.

What the saved file can and cannot preserve

SingleFile aims to package a page and its resources, including CSS, images, fonts, and frames, into one HTML file. The result still depends on what the browser and site expose and what resources are available as the page is processed. A visible page is not a guarantee that every resource has loaded or will be included.

Do not treat the file as a guaranteed archive of restricted content. Session expiry, site rules, browser protections, dynamic loading, and site-specific behavior can affect what is visible or captured. Keep only content you are authorized to access and store.

Interactive features

By default, SingleFile removes scripts because they can alter rendering and may not work offline. As a result, buttons, maps, carousels, and other interactive elements may appear as static content or fail to work in the saved file. The SingleFile FAQ describes settings for changing script blocking and content or style handling if you want to attempt to retain interactivity. Changing those settings does not guarantee that scripts will work offline.

Settings to consider

For a straightforward reference copy, start with the defaults and inspect the result. If you need to investigate a specific problem, the official FAQ documents settings related to script blocking, content and style handling, and a referer header for fetching images on sites that require it. Change one relevant setting at a time, capture again, and compare the file. The referer option addresses a particular image-fetching requirement; it is not a general fix for missing page content.

When SingleFile cannot run on the page

Browsers restrict extensions on some pages or domains for security reasons. If the toolbar action is unavailable or the extension cannot process the tab, this may be a browser restriction rather than a problem with your login. SingleFile’s FAQ gives Mozilla Add-ons as an example of a domain where browsers block extensions.

There is no universal SingleFile procedure for MFA, paywalls, bot challenges, or site-specific authentication flows in the official guidance reviewed here. Complete the site’s authorized flow in the browser and save only if the intended content is visible and the extension is permitted to run.

Troubleshooting

Symptom	Likely cause	What to try
The extension button is missing or does nothing.	The extension may be disabled, not pinned, or blocked on that browser page.	Confirm SingleFile is installed and enabled, then check whether the browser permits extensions on the current domain. If the browser blocks it for security, use a page where the extension is allowed; do not infer that the account login failed.
The saved file shows a login screen or challenge.	The session may have expired, or the intended content was not visible in the tab when saved.	Return to the site, complete its authorized sign-in flow, reopen the intended page, verify it is visible, wait for loading, and capture again. The extension does not bypass authentication.
Images or other resources are missing.	The page may not have finished loading, a resource may not have been available to the browser, or the site may require a referer header for image fetches.	Wait for the resource to appear in the browser before capture. If the issue is specifically image fetching on a site that requires a referer, consult the official FAQ’s referer-header option. It will not fix unrelated omissions.
The file looks different from the live page.	Dynamic content may not have settled before capture, or scripts and style handling affect the saved rendering.	Wait for the relevant content before saving, inspect the file, and consult the official settings guidance for the specific rendering behavior. A saved copy is not guaranteed to match every live state.
Buttons or widgets do not work offline.	Scripts are removed by default, and retained scripts are not guaranteed to work offline.	Keep the default for a static reference copy. If interactivity is necessary, review the FAQ settings for script blocking and test the result while treating offline behavior as uncertain.

Performance, reliability, and storage

Capture time depends on the page and its resources. A page with many images, fonts, frames, or content loaded after navigation can take longer to prepare and may produce a larger HTML file. Wait for the important material to appear, then inspect the output rather than assuming that the save action captured every resource.

For reliability, verify the downloaded file while your authorized browser session is still available. If a key resource is missing, determine whether it was visible in the browser and whether the page had finished loading before changing settings. A single HTML file is convenient to move and keep, but its appearance and offline behavior remain dependent on what was captured.

Or skip the browser setup

If you need a screenshot rather than a saved HTML page, ScreenshotNeo is a website screenshot API and MCP server for developers. A single GET request returns PNG, JPEG, WebP, or PDF. It can also capture pages that require custom headers, cookies, or Authorization, but it is not a way to bypass access controls: supply access only when you are authorized to do so.

For example, this cURL request captures a public page as WebP:

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

See the ScreenshotNeo API documentation for request options. The equivalent basic requests are:

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 Bun.write('shot.webp', new Uint8Array(await res.arrayBuffer()));

In Node.js versions with a filesystem API, save the response bytes with writeFile from node:fs/promises instead of Bun.write.

ScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The free plan includes 1,000 shots per month without a card; paid plans start at $5 for 3,000 shots. These are screenshots and PDFs, rather than a SingleFile-style saved HTML archive.

FAQ

Can SingleFile save a page after I log in?

Yes, if the page is open and the browser allows the extension to run. It captures the current tab; it does not log in for you.

Will the saved page work without an internet connection?

The file can contain page resources, but interactive scripts are removed by default and may not work offline even if retained.

Does saving a page let me keep access after my session expires?

The local file contains only what was captured. It does not extend your account access or grant permission to retain restricted material.

Where does SingleFile save the result?

By default, it uses the browser’s download-folder setting. Check your browser’s downloads list if the file is not immediately visible.