How to create a visual SEO audit report with website screenshots

A useful visual SEO audit report connects a specific finding to evidence, explains why it matters, and names a next action. Start with a repeatable page-level audit in Lighthouse, capture screenshots of the relevant page state, and label the test context. Add Search Console Core Web Vitals field data separately when available. Then rank the work by impact and affected pages.

A screenshot makes a finding easier to understand; it does not establish that a page will rank higher or prove a search outcome. Lighthouse’s SEO category checks a bounded set of technical items and is not a replacement for a broader SEO strategy. Google’s publisher guidance on Lighthouse SEO audits describes this limitation.

1. Define what the report covers

Before running tools, write down the report’s scope. One URL-level audit is evidence about that URL and test run, not a substitute for reviewing every page on a site.

Scope item	Record
Site and page	Domain, exact URL, and whether the page represents a template or a single page.
Purpose	For example, identify technical issues on a landing page or compare a template before and after a change.
Run context	Date, device, browser and Lighthouse version, mode, and relevant configuration.
Evidence sources	Mark each result as a live page test, grouped field data, or a screenshot of a finding.
Audience	Name the team or decision-maker expected to act on the report.

Keep these labels visible throughout the report. A mobile lab test, desktop test, Search Console URL group, and individual live URL test describe different scopes and conditions.

2. Run a repeatable Lighthouse audit

Run it in Chrome DevTools

Open the exact page in Chrome and open DevTools.
Select the Lighthouse panel.
Choose the device and the categories relevant to the report. Lighthouse reports Performance, Accessibility, Best Practices, and SEO.
Run the audit and review the category scores, issues, and suggested improvements.
Use the report’s save, print, or separate-view options to retain the audit details with your project notes.

For a before-and-after comparison, use the same device and broadly consistent setup. Extensions, other work on the machine, cookies, and local site data can affect a run. Google cautions that results from different machines cannot be compared directly. Record the environment instead of treating small score differences as definitive.

Run Lighthouse from the Node.js CLI

The Lighthouse project documents a Node CLI that writes an HTML report by default. Install and invoke the CLI for the page you want to inspect:

npm install --save-dev lighthouse
npx lighthouse https://example.com/ --output html --output-path ./lighthouse-report.html

Replace https://example.com/ with the page under review. The command creates an HTML report at the specified path. Use the same Lighthouse version, flags, and test conditions for runs you plan to compare. Consult the Lighthouse Node CLI documentation for available command-line options and current usage.

The report result includes context such as requested and final URL, fetch time, browser user agent, Lighthouse version, and configuration. Preserve that metadata with the report so another person can understand what the run represents. See the Lighthouse results documentation.

3. Choose screenshots that support findings

Lighthouse result data can include screenshots, and its HTML report renders screenshot evidence. The DevTools report can also be saved or printed. Select only images that help a reader see the affected page state or locate the relevant audit detail.

Capture the page state that makes the issue understandable, such as a visible layout problem or a page section related to the finding.
When the finding is in Lighthouse, include the relevant report detail or audit evidence as well as a page screenshot where useful.
Give each image a concise caption with the tested URL or page name and what to notice.
Keep the capture context with the image: date, device, and whether it is a live page or report screenshot.
Do not present a screenshot or Lighthouse score as proof of a ranking change.

For a visual report assembled from page captures, use the same viewport and page state for comparable pages. If a page has consent banners, popups, or chat widgets that obscure the content, record whether the capture shows that visitor state or a cleaned page state. The capture should make the evidence legible without hiding a condition relevant to the finding.

4. Write each report finding as an actionable entry

Do not paste a score and leave the reader to infer the work. Use a compact entry for each finding that matters:

Finding: State exactly what the audit observed. Avoid turning an audit signal into a broader claim the tool did not establish.
Evidence: Link or embed the relevant screenshot and report detail. Include the URL, date, device, and test context.
Why it matters: Explain the user or crawl consequence only when supported by the finding. Separate measured behavior from interpretation.
Recommended action: Give a concrete next step, ideally tied to a resource, DOM node, source location, or URL identified by the audit.
Priority: Mark high, medium, or low and explain the reason, such as severity, number of affected URLs, or importance of the page.

Example structure:

Finding: The audit reports a missing page description.
Evidence: Lighthouse SEO audit detail for https://example.com/pricing/, desktop run, 2026-10-04; see attached report capture.
Why it matters: The audited page has no description value available to the check. This finding alone does not predict rankings or how a search result will appear.
Recommended action: Review the page's metadata and add an accurate description if one is appropriate.
Priority: Medium — confirm whether the same template affects other important pages.

This is an illustrative format, not a claim about the result of an actual site audit. Replace it with observations from your own report.

5. Add field data separately from live tests

Search Console’s Core Web Vitals report uses anonymized real-user data and groups similar URLs. PageSpeed Insights and Lighthouse can run live tests on individual URLs. A specific URL’s live result can differ from its Search Console URL-group result, including when that URL is an outlier. Label each source and scope clearly in the report. Search Console’s Core Web Vitals report documentation explains its field data and URL grouping.

Report label	What it represents	How to present it
Live page test	A tool’s test of an individual URL under a particular run configuration.	Include exact URL, tool, date, device, and relevant configuration.
Search Console field data	Anonymized real-user data reported for groups of similar URLs.	Include the URL group and state that it represents grouped field data.
Screenshot evidence	A captured page state or report detail that illustrates a finding.	Caption the page and call out what the reader should notice.

Do not combine these into a single score or imply they are interchangeable. State which data answers which question.

6. Prioritize work and close with an action plan

For Core Web Vitals, Google’s guidance is to address issues marked Poor first, then sort by the number or importance of affected URLs. Include ownership and a retest date if the report will track implementation. Search Console’s guidance supports investigating issues and validating fixes.

Priority	Use it when	Report action
High	A serious issue affects important pages or many URLs, or a Core Web Vitals issue is marked Poor.	Name an owner and the next concrete step.
Medium	The issue matters but has a narrower scope or needs confirmation across a template.	Check affected pages and schedule a fix or follow-up audit.
Low	The evidence indicates a limited issue with lower page or user impact.	Record it for a later maintenance pass.

End with a short action table so the report leads to work:

Finding | Affected pages | Owner | Next action | Retest date
[observed issue] | [URL or URL group] | [team/person] | [specific change] | [date]

7. Capture page evidence with ScreenshotNeo

If your report needs consistent page screenshots, ScreenshotNeo is a website screenshot API and MCP server for developers. A GET request can return a PNG, JPEG, WebP, or PDF. The call below captures a page as WebP; see the ScreenshotNeo API documentation for request options.

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}`);
const fs = await import('node:fs/promises');
await fs.writeFile('shot.webp', Buffer.from(await res.arrayBuffer()));

Replace the example URL and API key with the page and credential for your capture. Keep credentials out of public client-side code. The API supports full-page captures with lazy images loaded, element captures by CSS selector, device and viewport settings, retina scale, dark mode, custom CSS and JavaScript, selector or network-idle waits, and more. Use the docs for parameter names and combinations; options can be turned on or off to fit the evidence you need.

Or skip the browser setup

ScreenshotNeo removes cookie and consent banners from more than 60 known platforms, plus newsletter popups and chat widgets, before capture; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and the response identifies the page verdict and billing status in headers. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots. The same features are on every plan. See the API docs.

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

Troubleshooting

Symptom	Likely cause	Fix
Scores differ between two runs	Different machine, device, browser conditions, extensions, cookies, local data, or Lighthouse version.	Record the run context, use a consistent setup, and avoid treating results from different machines as directly comparable.
A result does not match Search Console	A live individual-URL test and grouped field data answer different questions; the URL may be an outlier in its group.	Label data type and scope, and inspect the exact URL and URL group separately.
The screenshot does not show the issue	The capture shows a different page state, viewport, or point in the report.	Repeat with the relevant viewport or state and capture the exact report detail or page area.
The report implies a ranking guarantee	A bounded audit check or visual capture has been overstated.	Rewrite the conclusion to describe the observed check and its limits. Lighthouse’s SEO category does not guarantee search results.
The screenshot request fails or returns an unexpected page result	The target may be unavailable, blank, timed out, or presenting a bot check.	Check the URL and page availability, inspect the returned response and ScreenshotNeo’s `X-Page-Verdict` and `X-Billed` headers, then retry only after addressing the cause.

Performance, reliability, and cost notes

Performance: Auditing and capturing many URLs takes longer than a single-page run. Start with representative pages and important templates, then expand based on findings. Keep device and configuration consistent when comparing results.
Reliability: Treat Lighthouse as a run under recorded conditions, not an invariant property of a page. Retain result metadata, screenshots, and the date. Use Search Console field data for grouped real-user experience, with its scope clearly stated.
Capture billing: ScreenshotNeo bills only clean shots. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing; response headers state the verdict and billing status.
ScreenshotNeo plans: Free is 1,000 shots per month with no card; Starter is $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000. Yearly billing gives two months free. All features are available on every plan.
Cost control: Choose capture settings that match the evidence needed, use caching with a chosen TTL when appropriate, and use bulk capture for up to 100 URLs per call. Do not assume a screenshot API replaces Lighthouse or Search Console; they answer different audit questions.

FAQ

Does a Lighthouse SEO score predict a Google ranking?

No. It reports a defined set of checks and does not guarantee search results.

Can I use one screenshot to represent an entire site?

No. A screenshot documents a particular page state. Audit representative templates and label the pages covered.

Should I put every Lighthouse screenshot in the report?

No. Include evidence that supports a finding and helps the reader take the next step; keep the full saved report available for detail.

Can an AI agent capture report evidence?

ScreenshotNeo’s MCP server provides screenshot, page-info, and PDF capture tools to MCP clients such as Claude and Cursor.