RENDERED HTML

Return the HTML produced after the browser renders the page

Initial server markup can be only an application shell. Request rendered HTML when the workflow needs the DOM after client JavaScript and page data have built the visible state.

HTML
Rendered output
JavaScript
Client state included
Authorized use
Controlled extraction
Install:POST /api/v1/screenshot · format: html
Auth:SNAPSHOT_SITE_API_KEY
Get started for free
Webpage to HTML workflow
Snapshot Site themed webpage to HTML API illustration
Good fits
Debugging client-rendered page structure
Authorized extraction from rendered content
DOM inventories tied to visual evidence
Pipelines that need post-JavaScript markup

Rendered HTML and raw source answer different questions

Raw HTTP source describes what the server sent. Rendered HTML describes the DOM after browser execution at a specific state and time.

1

Browser execution

Client frameworks can create, replace, and hydrate markup after navigation.

2

State definition

Viewport, readiness, locale, and target data determine the DOM returned.

3

Safe parsing

Treat returned markup as untrusted and parse it without executing embedded content downstream.

4

Provenance

Store target, render settings, capture time, and extraction version with derived records.

Implementation workflow

Build an authorized rendered-HTML job

1

Confirm that raw source does not contain the required page state

2

Define the element or application condition that means rendering is complete

3

Request html output from a trusted backend

4

Parse safely and preserve provenance with extracted data

Webpage to HTML API example

cURL

Request rendered HTML

The format selects HTML output while waitForDom requests the documented rendered-page readiness behavior.

curl --fail-with-body --request POST \
  --url https://api.prod.ss.snapshot-site.com/api/v1/screenshot \
  --header "Content-Type: application/json" \
  --header "x-snapshotsiteapi-key: $SNAPSHOT_SITE_API_KEY" \
  --data '{
    "url": "https://example.com/catalog",
    "format": "html",
    "width": 1440,
    "height": 900,
    "fullSize": true,
    "delay": 2
  }'

Modern HTML often arrives in stages

A framework application can return a small server shell, then request data and construct the meaningful DOM in the browser. Fetching initial source may therefore miss product cards, headings, metadata widgets, or content loaded after hydration.

Rendered HTML captures the DOM at a selected moment. That moment must be defined with the same care as a screenshot: viewport, readiness, target data, and cleanup can all influence the result.

Parse without trusting

HTML from an external page is untrusted input. Use a parser appropriate to the application, limit resource use, and sanitize any content that may later enter an interface. Do not execute scripts from the returned document inside a privileged environment.

Selectors should be tested against representative templates. When a target is controlled by another team or publisher, structural changes can break extraction even if the page remains visually healthy.

Preserve the source of every field

Store the requested target, observed time, rendering configuration, raw or retained HTML policy, parser version, and validation outcome with derived records. This provenance helps resolve disputes when a field changes or disappears.

Respect target authorization, robots and publisher policy, data protection, and collection limits. A rendering API does not grant permission to process content.

Use AI DOM analysis when classification or review supports a rendered DOM workflow, and AI content extraction when the documented analysis response already matches the need.

Webpage to HTML API FAQ

What is a webpage to HTML API?

It loads a URL in a managed browser and returns HTML representing the rendered page state rather than only the initial server response.

How is rendered HTML different from view source?

Client-side JavaScript can hydrate, replace, or append DOM nodes after the server response. Rendered HTML reflects that later state.

Is this a complete web crawler?

No. It processes a requested URL. Discovery, crawl policy, link queues, deduplication, and domain-wide scheduling belong to a crawler you operate.

Can I use CSS selectors on the result?

Yes, through a parser in your application. Validate the target structure and avoid treating fragile selectors as permanent contracts.

Should returned HTML be executed again?

Treat it as untrusted data. Parse and sanitize according to the downstream use rather than injecting it into a privileged application.

Can it access login-protected content?

The renderer needs an authorized reachable state. Use short-lived preview access where suitable or browser automation for interactive login.

What provenance should extracted records include?

Keep source URL or entity, capture time, viewport, readiness, response version, parser version, and the relevant rendered artifact.

When should I use the analyze endpoint instead?

Use analyze for its documented structured summary, topics, metadata, and quality fields. Use HTML when your application owns exact parsing.

Inspect one client-rendered route

Compare its initial source with the rendered HTML, then design extraction around an explicit and authorized page state.