Alpha CrawlerAlpha Crawler
Free — No Credit Card — Up to 10,000 Pages

The Free Website Audit That Misses Nothing

Alpha Crawler runs a full technical SEO audit of your entire site — up to 10,000 pages — checking every metric from duplicate titles and orphan pages to schema validity, AI search visibility and JS execution timelines. All free. All in one crawl.

Run your free technical audit — no signup needed

Free foreverUp to 10,000 pages
See what it audits

10,000

Pages per crawl

150+

Checks run

1 click

AI action plan

100%

Free to use

Whole-Website Crawl — Up to 10,000 Pages

Enter any URL and Alpha Crawler spiders the entire site: discovers your XML sitemap, traverses the internal link graph and fetches every page. Track discovery, validation rate, anomalies and latency live as the crawl runs.

Alpha Crawler site health dashboard showing discovery, validation and technical health composite score

Page-by-Page Issue Detection

Every page is checked individually: title length and uniqueness, meta description presence and length, H1 balance, canonical status, indexability, text-to-HTML ratio, image alt integrity and response code. Issues are prioritised Critical → High → Medium → Low so you fix what matters first.

Internal pages table with per-page status, title length, meta description and response time

Whole-Website Issue Log

The Diagnostic Issue Log aggregates every problem site-wide, grouped by category and ranked by impact. Click any issue to filter the full URL list to only the affected pages — then export that filtered list directly to CSV or XLSX.

Diagnostic issue log showing duplicate titles, missing H1, orphan pages, not-in-sitemap and performance issues

Per-Page Deep Diagnostic

Click any URL for its complete anatomy: H1/H2 counts, DOM depth, external scripts, text ratio, inbound and outbound link graph with anchor text and status codes, asset counts and the asset execution lifecycle (DOM Buffer, JS Runtime, CSS Object Model, Asset Fetching) with millisecond timings.

URL diagnostic insights with DOM nodes, text ratio, inbound link graph and asset execution lifecycle

Scripts & Assets with HTTP Status Codes

Beyond HTML pages, the crawler inventories every JS file, stylesheet, image and other resource — each with its own HTTP status code. Broken scripts, missing images and dead CSS references surface immediately. Export the full asset inventory or filter to 4xx/5xx assets only.

Scripts and assets inventory with per-asset HTTP status codes, filter and export controls

Source Code Distribution

A whole-website footprint analysis: a donut chart of total assets split into HTML, CSS, JavaScript, Images and Other. An image-heavy or JS-heavy footprint is an early warning for page-weight and Core Web Vitals problems.

Source code distribution donut chart of total assets by file type across the whole website

Schema Distribution & Validation

Site-level schema footprint map shows which schema types (WebPage, Article, BreadcrumbList, Organization, Person, CollectionPage…) are deployed and on how many pages. Per-URL JSON-LD validation expands every entity property-by-property with a per-entity error count.

Schema distribution donut chart showing structured data types across all crawled pages

AI Search Visibility Check

The dashboard parses your robots.txt and reports whether AI crawlers — ChatGPT-User, OAI-SearchBot, Googlebot and Google-Extended — are permitted to access your site. Sites silently blocking these bots are invisible in AI-generated answers, and most owners never know.

Blocked from AI search panel showing robots.txt status for ChatGPT, OAI, Googlebot and Google-Extended

Complete Coverage

150+ Checks. Every Page. One Free Crawl.

Alpha Crawler evaluates every technical signal that affects crawlability, indexation, performance, and ranking — organized across 9 categories.

1. Indexability & Directives

24 checks
HTTP 200 OK — page loads successfully
HTTP 301/302 redirects detected
HTTP 404 Not Found errors
HTTP 500 Server Error detection
All other non-200 status codes flagged
Meta robots: noindex directive check
Meta robots: nofollow directive check
Meta robots: noarchive / nosnippet check
X-Robots-Tag HTTP header check
Canonical tag present (link rel=canonical)
Self-referencing canonical validation
Canonical pointing to different URL (cross-canonical)
Canonical chain detection (canonical → canonical)
Page present in XML sitemap
Page missing from XML sitemap
Sitemap auto-discovery via robots.txt
Manual sitemap URL support
HTTPS / SSL certificate valid
Mixed content (HTTP resources on HTTPS page)
Protocol coverage across all pages
AI crawler access: ChatGPT-User (robots.txt)
AI crawler access: OAI-SearchBot (robots.txt)
AI crawler access: Googlebot (robots.txt)
AI crawler access: Google-Extended (robots.txt)

2. On-Page Content & Metadata

29 checks
Title tag present
Title tag length (character count)
Title tag too long (truncated in SERPs)
Title tag too short
Duplicate title tag across pages
Title tag content extracted
Meta description present
Meta description length (character count)
Meta description too long
Meta description missing
Duplicate meta description across pages
Meta description content extracted
H1 tag present
H1 tag content extracted
H1 length validation
Multiple H1 tags on one page (balance mismatch)
H1 missing entirely
H2 tag count
H2 content extracted
Heading hierarchy check (H1 → H2 → H3 order)
Total word count on page
Text-to-HTML ratio (content density)
Low text-to-HTML ratio flagged
Readable text vs markup bloat
Page language attribute (lang=)
Open Graph title (og:title)
Open Graph description (og:description)
Open Graph image (og:image)
Twitter card meta tags

3. Site Architecture & Links

20 checks
Crawl depth (clicks from start URL)
Directory level (folder depth in URL path)
Depth distribution across all pages
Total internal link edges (connectivity)
Internal link count per page (outbound dispatch)
External link count per page
Inbound links (inlinks) per page tracked
Outbound links (outlinks) per page tracked
Anchor text for every inbound link
Anchor text for every outbound link
Link status code (200/404/301) per link
Broken internal links (4xx/5xx targets)
Orphan pages (zero internal inlinks)
Redirect chains in internal links
Unique inlink count per URL
Unique outlink count per URL
Internal link graph visualization
Site architecture: directory list view
Site architecture: horizontal tree view
Semantic density (average words/page site-wide)

4. Assets & Media

18 checks
Total image count per page
Images missing alt attributes
Alt integrity score per page
External script count
Inline script count (<script> tags)
Stylesheet (CSS) count per page
All assets crawled with HTTP status codes
Broken scripts (4xx/5xx JS files)
Broken stylesheets (4xx/5xx CSS files)
Broken images (4xx/5xx image URLs)
Document size (page weight in KB)
Source code distribution: HTML %
Source code distribution: CSS %
Source code distribution: JavaScript %
Source code distribution: Images %
Source code distribution: Other assets %
Total asset count site-wide
Asset inventory export (CSV/XLSX)

5. DOM & Technical Structure

16 checks
DOM node count (total HTML elements)
DOM depth (nesting level)
Large DOM flagged (>1500 nodes warning)
Asset execution lifecycle: DOM Buffer (ms)
Asset execution lifecycle: JS Runtime (ms)
Asset execution lifecycle: CSS Object Model (ms)
Asset execution lifecycle: Asset Fetching (ms)
Render-blocking resources detected
Unused JavaScript execution detected
Large JavaScript payload size flagged
Long main-thread tasks detected
JavaScript rendering mode (static / JS-rendered)
Page response time / latency (ms)
Server response time per URL
Infrastructure health: 200 OK success rate %
Protocol coverage: SSL/TLS verified nodes %

6. Structured Data (Schema)

20 checks
JSON-LD script blocks detected per page
Schema type: WebPage
Schema type: WebSite
Schema type: Organization
Schema type: BreadcrumbList
Schema type: ImageObject
Schema type: Article
Schema type: Person
Schema type: CollectionPage
Schema type: Product
Schema type: FAQPage
Schema type: LocalBusiness
Schema type: Event
Schema type: Review / AggregateRating
Per-entity property validation (@type, @id, url, name…)
Error count per schema entity
Site-wide schema type distribution chart
Page-level schema type badges
Schema present / missing per page
Structured data export and reporting

7. Performance (Lighthouse / PageSpeed)

16 checks
FCP — First Contentful Paint (ms)
LCP — Largest Contentful Paint (ms)
CLS — Cumulative Layout Shift (score)
TBT — Total Blocking Time (ms)
INP — Interaction to Next Paint (ms)
Speed Index
Render-blocking resource list
Unused JavaScript (bytes / files)
Unused CSS (bytes / files)
Large payload size warnings
Long task count on main thread
DOM Buffer timing (ms)
JS Runtime timing (ms)
CSS Object Model build time (ms)
Asset fetch timing (ms)
Per-page latency / response time (ms)

8. Crawl Analytics & Reporting

20 checks
Total pages crawled
Discovery count (URLs found)
Validation rate % (pages fully validated)
Anomaly count
Errors count (critical issues)
Warnings count (medium issues)
Pages with issues count
Healthy / Broken / Have Issues / Redirects / Blocked breakdown
Technical health composite score (0–100%)
Security (HTTPS) sub-score
Top-10% website benchmark comparison
Depth distribution bar chart (Depth 0/1/2/3+)
Status codes mix donut chart (2xx/3xx/4xx/5xx)
Internal connectivity (total link edges)
Semantic density (avg words/page)
AI Summary (Gemini-powered action plan)
CSV export for every report view
XLSX export for every report view
Filter-respecting exports (export only filtered URLs)
Google Search Console integration (clicks, impressions, rankings)

9. Custom Extractions & Configuration

15 checks
Max pages to crawl (10 – 10,000)
Maximum crawl depth (1 – 10 levels)
Include subdomains toggle
Limit to path / subdirectory toggle
Auto-discover XML sitemaps (robots.txt scan)
Manual sitemap URL input (priority indexing)
Exclusion regex pattern
Custom crawl segments (URL pattern grouping)
Custom extraction: CSS selector rules
Custom extraction: XPath selector rules
Gemini API key (AI summaries, stored locally)
JavaScript rendering engine toggle
Session-based crawl pause / stop controls
Crawl state management (resume / erase data)
Crawl Trace status indicator

All 178+ checks run automatically — no configuration needed for the essentials.

How It Works

From URL to Full Audit Report in Minutes

1

Enter Your URL

Paste any domain or page URL into the address bar. No login, no signup.

2

Configure (Optional)

Set crawl depth (1–10), max pages (up to 10,000), sitemap URLs or path scope.

3

Launch the Crawl

Alpha Crawler discovers your sitemap, traverses every internal link and validates each page live.

4

Get Your Report

Receive the full diagnostic report. Generate an AI summary. Export CSV or XLSX.

What Users Say

Trusted by SEO Professionals

“The technical audit was incredibly detailed. It uncovered issues that other SEO tools completely missed.”

RM

Recall Media

SEO Agency

“Excellent technical SEO tool. The crawl reports are thorough, actionable, and easy to understand.”

R

Robert

SEO Manager, Digital Agency

“I was impressed by how relevant the AI suggestions were. They helped us prioritize the issues that mattered most.”

RJ

Rajesh

Head of SEO

For Agencies & Enterprises

Need to Audit Hundreds of Client Sites?

The free plan covers 10,000 pages per crawl. For agencies managing multiple clients at scale, we offer extended limits, scheduled automated audits, multi-client workflows and priority support.

10K+

Pages / Crawl

150+

Checks Run

AI

Summaries

Free

Always

Rendering Intelligence

Works on Static & JavaScript-Rendered Sites

Alpha Crawler can audit both server-rendered and JavaScript-heavy sites — so your React, Next.js, Vue or Angular site gets the same deep technical audit as a classic HTML site.

Static / Server-Side Rendering

For traditional HTML sites and server-rendered frameworks (WordPress, Shopify, PHP, Django, Rails, Next.js SSR), the crawler fetches and parses the HTML directly — fast, thorough and accurate.

  • Full HTML parsed on first fetch
  • All metadata extracted immediately
  • Fastest crawl speed
  • 100% accurate on SSR frameworks
  • Works on WordPress, Shopify, Drupal, Magento

JavaScript / Client-Side Rendering

Enable JS Rendering mode in Crawler Configuration to audit React, Vue, Angular, Next.js CSR and other client-rendered sites. The crawler waits for the JS to execute before extracting content.

  • JS executes before page analysis
  • Detects dynamically injected metadata
  • Catches client-side rendered H1s and titles
  • Identifies JS-rendered schema markup
  • Toggle in Crawler Configuration settings

WordPress

SSR

Shopify

SSR

Next.js

SSR + JS

React SPA

JS Mode

Vue / Nuxt

JS Mode

Angular

JS Mode

Webflow

SSR

Wix / Squarespace

SSR

FAQ

Frequently Asked Questions

Run Your Free Website Audit Now

No signup. No credit card. No page limit tricks. Paste your URL and get the full technical picture in minutes.

Questions? support@alphacrawler.org