How to Capture a Full-Page Website Screenshot for a Client Report

To capture a full-page website screenshot for a client report, use Firefox’s Save full page option for a one-off image, or use Playwright’s screenshot API with fullPage: true for repeatable captures. Open the result and confirm the whole page is present and readable at the size it will appear in the report.

Choose the capture method

Need	Method
One screenshot, saved or copied manually	Firefox screenshot interface
Explicit filename or capture options	Firefox Web Console screenshot helper
Recurring reports or multiple pages	Playwright
Capture without maintaining browser automation	ScreenshotNeo API

Capture a full page in Firefox

Open the page you want to document in Firefox.
Open the screenshot interface and choose Save full page. Firefox’s Save visible option captures only the current viewport, so verify that full-page capture is selected.
Choose Download to save the image, or Copy to put it on the clipboard and paste it into your report.

Another Firefox route is Developer Tools: enable Take a screenshot of the entire page in Developer Tools settings, then click the screenshot icon. The image is saved in the browser’s Downloads directory. Firefox’s Web Console also supports :screenshot --fullpage. See Mozilla’s screenshot tool documentation for the browser controls.

Set a filename with the Web Console

Use the Web Console helper when you want a named file or need options such as a delay, device-pixel ratio, clipboard output, or a CSS selector. For example:

:screenshot --fullpage --filename=client-report-homepage.png

Check the Firefox version’s supported helper options if you need additional parameters. Reusing a filename overwrites the earlier image, so choose a distinct name when you need to keep multiple report captures.

Capture full pages with Playwright

Playwright is useful when a report needs the same capture procedure repeated. Its full-page option captures the page’s full scrollable area; it defaults to false.

JavaScript: complete runnable example

Install Playwright and its Chromium browser:

npm init -y
npm install playwright
npx playwright install chromium

Save this as capture.mjs, replacing the URL with the page you are authorized to capture:

import { chromium } from 'playwright';

const browser = await chromium.launch({ headless: true });
try {
  const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
  const response = await page.goto('https://example.com', {
    waitUntil: 'networkidle',
    timeout: 30_000
  });
  if (!response || !response.ok()) {
    throw new Error(`Navigation failed: ${response?.status() ?? 'no response'}`);
  }
  await page.screenshot({ path: 'client-report-page.png', fullPage: true });
} finally {
  await browser.close();
}

node capture.mjs

networkidle can be unsuitable for pages that keep network connections open. If navigation times out there, wait for a more meaningful page condition such as a report heading or main content, then capture:

await page.goto('https://example.com', { waitUntil: 'domcontentloaded' });
await page.locator('main').waitFor({ state: 'visible', timeout: 15_000 });
await page.screenshot({ path: 'client-report-page.png', fullPage: true });

Python: runnable equivalent

Install Playwright and its browser:

python -m pip install playwright
playwright install chromium

Save as capture.py:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    try:
        page = browser.new_page(viewport={"width": 1440, "height": 900})
        response = page.goto(
            "https://example.com",
            wait_until="networkidle",
            timeout=30_000,
        )
        if response is None or not response.ok:
            status = response.status if response else "no response"
            raise RuntimeError(f"Navigation failed: {status}")
        page.screenshot(path="client-report-page.png", full_page=True)
    finally:
        browser.close()

python capture.py

As in JavaScript, replace networkidle with domcontentloaded and wait for a page-specific locator if the site never becomes idle.

Capture a particular element

If the client needs a chart, article, or report panel rather than the complete page, capture the element. In JavaScript, for example:

await page.locator('main article').screenshot({ path: 'report-section.png' });

Use a selector that identifies the intended content on the target page. Element capture avoids an extremely tall image when only one section matters.

Or skip the browser setup

ScreenshotNeo provides a website screenshot API and MCP server. One GET request returns an image or PDF; its full-page option loads lazy images before capture. See the ScreenshotNeo API documentation for parameters and response details.

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

import requests

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

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.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(fs => fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before capture. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed; response headers identify the page verdict and billing status. Its 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 screenshots.

Make the screenshot report-ready

Check coverage: confirm the capture includes the intended content from the top through the bottom of the page.
Check legibility: view the image at the size it will occupy in the report. A tall screenshot can become too small to read when fitted to a page.
Use a clear filename: include the page or client and capture date, for example client-homepage-2026-10-04.png.
Keep the original: retain the full-resolution capture if you need to crop or annotate a copy for the report.
Choose a useful format: PNG is suitable when crisp text and detail matter; JPEG or WebP can reduce file size. Use a PDF workflow if a long page is easier for the client to review across pages.

Options and edge cases

Lazy-loaded images: a browser may not load content far below the fold until it scrolls into view. If the capture omits these assets, scroll through the page before capturing or use a tool that loads lazy images as part of full-page capture.
Dynamic content: dashboards, rotating banners, timestamps, and personalized pages can change between runs. Wait for the content needed for the report and capture under consistent conditions.
Authentication: a page behind login must be opened in a browser context with the required session. Never place credentials in a shared script or report artifact.
Very long pages: a full-page image can be unwieldy or exceed image dimension limits. Break it into focused captures or use PDF output if that is easier to review.
Responsive layout: set a consistent viewport for automated captures; otherwise, text wrapping and layout may vary.
Privacy: check that the page does not expose personal or confidential details that should not appear in a client deliverable.

Troubleshooting

Symptom	Likely cause	Fix
Only the visible screen is captured	The browser used viewport capture	Select Firefox’s Save full page or set Playwright’s `fullPage: true`.
Images or sections are missing	Lazy loading or delayed rendering	Scroll through the page, wait for a meaningful selector, or add a suitable delay before capture.
Playwright hangs waiting for navigation	The page never reaches network idle	Use `domcontentloaded` or `load`, then wait for the specific content you need.
Capture shows a login page or error	The route requires authentication or navigation failed	Establish the authorized session and check the final URL and navigation response before saving.
Output is too small to read in the report	The whole tall page was scaled to fit one page	Use several focused screenshots or a PDF layout that can span pages.
A previous Firefox image disappeared	The same filename was reused	Use a unique filename for each capture you need to retain.

Performance, reliability, and cost

For a single page, Firefox requires no automation setup. Playwright adds installation and browser startup, but makes repeated captures scriptable. Reuse a browser process for batches rather than launching one for every page, and keep concurrency within the limits of the machine running the capture. Wait only for the content required by the report; waiting for all network activity can slow captures or time out on sites with persistent requests.

Browser-based capture has no screenshot API request charge, though it uses local compute and requires maintenance of the browser automation environment. ScreenshotNeo offers a hosted option with a free allowance of 1,000 shots per month and paid tiers of $5 for 3,000, $15 for 15,000, $39 for 60,000, $99 for 250,000, and $249 for 1,000,000 shots. Yearly billing gives two months free. All features are available on every plan. Only clean shots are billed; use the response’s X-Page-Verdict and X-Billed headers to see the result for each request.

FAQ

Can I paste a full-page screenshot directly into a report?

Yes. Use Firefox’s Copy option or insert the downloaded image. Check its readability after placing it in the report.

Does Playwright capture content below the fold?

With fullPage: true, it captures the full scrollable page. Whether every dynamic or lazy-loaded asset has rendered depends on the page and when the capture runs.

Should I use an image or PDF?

Use an image when the client needs a single visual record. A PDF can be easier to read and navigate when the page is very long.

Can I automate captures on a schedule?

Yes. Run a Playwright script from your existing scheduler or use an API workflow. Keep the viewport, wait condition, and output naming consistent across runs.