Detect & Map Indexing Errors Offline
Upload a .ZIP static export, a Blogger XML theme, or HTML files. The engine resolves full cross-file dependencies, maps anomalies to GSC errors, and generates replacement files via AST modification.
Enable Live HTTP Header Verification
Attempts to fetch live status codes (200, 301, 404) and X-Robots-Tags using the Target Domain. Requires target server to permit CORS.
Drop ZIP Archive or Files
Platform Foundation & Summary
Initial structural scan complete. Review platform detection and overview metrics.
Search Console Root Cause Engine
Evaluates the complete dependency graph to explain why Google flags a specific error, including confidence scoring and verification requirements.
Internal Link & Crawl Budget Simulator
Builds an adjacency matrix to trace inbound/outbound flow, extracting Anchor Text and identifying deep architectural crawl risks.
| Normalized URL | Crawl Depth | Anchor Text (Sample) | Inbound | Crawl Budget Risk |
|---|
Canonical Graph Solver
Traces relationships to detect canonical loops (A→B→A) and conflicts where a canonical points to a blocked or non-existent URL.
| Source Node | Directive | Target Node | Endpoint Status |
|---|
Duplicate Content Cluster Detector
Utilizes semantic Jaccard approximations (extracting body content, stripping nav/footers) to flag files that share highly similar content but possess conflicting or missing canonical markers.
AST Patch Validation & Generator
Review Before/After diffs of structural AST repairs. The Patch Validation Engine has mathematically confirmed these changes resolve the GSC error offline. Select the patches you wish to apply and download the fully rebuilt replacement files.
The Ultimate Website Crawl & Index Audit Platform
Technical SEO has evolved from simple HTML tag validation into complex systems architecture. Search engines do not evaluate web pages as isolated files; they render them as interconnected systems. If Page A canonically points to Page B, but Page B is blocked by an obscure robots.txt wildcard rule, a traditional "SEO Checker" will incorrectly report that both pages are perfectly optimized. The Website Crawl & Index Audit Platform solves this by diagnosing the exact root causes of Google Search Console errors completely offline in your browser.
1. Platform Foundation Detection & AST Parsing
The first step to fixing an indexation error is understanding the environment. Standard validators destroy proprietary CMS tags. Our engine utilizes specialized AST (Abstract Syntax Tree) parsers based on the detected platform:
- Google Blogger Compiler: Uses a custom XML AST engine to parse proprietary nodes. It traverses conditional
<b:if>and<b:switch>scopes, checking for conditional archive errors (which cause massive duplicate indexing) and missing nativeall-head-contentdependencies without breaking your template layout. - WordPress Analysis: Scans DOM signatures and paths to detect installations and common plugins. Evaluates theme-generated canonical graphs for pagination loops or conflicts.
- Static HTML/Jamstack: Performs pure DOM evaluation, URL normalization, internal link extraction, and exact-match canonical validation.
2. The Search Console Root Cause Engine
Google Search Console (GSC) tells you what is wrong, but rarely why. Our platform reverse-engineers these statuses by mapping raw code anomalies to GSC error codes, generating a complete dependency graph for each issue:
- Duplicate without user-selected canonical: Triggered when the engine finds HTML files missing the
rel="canonical"tag, or when Blogger XML lacks the native SEO include tag. - Duplicate, Google chose different canonical: The Canonical Graph Solver triggers this if you declare a canonical that points to a 404 dead end, a meta-refresh chain, or a file blocked by robots.txt, forcing Google to ignore your directive.
- Excluded by 'noindex' tag: Identifies the exact DOM node where a meta robots noindex tag is forcibly dropping a page.
- Page with redirect: Simulates meta-refresh redirects offline to map redirect chains and warn about infinite routing loops.
- Crawled - currently not indexed (Crawl Budget Risk): Correlates with the Internal Link Simulator. If the engine finds an Orphan page (zero inbound links) or excessive depth (>3 clicks), it flags it because Googlebot cannot discover enough internal PageRank to justify indexing it.
- Submitted URL blocked by robots.txt: Evaluates advanced wildcards and precedence rules in your uploaded robots.txt file to warn you if paths defined in your sitemap.xml are actively disallowed.
3. URL Normalization & Target Domain Mapping
Offline analysis often fails because of URL fragmentation (e.g., /about vs /about/index.html vs /about?utm=header). By declaring your Target Domain, our URL Normalization Engine strips fragments, handles trailing slashes consistently, and drops common tracking parameters to build a mathematically accurate adjacency matrix. This resolves false 404s and ensures the canonical graph accurately reflects your live site structure.
4. Semantic Duplicate Clustering (Jaccard Approximation)
Detecting exact duplicate files is easy; detecting near-duplicates is hard. Our Advanced Duplicate Engine does not rely solely on exact body hashes. It extracts the innerText of the DOM body, actively strips navigation and footer elements, normalizes the whitespace, and generates semantic tri-grams. It uses a Jaccard approximation to detect files that share highly similar content. If these near-duplicates do not canonicalize to the same master URL, it maps a severe cannibalization conflict.
5. Patch Validation & Full-File Auto-Repair
Fixing code via automated Regex (string replacement) is dangerous. Our repair engine operates entirely differently.
It clones the AST, structurally injects the necessary fixes directly into the parsed nodes, and serializes it back to generate the complete, fully corrected file. But it doesn't stop there. The Patch Validation Engine takes the newly generated file, parses it back into a temporary AST, and re-runs the exact diagnostic rule that failed initially. Only if the system mathematically verifies that the GSC error is resolved does it offer the patch for download. You can review the exact Before/After code Diff, select which patches to approve, and download the entire fixed file ready to upload directly to your host. It preserves your formatting, custom scripts, and CMS namespaces perfectly.
Frequently Asked Questions
No. It performs offline structural analysis based on documented technical SEO signals. It maps these structural flaws to likely Google Search Console error categories. Live indexing depends on server configuration (e.g., 301 vs 302 HTTP status codes), which offline HTML cannot natively know. We clearly label these as 'Simulated' or 'Requires Live Server'. If you enable the Live HTTP Verification toggle, it will attempt to fetch real headers (CORS permitting).
It maps every canonical tag and meta-refresh in your project into a directional graph. It utilizes a cycle-detection loop algorithm. If Page A canonicalizes to Page B, but Page B canonicalizes back to Page A, it flags a 'Canonical Loop', exposing the exact path that traps search engine indexers.
Instead of basic string matching, it utilizes an XML Abstract Syntax Tree (AST) parser to validate Blogger's proprietary <b:widget>, <b:include>, and <b:if> nodes, checking for duplicate IDs, conditional scope errors, and missing native SEO includes.
The Internal Link Engine calculates the click-depth of every file from your root index. URLs buried deeper than 3-4 clicks are flagged as 'Crawl Budget Risks'. Search engines allocate limited resources per site; deep architecture often results in the 'Discovered - currently not indexed' Google Search Console status.
Absolutely not. The extraction, AST parsing, graph mapping, and code repair processes run entirely in your local browser's memory using HTML5 JavaScript APIs, ensuring complete privacy for your proprietary structures.