How to Test What Google Actually Sees

What “what Google sees” actually means

• Final resolved URL and redirect path
• HTTP status
• Raw HTML before JavaScript
• Rendered DOM after JavaScript
• Title, meta description, canonical, robots directives
• Visible text and internal links
• Structured data
• Resources required to render
• Search Console selected canonical and indexing status

The real problem

The fastest way to test what Google sees

1. Confirm final URL and redirects.
2. Fetch raw HTML with a normal user agent.
3. Fetch raw HTML with Googlebot user agent.
4. Compare raw HTML to rendered DOM.
5. Check title, H1, canonical, noindex, and internal links.
6. Check failed JS/CSS/API requests.
7. Check Search Console URL Inspection.
8. Check AI crawler-readable output if AI visibility matters.

Testing mental model: four layers

Step 1: Check final URL and redirects

If URL resolution is noisy, every downstream SEO signal becomes noisy.

# macOS/Linux
curl -sIL https://example.com/page
curl -sIL http://example.com/page
curl -sIL https://www.example.com/page
curl -sIL "https://example.com/page?utm_source=test"

# Windows (single-line)
curl.exe -s -I -L https://example.com/page

Failure examples: http and https both 200, www and non-www both 200, trailing-slash variants both indexable, UTM URLs indexable, sitemap URLs redirecting, internal links using mixed variants. Healthy state: one canonical host, one final URL, clean 301/308 redirects, sitemap points to final URLs.

Step 2: Fetch raw HTML like a crawler

Raw HTML is what the crawler receives before JavaScript rendering. This is critical for SPAs, React/Vite/Lovable routes, link discovery, title/canonical/noindex extraction, and thin-content detection.

curl -s https://example.com/page -o raw.html
curl -s -A "Googlebot/2.1 (+http://www.google.com/bot.html)" https://example.com/page -o googlebot.html
curl -sI https://example.com/page
wc -c raw.html googlebot.html

Debug thresholds: raw HTML under 10 KB can be fine for minimal SSR pages, but risky for JavaScript-heavy content pages with little text. Visible text under 200 characters is a serious warning. Empty root div + script bundle dependency is a crawler visibility risk.

Step 3: Compare raw HTML vs rendered DOM

Compare: raw and rendered visible text length, word count, H1 presence, internal link count, title/canonical/noindex, and key CTA selector presence.

Step 4: Check visible text and word thresholds

These are debugging thresholds, not ranking laws.

Step 5: Check title, meta description, H1, and body copy

Why it matters: These are primary visibility signals for relevance and extraction.

Healthy: Healthy: title/H1 match intent, unique description, clear body sections.

Failure signals: Failure: placeholder title, missing H1, generic or duplicate body copy.

Step 6: Check canonical and noindex

Why it matters: Canonical and robots directives decide index eligibility and consolidation.

Healthy: Healthy: self-canonical on indexable pages, intentional robots directives.

Failure signals: Failure: canonical points elsewhere, accidental noindex, conflicting robots tags.

Step 7: Check internal links and sitemap consistency

Why it matters: Crawl paths and sitemap alignment help discovery and canonical stability.

Healthy: Healthy: crawlable internal links and sitemap URLs that resolve directly.

Failure signals: Failure: orphan pages, JS-only links, sitemap entries that redirect.

Step 8: Check structured data

Why it matters: Structured data improves machine interpretation and rich result eligibility.

Healthy: Healthy: valid schema matching visible content.

Failure signals: Failure: broken JSON-LD, schema not present in crawler-visible output.

Step 9: Check JS/CSS/API resource failures

Why it matters: Render integrity depends on resource health.

Healthy: Healthy: critical assets load, low console/resource error rate.

Failure signals: Failure: blocked JS, failed APIs, hydration crashes, missing CSS.

Step 10: Check Search Console URL Inspection

Why it matters: Search Console confirms Google’s chosen outcome for the inspected URL.

Healthy: Healthy: selected canonical matches target URL and page is indexed.

Failure signals: Failure: Crawled — currently not indexed, Google-selected canonical mismatch.

Step 11: Check AI crawler-readable output

Why it matters: If AI visibility matters, extraction must be reliable beyond browser rendering.

Healthy: Healthy: meaningful crawler-readable content and stable AI Markdown where available.

Failure signals: Failure: AI crawlers extract little text, miss key claims, or lose citation context.

What browser screenshots miss

• Screenshots do not prove raw HTML quality.
• Screenshots do not prove Googlebot received the same response.
• Screenshots do not clearly expose canonical/noindex mistakes.
• Screenshots do not prove internal links are crawlable.
• Screenshots do not prove Search Console selected the right canonical.
• Screenshots do not prove AI crawlers can extract the page.

What Search Console can and cannot tell you

How Guard helps

Guard gives page-level monitoring for production visibility signals and output regressions across scans: page snapshot history, rendered output changes, raw HTML/rendered output signals where available, visible text length, word count, HTML bytes, title/H1/canonical/noindex drift, resource errors, console errors, DOM/content changes, and Core Web Vitals regressions.

Guard does not replace Search Console. It catches page-output changes before they turn into indexing and visibility problems.

Common mistakes that create false confidence

• Relying only on Chrome.
• Relying only on Lighthouse.
• Assuming Google always renders JavaScript fully.
• Testing only the homepage.
• Ignoring raw HTML.
• Ignoring canonical/noindex directives.
• Ignoring internal links.
• Ignoring failed JS/API requests.
• Checking GSC too late.
• Treating Crawled — currently not indexed as random.
• Assuming AI crawlers behave like Googlebot.
• Using sitemap submission as a fix for thin output.

Full test checklist

Command snippets for quick checks

# Redirect chain and final URL
curl -sIL https://example.com/page

# Raw HTML and Googlebot-style fetch
curl -s https://example.com/page -o raw.html
curl -s -A "Googlebot/2.1 (+http://www.google.com/bot.html)" https://example.com/page -o gbot.html

# Headers only
curl -sI https://example.com/page

# Compare byte size
wc -c raw.html gbot.html

# Quick signal extraction
rg -in "<title|rel="canonical"|name="robots"|<h1" raw.html gbot.html

# Windows one-line fetch
curl.exe -s -A "Googlebot/2.1 (+http://www.google.com/bot.html)" https://example.com/page -o gbot.html

FAQ