GEO · Raw vs. rendered HTML
What you see in a browser isn't always what a crawler gets.
Surgbly compares what's in the raw HTML response against what's visible after full rendering, so JavaScript-loaded prices, FAQ content, links, and structured data don't quietly disappear from what AI crawlers actually receive.
Every comparison shows the evidence and which crawlers it applies to — not every AI crawler behaves identically.
Rendered (browser)
- Product title
- Price
- FAQ answers
- Internal links
Raw HTML (crawler)
- Product title
- Price
- FAQ answers
- Internal links
Price and FAQ answers load only after JavaScript runs — AI crawlers that don’t execute it never see them.
A page can look complete and still ship an empty shell.
Modern sites often render prices, FAQs, and even core content client-side. A human visitor never notices. A crawler that doesn't execute JavaScript can receive a page with almost nothing on it.
Content loaded only by JavaScript
Important text, prices, or product data exist only after the browser runs a script.
Missing product data in raw HTML
A price or availability field that renders fine visually can be entirely absent from the raw response.
FAQ and answer content, invisible
The exact Q&A sections AI answer engines want to cite are sometimes the first thing hidden behind client-side rendering.
Not every crawler behaves the same
Assuming all AI crawlers render JavaScript identically to Googlebot is a guess, not a fact.
How this feature works
From a rendering assumption to verified evidence.
Fetch the raw HTML response
The exact HTML returned before any JavaScript executes is captured for the page. This is the same response a non-rendering crawler like GPTBot receives, byte for byte.
Fetched with no JavaScript executed, matching what a non-rendering crawler actually gets.
Raw HTML captured
Render the page fully
The page is rendered the way a browser would, executing JavaScript and waiting for content to load. Every script runs and every fetch resolves before this capture is taken.
Waits for full network-idle — the same signal a real browser uses to call a page done loading.
Rendered DOM captured
Compare content, not just size
Product data, FAQ content, internal links, and structured data are compared specifically, not just byte count. Price and FAQ content are the two fields buyers and AI engines look for first.
A byte-count difference alone doesn’t say what’s missing — this checks the fields that actually matter.
2 gaps found
- Both fields load via a client-side fetch after page load.
Show the evidence, by crawler
Findings are shown with crawler context — not every AI crawler executes JavaScript the same way. A gap that only affects non-rendering crawlers gets labeled as such, not treated as universal.
Rendering behavior is never assumed uniform — each finding states exactly which crawlers it applies to.
Crawler context attached
- Rendering behavior varies by crawler and is not assumed uniform.
Recommend a fix and verify parity
Server-side rendering, static generation, or feed-backed structured data is recommended, then raw/rendered parity is reverified after deployment. Parity is confirmed field by field, not inferred from a smaller size difference.
The after-fix comparison checks the exact same fields as before it — no partial credit.
Fix Pack ready
- 1Move price and FAQ data into server-rendered HTML.
- 2Reverify raw/rendered parity after deployment.
Explore it yourself
Explore the raw vs. rendered workspace.
Key capabilities
Everything a raw vs. rendered comparison needs.
Detection
- JavaScript-only content, links, and structured data
- Missing product data and FAQ content in raw HTML
- Template-level rollup instead of per-page duplicates
Evidence
- Side-by-side raw and rendered comparison
- Crawler-specific context, not a one-size-fits-all claim
- Evidence shown alongside every finding
- Extraction simulation for a clean standalone answer quote
Recovery
- Server-side rendering and static generation recommendations
- Feed-backed structured data where appropriate
- Before-and-after parity verified after deployment
- Template-level findings so a shared rendering issue is fixed once
Business outcomes
What changes once raw and rendered are compared directly.
Know what a crawler actually gets
Stop assuming a page renders the same for every crawler as it does in a browser.
Missing content, found by field
See exactly which fields — price, FAQ, links — are rendered-only, not just a vague size difference.
One fix, every affected page
A template-level rendering gap gets fixed once instead of page by page.
Parity, verified
The fix is rechecked for raw/rendered parity after it ships, not assumed to have worked.
Why Surgbly does it better
Field-level evidence instead of a size difference.
Traditional
- 1Raw and rendered HTML sizes differ.
- 2No breakdown of which specific fields are missing.
- 3No context for which crawlers are actually affected.
- 4The same gap repeats across every page on the template.
Surgbly
- 1Raw and rendered content compared field by field.
- 2Findings grouped by template, not duplicated per page.
- 3Crawler-specific context attached to every finding.
- 4Fix recommended and parity reverified after deployment.
Use cases
Built for the moment content looks fine but isn't reaching anyone.
Integrations
Works with the CMS, GitHub, or Snippet surface your pages support.
- WordPress
- Webflow
- Shopify
- GitHub
- Snippet
Questions
Answers before you have to ask.
What content is compared?
Product data, FAQ and answer content, internal links, and structured data — not just overall page size.
Do all AI crawlers execute JavaScript the same way?
No — behavior varies by crawler. Findings are shown with crawler context instead of assuming uniform behavior.
How are large sites handled?
Gaps are grouped by CMS template, so one rendering issue across thousands of pages appears as one finding.
What’s the recommended fix?
Typically server-side rendering, static generation, hydration changes, or feed-backed structured data, depending on the platform.
How does extraction simulation work?
Surgbly checks whether a clean, standalone answer can be pulled from the raw or server-rendered content, not only whether the page has valid schema.
See what a crawler actually receives.
Run a raw vs. rendered comparison on your own site and see the first gap.