The complete website audit platform. Analyze your site across 160+ checks covering SEO, performance, security, accessibility, and AI search readiness — in seconds.
No signup required. No credit card. Instant results.
Each check comes with a detailed guide explaining what it is, why it matters, and how to fix it. Click any check to learn more.
Title tags, descriptions, headings, keywords, and on-page content signals.
Checks for the presence, length, and content of the meta title tag.
Evaluates the meta description for its presence, length, and relevance.
Verifies the presence and uniqueness of the H1 heading tag.
Checks for the presence and structure of H2 heading tags.
Ensures all images have descriptive ALT attributes for accessibility and SEO.
Analyzes the page content to identify the most frequently used keywords.
Checks if the main keywords are present in the title, description, and headings.
Visualizes the most frequent keywords on the page in a tag cloud.
Counts the total number of words on the page.
Compares publication dates across meta tags, structured data, and sitemap lastmod for consistency.
Detects multiple title tags, meta descriptions, or H1 headings on a single page.
Advisory classification of likely search intent: informational, transactional, commercial, local, or how-to.
Advisory analysis of how well your content structure supports AI systems extracting and understanding your content.
Detects substantially similar content across multiple pages on your site.
Identifies indexable pages with very little unique body content after removing boilerplate.
Finds multiple pages competing for the same primary keywords.
Finds pages across your site that share identical or near-identical title tags and meta descriptions.
Calculates the ratio of visible text content to total HTML code on the page.
Checks for the presence of About, Contact, Privacy Policy, and other trust-building pages.
Identifies pages where the title tag and primary H1 are completely unrelated.
Identifies whether factual claims or articles have external references.
Crawlability, indexability, canonical tags, sitemaps, and robots.txt.
Validates the presence and accessibility of the robots.txt file.
Confirms the presence of a sitemap in robots.txt.
Checks for the presence of an image sitemap to improve image indexing.
Checks for noindex meta tags or headers that might block search engines.
Scans the page for any broken internal or external links.
Ensures the domain consistently resolves to one version (WWW or non-WWW).
Verifies the implementation of canonical tags to prevent duplicate content.
Scans for outdated HTML tags that are no longer supported.
Checks if a favicon is present and correctly configured.
Checks if the URL is user-friendly and optimized for search engines.
Checks for a declared character set (e.g., UTF-8).
Detects the use of Adobe Flash, which is obsolete and unsupported.
Checks for nested tables, which should not be used for layout.
Checks for the use of framesets, which are outdated and bad for SEO.
Verifies that the page has a modern HTML doctype declaration.
Checks if the server returns a 404 HTTP status code for non-existent pages.
Checks for meta refresh tags which can be confusing for users and search engines.
Checks for the presence of an ads.txt file for advertising transparency.
Checks for the presence of heatmap and session replay tools like Clarity or Hotjar.
Advanced robots.txt syntax validation, conflict detection, and AI crawler directive analysis.
Full XML sitemap validation including structure, URL count, lastmod, duplicates, and sitemap index support.
Advanced canonical tag analysis: multiple canonicals, relative URLs, cross-domain canonicals, and mismatch detection.
Validates hreflang language tags syntax, self-reference, and return tag requirements.
Identifies the CMS, framework, and platform used to build this site.
Checks for duplicate IDs, empty links, empty buttons, and missing lang attribute.
Analyzes robots.txt directives for AI crawlers: GPTBot, Google-Extended, ClaudeBot, PerplexityBot, and others.
Checks for the emerging /llms.txt convention for AI-readable site documentation.
Detects heavy Client-Side Rendering (CSR) by comparing initial HTTP payload to fully rendered DOM.
Detects URLs that pass through multiple redirects before reaching a final destination.
Detects circular redirect patterns that prevent users and crawlers from reaching a page.
Detects pages that show error content but return HTTP 200 instead of a proper 404 status code.
Scans all crawled URLs for unexpected status codes including server errors, redirects, and access-denied responses.
Finds indexable pages in the sitemap that have no internal links pointing to them.
Calculates the minimum number of clicks from the homepage to reach each crawlable page.
Inspects HTTP headers for indexing directives like noindex and nofollow.
Confirms that the canonical URL target returns a 200 OK status and is indexable.
Identifies conflicts between HTML meta tags and HTTP X-Robots-Tag headers.
Checks consistency across trailing slashes, WWW, and HTTPS versions.
Validates specific directives like max-snippet and max-image-preview.
Detects critical assets blocked in robots.txt that interfere with rendering.
Sitemap XML, redirect analysis, hreflang, security headers, cookie audit, cache, and content freshness.
Checks for the presence of a nofollow meta tag.
Checks for disallowed paths in the robots.txt file.
Reports how many internal links point to each page and identifies under-linked important pages.
Analyzes internal link anchor text for diversity, generic anchors, and over-optimization.
Identifies internal links marked with rel="nofollow" where that is likely unintended.
Detects filter, sort, and parameter URLs that could create excessive crawlable combinations.
Detects paginated content and validates crawlable page links and self-referencing canonicals.
Reports the number of backlinks and unique referring domains pointing to your site.
Identifies external backlinks pointing to pages on your site that return 404 errors.
Reports an estimated domain authority or trust score from third-party SEO data providers.
WCAG compliance, ARIA, keyboard navigation, color contrast, and screen readers.
Checks for proper use of semantic tags like <main>, <nav>, etc.
Ensures headings (<h1>-<h6>) are logically ordered and not skipping levels.
Ensures all form inputs have associated labels for accessibility.
Checks if all interactive elements are reachable via the Tab key.
Checks for sufficient contrast between text and background colors.
Checks that link text is descriptive and not generic like "click here".
Checks for potentially problematic use of ARIA roles and attributes.
Checks that the document has a language attribute defined (e.g., <html lang="en">).
Checks if data tables use headers (<th>) and captions.
Checks for the presence of captions or transcripts for <video> and <audio> elements.
Checks that focus styles have not been improperly removed.
Checks for the presence of a "Skip to main content" link for keyboard users.
Checks if the page is readable and functional when zoomed to 200%.
Checks for the use of CAPTCHAs, which can be an accessibility barrier.
Checks for prefers-reduced-motion CSS support on animations and transitions.
Checks that buttons, links, form controls, and custom widgets have accessible names for screen readers.
Detects unlabeled or duplicate ARIA landmarks.
Identifies if keyboard users become trapped in components.
Core Web Vitals, caching, resource hints, image optimization, and load time.
Checks if images use responsive techniques like srcset.
Checks if images have width and height attributes to prevent layout shift.
Checks for JavaScript errors in the browser console. (Note: In-dev check)
Measures the total size of the HTML document.
Checks if GZIP or Brotli compression is enabled.
Detects the use of inline CSS, which can affect performance.
Checks if images are served in modern formats like WebP for better compression and quality.
Measures the server's response time to the first byte.
Measures the time until the first content is painted on the screen.
Measures the time until the largest content element is painted.
Measures visual stability to ensure a smooth user experience.
Counts the number of page resources (CSS, JS, images).
Checks if the site appears to be using a Content Delivery Network.
Checks if images contain excessive EXIF metadata.
Checks if JavaScript files are minified to reduce their size.
Checks if CSS files are minified to reduce their size.
Identifies scripts and stylesheets that can block page rendering.
Audits preload, preconnect, dns-prefetch, and prefetch hints for correctness.
Checks Cache-Control headers, ETag, and Last-Modified for proper caching configuration.
Detects HTTP/3 and QUIC support via the Alt-Svc header.
Extended image audit: HTTP vs HTTPS images, dimensions for CLS, lazy loading, and srcset usage.
Measures input responsiveness — the delay between user interaction and the next visual update.
Estimates downloaded but unused code payload.
Compares delivered dimensions against rendered size for optimization opportunities.
Responsive design, viewport, mobile content parity, and tap target usability.
Ensures a viewport meta tag is present to control layout on mobile browsers.
Checks for the use of CSS media queries for responsive design.
Provides a visual snapshot of the page on a mobile device.
Compares rendered mobile and desktop versions for differences in content, links, and headings.
Identifies interactive elements that are too small or too close together for reliable mobile tapping.
Detects popups, overlays, and full-screen interstitials that block main content on mobile.
HTTPS, security headers, cookies, SPF, DMARC, CSP analysis, and email authentication.
Verifies the validity and configuration of the SSL certificate.
Checks if the site is secured with a valid SSL certificate.
Ensures that HTTP traffic is automatically redirected to HTTPS.
Checks for insecure (HTTP) resources on a secure (HTTPS) page.
Checks if the server supports the modern HTTP/2 protocol for better performance.
Checks for the presence of the Strict-Transport-Security header.
Checks for exposed server version headers which can be a security risk.
Checks if directory listing is disabled on the server.
Detects plain text email addresses on the page.
Checks for target="_blank" links without rel="noopener".
Checks for Open Graph and Twitter Card meta tags for social sharing.
Checks for the presence of common analytics tracking scripts (Google Analytics, Adobe Analytics, JSLL, etc.).
Checks for links to privacy policy, terms of service, and other legal pages.
Checks if the domain has an SPF record to prevent email spoofing.
Checks for recommended security headers: CSP, Referrer-Policy, Permissions-Policy, X-Content-Type-Options.
Checks cookies for Secure, HttpOnly, and SameSite attributes.
Validates SPF record syntax, detects multiple SPF records, and checks for excessive DNS lookups.
Checks for a DMARC TXT record and validates the policy configuration.
Analyzes Content Security Policy quality — flags unsafe-inline, unsafe-eval, and wildcard sources.
Checks for X-Frame-Options and CSP frame-ancestors to prevent clickjacking attacks.
Checks for overly permissive CORS settings that could expose your API to unauthorized access.
Checks the TLS protocol version and identifies outdated or insecure configurations.
Checks how many days until the SSL/TLS certificate expires and alerts if expiration is imminent.
Checks for the presence of a security.txt file at /.well-known/security.txt.
Checks for publicly accessible JavaScript source maps that expose original source code.
Flags forms submitting to HTTP or insecure external endpoints.
Structured data validation, schema audits, E-E-A-T signals, and JavaScript SEO.
Detects Schema.org JSON-LD structured data.
Detects video content and validates VideoObject structured data for title, thumbnail, duration, and upload date.
Validates Product and Offer structured data for ecommerce sites.
Validates LocalBusiness structured data for name, address, telephone, and opening hours.
Validates JSON-LD formatting and catches malformed JSON, broken escaping, and parsing failures.
Tests structured data against Google's rich result requirements for FAQs, reviews, recipes, and more.
Flags structured data values that don't match visible page content.
Validates FAQPage structured data and checks that questions and answers are visible on the page.
Validates breadcrumb structured data for correct positions, URLs, and hierarchy.
Validates Organization structured data for name, URL, logo, and social profiles.
Validates Article/BlogPosting structured data for headline, image, author, publisher, and dates.
Validates Review and AggregateRating structured data for proper rating values and review content.
Detects multiple identical schema types on the same page that may confuse search engines.
Identifies contradictory values across multiple schema blocks on the same page.
Checks for author bylines, author pages, and Person structured data on article-style content.