Every one of the 196 checks AudEsto's audit engine runs, in one place -- what each check actually looks at, and why it matters for search engines and AI answer engines. Use it to understand a result on your report, or to learn the reasoning behind the score before you run an audit at all.
Run a free audit and every result links straight back to the matching section here.
Crawlability, security, performance, and the markup that lets search engines fetch and render a page at all.
What it is: Confirms the site serves its pages over HTTPS rather than plain HTTP.
Why it matters: HTTPS is a confirmed Google ranking signal and browsers flag HTTP sites as "Not Secure," which erodes trust and click-through.
What it is: Checks that requests to the HTTP version of a URL 301-redirect to its HTTPS equivalent.
Why it matters: Without this redirect, search engines can index both HTTP and HTTPS copies of a page, splitting link equity and creating duplicate content.
What it is: Verifies the TLS certificate is currently valid, correctly chained, and issued for the requested domain.
Why it matters: An invalid certificate triggers browser security warnings that block most visitors before they ever see the page.
What it is: Tests whether the layout adapts cleanly at typical smartphone widths without horizontal scrolling or overlapping elements.
Why it matters: Google indexes and ranks primarily using the mobile version of a page (mobile-first indexing), so a broken phone layout directly hurts rankings.
What it is: Tests whether the layout adapts correctly at tablet-range viewport widths.
Why it matters: A large and fast-growing share of traffic arrives on tablets; a layout that only works at phone or desktop widths loses that audience.
What it is: Tests whether the layout holds up on wide desktop viewports without wasted whitespace or broken grids.
Why it matters: A layout that only tuned for mobile can look broken or unfinished on desktop, undermining credibility for the majority of B2B research traffic.
What it is: Checks for a `<meta name="viewport">` tag that tells mobile browsers how to scale the page.
Why it matters: Without it, mobile browsers render the desktop layout and shrink it to fit, producing tiny unreadable text on phones.
What it is: Checks whether a robots.txt file exists at the domain root.
Why it matters: robots.txt is the standard place crawlers look for crawl directives and a sitemap pointer; its absence isn’t fatal but is a missed control point.
What it is: Parses robots.txt to confirm its directives (User-agent, Disallow, Allow, Sitemap) are syntactically valid.
Why it matters: A malformed robots.txt can be misread by crawlers, accidentally blocking pages that should be indexed or allowing ones that shouldn’t be.
What it is: Checks whether an XML sitemap exists at the expected location.
Why it matters: A sitemap gives search engines a direct, complete list of URLs to crawl instead of relying purely on discovering links.
What it is: Measures how long the server takes to send the first byte of the response after a request.
Why it matters: TTFB is the floor under every other loading metric -- a slow server response delays everything downstream and is a direct Core Web Vitals input.
What it is: Checks whether the server compresses text responses (HTML/CSS/JS) with Brotli or Gzip.
Why it matters: Compression can cut transfer size by 70%+ with no quality loss, directly speeding up page load on every connection.
What it is: Checks how many days remain before the current TLS certificate expires.
Why it matters: An expired certificate takes the entire site offline behind browser warnings with no advance notice to visitors.
What it is: Measures how long DNS lookups for the domain take to resolve.
Why it matters: Slow DNS adds delay before a browser can even start connecting, on top of whatever the server itself takes to respond.
What it is: Checks whether HTTP response headers leak the server software and OS version.
Why it matters: Publishing exact server/OS versions gives attackers a head start matching known vulnerabilities to your stack.
What it is: Validates that any JSON-LD structured data on the page parses as well-formed JSON.
Why it matters: A syntax error in JSON-LD makes the entire schema block unreadable to search engines, silently losing any rich-result eligibility it was meant to provide.
What it is: Checks for a favicon linked or present at the conventional location.
Why it matters: Favicons appear in browser tabs, bookmarks, and search results; a missing one reads as unfinished or untrustworthy.
What it is: Checks for an apple-touch-icon link tag used when the site is saved to an iOS home screen.
Why it matters: Without it, iOS falls back to a generic screenshot-based icon instead of your brand mark for home-screen shortcuts.
What it is: Checks whether CSS files are minified (whitespace/comments stripped) rather than served as raw source.
Why it matters: Minification reduces file size and parse time with zero visual impact, a straightforward performance win.
What it is: Checks whether JavaScript files are minified rather than served as raw source.
Why it matters: Unminified JS ships unnecessary bytes and can meaningfully slow parsing and execution on slower devices.
What it is: Scans for meta robots or X-Robots-Tag headers set to noindex or nofollow.
Why it matters: A stray noindex tag -- often left over from staging -- silently removes an important page from search results entirely.
What it is: Measures how much CSS is written inline via `style` attributes rather than in stylesheets.
Why it matters: Heavy inline styling bloats HTML payload and blocks the browser from caching styles across pages.
What it is: Checks that the page declares a character encoding (typically UTF-8).
Why it matters: Without an explicit charset, browsers may guess wrong and render special characters, symbols, or non-Latin text as garbled glyphs.
What it is: Checks for an X-Frame-Options (or equivalent CSP frame-ancestors) header restricting who can embed the page in an iframe.
Why it matters: Without it, an attacker can frame your page inside their own site and trick users into clicking things they can’t see (clickjacking).
What it is: Checks for the `X-Content-Type-Options: nosniff` header.
Why it matters: Without it, browsers may reinterpret a file’s type based on content rather than its declared Content-Type, opening a path for disguised malicious files.
What it is: Checks whether a Content-Security-Policy header restricts which sources scripts, styles, and other resources can load from.
Why it matters: CSP is one of the strongest defenses against cross-site scripting (XSS) by blocking unauthorized script execution outright.
What it is: Checks for a `lang` attribute on the `<html>` tag declaring the page’s language.
Why it matters: Search engines and screen readers use this to serve the page to the right audience and pronounce content correctly.
What it is: Checks whether the page uses modern CSS Flexbox/Grid rather than legacy float- or table-based layout hacks.
Why it matters: Modern layout systems render more predictably across devices and are far easier to make genuinely responsive.
What it is: Checks for BreadcrumbList structured data marking up the page’s position in the site hierarchy.
Why it matters: Breadcrumb schema can make Google show a clean hierarchical path in search results instead of a raw URL, improving click-through.
What it is: Checks whether an AMP (Accelerated Mobile Pages) version of the page is linked, where applicable.
Why it matters: For publishers still relying on AMP surfaces, a missing or broken AMP link forfeits eligibility for those placements.
What it is: Checks that paginated content exposes real crawlable `<a href>` links between pages rather than JS-only pagination.
Why it matters: Crawlers that can’t click a "Next page" button rely on real anchor links to discover page 2, 3, and beyond.
What it is: Checks whether icons and simple graphics use SVG rather than raster images.
Why it matters: SVGs stay sharp at any size and are typically far smaller than an equivalent PNG, helping both quality and load time.
What it is: Checks for `<link rel="dns-prefetch">` hints for third-party domains the page connects to.
Why it matters: DNS prefetching resolves external hostnames early, shaving latency off requests to CDNs, fonts, and third-party scripts.
What it is: Measures how deeply nested and how large the page’s DOM tree is.
Why it matters: A bloated DOM slows down style recalculation and rendering, and is explicitly flagged by Lighthouse as a performance risk.
What it is: Checks an HTTPS page for resources (images, scripts, styles) still loaded over plain HTTP.
Why it matters: Mixed content triggers browser warnings and can be silently blocked, breaking images or scripts on an otherwise secure page.
What it is: Checks that a page’s canonical tag points to itself when there’s no duplicate to consolidate.
Why it matters: A missing or misdirected self-canonical leaves the page’s preferred URL ambiguous to search engines.
What it is: Checks that the server negotiates modern, strong TLS cipher suites rather than deprecated weak ones.
Why it matters: Outdated ciphers are vulnerable to known attacks and can trigger security warnings or reduced trust indicators in modern browsers.
What it is: Checks whether cookies are flagged Secure (HTTPS-only) and HttpOnly (inaccessible to JavaScript).
Why it matters: Without these flags, cookies can be intercepted over insecure connections or stolen via cross-site scripting.
What it is: Checks that links opening in a new tab (`target="_blank"`) include `rel="noopener"`.
Why it matters: Without `noopener`, the linked page can access and manipulate the original tab via `window.opener` -- a known phishing/security risk.
What it is: Checks for `<link rel="preload">` hints on assets critical to first render (hero image, key font, etc.).
Why it matters: Preloading tells the browser to fetch render-critical assets immediately instead of discovering them late in the parse, improving perceived load speed.
What it is: Measures total JavaScript payload size delivered to the page.
Why it matters: Heavy JS bundles delay interactivity and directly worsen Core Web Vitals metrics like Total Blocking Time.
What it is: Reports Largest Contentful Paint -- how long the largest visible element takes to render.
Why it matters: LCP is one of Google’s three Core Web Vitals and a direct ranking factor measuring perceived load speed.
What it is: Reports how long the main thread was blocked by long tasks, delaying responsiveness to input.
Why it matters: High TBT means the page looks loaded but doesn’t actually respond to clicks or taps, a common source of user frustration.
What it is: Measures how much visible content unexpectedly shifts position while the page loads.
Why it matters: CLS is a Core Web Vital; layout jumps cause mis-clicks and a jarring experience, and directly hurt rankings.
What it is: Checks how heavily the site relies on query-string parameters (`?sort=`, `?ref=`, etc.) to generate URLs.
Why it matters: Uncontrolled parameter combinations can multiply into near-duplicate URLs that waste crawl budget and dilute ranking signals.
What it is: Checks usage of `#fragment` anchor links for in-page navigation.
Why it matters: Hash-only routing (common in older single-page apps) can hide distinct content from crawlers that treat the fragment as the same URL.
What it is: Checks for a linked RSS or Atom feed, typically for blog/news content.
Why it matters: Feeds help syndication, aggregators, and some discovery/crawl pathways pick up new content quickly.
What it is: Counts elements using inline `style` attributes across the page.
Why it matters: Excessive inline styling increases HTML weight and makes consistent, cacheable styling harder to maintain.
What it is: Checks for hreflang tags declaring language/region-specific versions of a page.
Why it matters: Without hreflang, search engines can serve the wrong language version to users, or treat regional variants as duplicate content.
What it is: Measures how many clicks deep a page sits from the homepage in the site’s link structure.
Why it matters: Pages buried many clicks deep get crawled less often and receive less internal link equity, hurting their ranking potential.
What it is: Checks for a Strict-Transport-Security header forcing browsers to only ever connect over HTTPS.
Why it matters: HSTS closes the window for downgrade attacks by making the browser refuse HTTP entirely for future visits, even before a redirect can run.
What it is: Checks that the www and non-www versions of the domain don’t both resolve as separate, non-redirecting sites.
Why it matters: Two live versions of the same site split ranking signals and can be crawled and indexed as duplicate content.
What it is: Checks whether the server supports the modern HTTP/2 or HTTP/3 protocols instead of only HTTP/1.1.
Why it matters: Newer protocols multiplex requests over one connection, cutting latency meaningfully versus HTTP/1.1’s one-request-at-a-time model.
What it is: Detects URLs that redirect through multiple hops before reaching their final destination.
Why it matters: Each extra hop adds latency and wastes crawl budget; long chains can also cause crawlers to give up before reaching the final page.
What it is: Checks that canonical tags don’t point in a circular chain (A canonicalizes to B, B back to A).
Why it matters: A canonical loop gives search engines no clear signal for which URL is authoritative, and both can end up poorly indexed.
What it is: Reports that the audit itself was blocked from fetching the target because it resolved to a private, internal, or otherwise unsafe network address.
Why it matters: This protects against SSRF abuse; it also means the URL entered isn’t a normal public website reachable the way visitors and crawlers would reach it.
What it is: Confirms the domain itself (not just individual pages) is correctly served over HTTPS.
Why it matters: A domain-level HTTPS failure affects every page on the site at once and is one of the most basic trust and ranking prerequisites.
What it is: Confirms robots.txt is actually reachable at the domain root during a full site crawl.
Why it matters: If robots.txt can’t be fetched, crawlers may fall back to conservative default behavior instead of respecting your intended crawl rules.
What it is: Confirms a sitemap.xml is discoverable during a full site crawl, typically via robots.txt or the conventional path.
Why it matters: A missing sitemap forces search engines to rely entirely on link discovery, which can miss pages with weak internal linking.
What it is: Counts crawled pages that returned a hard error status (4xx/5xx) across the whole site.
Why it matters: Error pages waste crawl budget, break the user journey, and can be a sign of a larger structural problem like a bad migration.
What it is: Checks a sample of crawled pages for the presence of a canonical tag.
Why it matters: Consistent canonical tags across the site prevent duplicate-content ambiguity at scale, not just on individual pages.
What it is: Flags URLs that run unusually long across the crawled site.
Why it matters: Very long URLs are harder to share, read, and remember, and can signal disorganized parameter- or ID-heavy URL structures.
What it is: Detects multiple crawled pages sharing the exact same `<title>` tag.
Why it matters: Duplicate titles make it harder for search engines to tell pages apart and for users to distinguish results in the SERP.
What it is: Detects multiple crawled pages sharing the exact same meta description.
Why it matters: Repeated descriptions waste an opportunity to differentiate each page’s snippet and improve click-through from search results.
What it is: Finds `<img>` sources across the crawl that return an error instead of an image.
Why it matters: Broken images look unpolished, hurt user trust, and waste the alt-text/accessibility value the image was meant to provide.
What it is: Reports that this specific page could not be retrieved at all during the audit.
Why it matters: If the audit can’t fetch a page, neither can a search engine crawler under similar conditions -- the page is effectively invisible.
What it is: Reports that the page responded with an HTTP status other than 200 OK.
Why it matters: Anything other than a clean 200 (or an intentional redirect) tells search engines something is wrong with that URL.
What it is: Reports that the URL resolves to a non-HTML resource (PDF, image, JSON, etc.), which most on-page checks don’t apply to.
Why it matters: Running text/heading/meta checks against a non-HTML resource would produce meaningless results, so this flags it instead.
What it is: Checks that this individual crawled page, specifically, loads over HTTPS.
Why it matters: A site can have HTTPS configured at the domain level yet still leak individual pages over HTTP through old links or misconfiguration.
What it is: Checks that this specific page has a canonical tag, and that it points where it should.
Why it matters: A missing or mismatched canonical on even one important page can cause it to be indexed under the wrong URL.
What it is: Checks this page’s meta robots tag (and X-Robots-Tag header) for noindex/nofollow directives.
Why it matters: An accidental noindex on a single important page removes just that page from search results without affecting the rest of the site -- easy to miss.
Titles, headings, content quality, and the internal signals that tell search engines what a page is about.
What it is: Checks that the page has a `<title>` tag at all.
Why it matters: The title tag is the single strongest on-page relevance signal and is almost always what search engines display as the clickable headline.
What it is: Checks the title length falls in the range that search engines typically display in full without truncating.
Why it matters: A title that gets cut off in search results loses its message and its call to click right at the moment it matters most.
What it is: Checks that this page’s title differs from titles on other pages of the site.
Why it matters: Identical titles across pages make it harder for search engines and users to tell which result actually answers their query.
What it is: Checks whether the page’s target keyword appears in the title tag.
Why it matters: Keyword presence in the title remains one of the clearest relevance signals search engines use to match queries to pages.
What it is: Checks that the page has a meta description tag.
Why it matters: A written description gives you control over the search-result snippet instead of leaving it to an auto-generated excerpt.
What it is: Checks the meta description length against the range search engines typically show without truncation.
Why it matters: An overly long description gets cut off mid-sentence in results, and a too-short one wastes space that could sell the click.
What it is: Checks whether the target keyword appears in the meta description.
Why it matters: Search engines bold matching query terms in the snippet, which draws the eye and reinforces relevance to the searcher.
What it is: Checks the URL is readable, hyphen-separated, and free of unnecessary IDs or parameter clutter.
Why it matters: Clean URLs are easier for users to read and trust, and give search engines an extra readable relevance signal.
What it is: Checks that the URL path isn’t excessively long.
Why it matters: Shorter, more direct URLs are easier to share, remember, and display in full within search results.
What it is: Checks whether the URL slug includes the page’s target keyword.
Why it matters: A keyword-aligned slug reinforces topical relevance and is visible in the search-result URL line itself.
What it is: Checks that the page uses exactly one H1 heading.
Why it matters: A single H1 gives both users and search engines one unambiguous statement of what the page is about; multiple H1s dilute that signal.
What it is: Checks whether the H1 heading includes the page’s target keyword.
Why it matters: The H1 is the first thing both users and crawlers read as the page’s main topic statement.
What it is: Checks that headings descend in logical order (H1 then H2 then H3) without skipping levels.
Why it matters: A broken hierarchy (H1 straight to H4, for example) confuses both screen readers and search engines trying to parse the page’s outline.
What it is: Checks overall heading usage for structural soundness across the page.
Why it matters: A well-structured heading outline helps search engines break the page into topics and helps users scan it quickly.
What it is: Checks that the target keyword appears in the body at a natural frequency -- present, but not stuffed.
Why it matters: Too little keyword usage weakens relevance signals; too much reads as keyword stuffing and risks a quality penalty.
What it is: Checks whether the content uses the broader vocabulary and related terms a topic would naturally include.
Why it matters: Modern search engines judge topical depth by vocabulary breadth, not just exact-keyword repetition -- thin vocabulary reads as thin coverage.
What it is: Checks whether subheadings reflect the range of subtopics the content actually covers.
Why it matters: Subheadings that map to real subtopics make content easier to scan and easier for search engines to match to specific queries.
What it is: Measures the page’s body word count against what’s typical for genuinely comprehensive coverage of its topic.
Why it matters: Very thin pages rarely have room to satisfy search intent fully and tend to underperform pages that cover a topic in depth.
What it is: Flags pages whose content is too sparse to meaningfully satisfy a searcher’s intent.
Why it matters: Thin content is one of the most common reasons pages fail to rank at all, regardless of other optimization.
What it is: Uses near-duplicate content fingerprinting to detect pages that are substantially the same as another page on the site.
Why it matters: Duplicate pages compete with each other for the same rankings instead of each earning its own visibility.
What it is: Scores the text’s readability using the Flesch Reading Ease formula.
Why it matters: Content that’s needlessly hard to read loses readers before they get to the point, hurting engagement signals search engines can observe.
What it is: Checks the ratio of active-voice to passive-voice sentences in the body content.
Why it matters: Active voice is generally more direct and readable, which supports both user engagement and clarity for AI systems parsing the content.
What it is: Checks average sentence length against readable norms.
Why it matters: Long, dense sentences are harder to skim and to parse into a clean answer, both for readers and for AI summarization.
What it is: Checks paragraph length against readable, scannable norms.
Why it matters: Wall-of-text paragraphs discourage reading on screens; shorter paragraphs improve scannability and time-on-page.
What it is: Checks usage of transition words and phrases that connect ideas between sentences.
Why it matters: Transitions make content flow logically, which readability scoring tools and real readers both reward.
What it is: Checks whether tabular data is marked up as real `<table>` elements where appropriate.
Why it matters: Real tables are more accessible and more likely to be lifted into rich results or AI answers than data described only in prose.
What it is: Checks usage of `<ul>`/`<ol>` list markup for list-like content.
Why it matters: Proper list markup is easier to scan, more accessible, and more extractable for featured snippets and AI answers than a comma-separated paragraph.
What it is: Checks whether the page includes a clear FAQ-style question-and-answer section.
Why it matters: FAQ sections directly match how people phrase search queries and are prime material for featured snippets and AI-generated answers.
What it is: Checks for a table of contents on longer content pages.
Why it matters: A TOC helps readers jump to what they need and can generate jump-link sitelinks in search results.
What it is: Checks that images have descriptive alt text rather than empty or missing attributes.
Why it matters: Alt text is essential for screen-reader accessibility and is the primary signal search engines use to understand and rank images.
What it is: Checks whether image filenames are descriptive rather than generic camera/CMS-generated strings.
Why it matters: A descriptive filename like `red-running-shoes.jpg` gives search engines context that `IMG_4021.jpg` never can.
What it is: Checks that `<img>` tags declare explicit width and height attributes.
Why it matters: Without declared dimensions, the browser can’t reserve space for the image, causing layout shift as it loads -- a direct Core Web Vitals hit.
What it is: Checks whether below-the-fold images use `loading="lazy"`.
Why it matters: Lazy loading defers offscreen images so the browser isn’t competing to download them before the visible content is ready.
What it is: Checks whether images use modern formats (WebP/AVIF) instead of only legacy JPEG/PNG.
Why it matters: Next-gen formats deliver the same visual quality at meaningfully smaller file sizes, speeding up page load.
What it is: Measures how many internal links point to this page from elsewhere on the site.
Why it matters: Pages with more internal inbound links are crawled more often and treated as more important by search engines.
What it is: Checks whether internal links use varied, descriptive anchor text rather than repeating the same generic phrase.
Why it matters: Descriptive anchor text tells both users and search engines what the linked page is about before they click.
What it is: Checks that internal links on this page resolve successfully rather than 404ing.
Why it matters: Broken internal links waste crawl budget, break the user journey, and leak the link equity that was meant to flow to the target.
What it is: Checks whether the page links out to relevant, reputable external sources.
Why it matters: Citing credible sources supports E-E-A-T and gives readers (and AI systems) a way to verify claims.
What it is: Checks that external links on the page resolve successfully rather than pointing to dead pages.
Why it matters: Dead outbound links look neglected and erode trust, even though they don’t directly affect crawl budget the way internal ones do.
What it is: Checks that a `Link: rel=canonical` header or tag is properly formed for this page.
Why it matters: A well-formed canonical is the clearest way to tell search engines exactly which URL should be indexed.
What it is: Checks that the canonical URL actually resolves and points to a real, accessible page.
Why it matters: A canonical pointing to a broken or redirecting URL gives search engines a dead end instead of a clear signal.
What it is: On-page check for a declared `lang` attribute on the document.
Why it matters: Declaring language helps search engines match the page to the right language’s search results and helps assistive technology pronounce it correctly.
What it is: Checks whether the page credits a visible author with identifiable expertise.
Why it matters: Google’s quality guidelines explicitly weigh author expertise as part of E-E-A-T, especially for YMYL (health/finance/legal) content.
What it is: Checks whether the page declares a clear publication date.
Why it matters: A visible date helps users and search engines judge whether the content is current, especially for time-sensitive topics.
What it is: Checks whether the page shows a last-updated/modified date, and how recent it is.
Why it matters: Freshness signals matter more for some queries than others, but a visibly stale update date can quietly undercut trust either way.
What it is: Checks for a visible breadcrumb trail in the page UI (independent of the BreadcrumbList schema check).
Why it matters: Breadcrumbs help users understand where they are in the site and provide an easy path back to parent categories.
What it is: Checks that the page includes at least some relevant structured data for its content type.
Why it matters: Structured data is the clearest way to hand search engines and AI systems an unambiguous description of the page’s content.
What it is: Checks that the homepage exposes a real navigation menu with crawlable links.
Why it matters: The homepage’s nav menu is usually the single biggest source of internal links pointing deeper into the site.
What it is: For utility/tool-type pages, checks that the actual interactive input fields are present in the markup.
Why it matters: A tool page with no detectable inputs may be rendering its functional UI in a way crawlers -- and some users -- can’t see.
What it is: For blog/article pages, checks for a table of contents aiding navigation through longer posts.
Why it matters: Long-form posts benefit disproportionately from a TOC, both for reader navigation and for search engines’ jump-link sitelinks.
Open Graph and Twitter Card markup controlling how links preview when shared.
What it is: Checks for Open Graph tags (og:title, og:description, og:image, etc.) controlling how the page previews when shared.
Why it matters: Without Open Graph tags, social platforms fall back to guessing a title/image, often producing an ugly or irrelevant preview.
What it is: Checks for Twitter/X Card meta tags controlling the link preview format on that platform.
Why it matters: X renders link previews from its own Card tags, not Open Graph alone, so this needs separate coverage.
What it is: Checks for general social-sharing affordances (share buttons, complete social metadata) on the page.
Why it matters: Easy sharing paired with a strong preview increases the odds content actually gets shared once someone wants to.
What it is: Samples multiple crawled pages to check how consistently Open Graph tags are implemented across the whole site.
Why it matters: A site that gets OG tags right on the homepage but misses them elsewhere still produces broken previews on most shared links.
What it is: Samples multiple crawled pages to check how consistently Twitter Card tags are implemented across the whole site.
Why it matters: Consistent Card coverage matters more than a single well-optimized page if most of the site’s content gets shared on X.
Experience, Expertise, Authoritativeness, and Trust signals search engines weigh for quality raters and ranking.
What it is: Checks for the presence of foundational trust pages sitewide -- About, Contact, Privacy Policy, and similar.
Why it matters: These pages are a baseline trust signal Google’s quality raters explicitly look for, especially for sites making claims that affect a reader’s money or wellbeing.
What it is: Checks whether this specific page visibly credits an author.
Why it matters: Attributed content signals accountability and expertise, both core components of E-E-A-T.
What it is: Checks whether this specific page visibly shows a publication date.
Why it matters: A visible date lets readers judge whether advice or claims on the page are still current.
How pages connect to each other -- the paths crawlers and visitors use to discover content.
What it is: Flags pages the crawl reached (e.g. via sitemap) but that no other crawled page links to internally.
Why it matters: A page with zero internal links pointing to it is hard for both crawlers and users to discover, no matter how good the content is.
What it is: Flags pages that receive very few internal links relative to the rest of the site.
Why it matters: Thin internal linking starves a page of both crawl attention and the topical context that links between related pages provide.
What it is: Lists internal links discovered during the crawl that point to pages returning an error status.
Why it matters: Broken internal links interrupt the user journey and burn crawl budget on dead ends instead of real content.
What it is: Checks whether internal link anchor text is descriptive and varied rather than repeated generic phrases like "click here."
Why it matters: Generic anchor text ("click here", "read more") tells search engines nothing about what the linked page covers.
What it is: Counts how many internal pages the homepage links to.
Why it matters: The homepage usually holds the most authority on a site; how widely it distributes internal links shapes how that authority spreads.
What it is: Checks the links found specifically on this page for ones that resolve to an error.
Why it matters: A page with several broken links reflects poorly on content freshness and directly interrupts navigation for anyone who clicks one.
Structured data (JSON-LD) that lets search engines and AI systems parse a page’s meaning directly.
What it is: Detects JSON-LD structured data blocks that fail to parse as valid JSON.
Why it matters: A single syntax error can invalidate an entire schema block, silently forfeiting whatever rich-result eligibility it was meant to unlock.
What it is: Lists which schema.org types (Article, Product, FAQPage, etc.) were found in the page’s structured data.
Why it matters: Knowing exactly what schema is already present makes it easy to spot what’s missing for this content type.
What it is: Suggests specific schema types this page is likely missing, based on its detected content type.
Why it matters: Adding the right schema type is often the single fastest way to become eligible for a new rich-result feature.
Content depth, readability, and structural signals search engines use to judge topical authority.
What it is: Scores overall content comprehensiveness into a thin/moderate/optimal tier based on depth of coverage.
Why it matters: Search engines increasingly reward pages that cover a topic comprehensively over pages that touch it only briefly.
What it is: Evaluates whether sentence complexity is holding back the content’s overall readability.
Why it matters: Content that’s unnecessarily hard to parse loses both human readers and the AI systems trying to summarize it accurately.
What it is: Evaluates whether the page’s subheadings form a clear, logical hierarchy of topics and subtopics.
Why it matters: A clear hierarchy helps search engines segment the page into topically distinct, individually rankable sections.
What it is: Checks whether list-like or tabular information is actually marked up as lists/tables rather than left as plain prose.
Why it matters: Structured formatting is both easier to scan for humans and easier to extract cleanly for featured snippets and AI answers.
What it is: Scores how completely the page’s body content actually covers its stated target keyword phrase.
Why it matters: A page optimized in the title and headings but missing the keyword from the body sends a weaker, inconsistent relevance signal.
What it is: Checks whether the URL structure groups related content into topical directories (a "silo") rather than a flat structure.
Why it matters: Siloed URL structures reinforce topical relationships for search engines and make site sections easier for users to navigate.
What it is: Aggregates semantic structural quality (headings, content depth, formatting) across the crawled site.
Why it matters: A sitewide view catches structural problems -- like most pages lacking proper headings -- that per-page checks alone can miss.
What it is: Flags pages that appear to render most of their content via client-side JavaScript rather than server-delivered HTML.
Why it matters: The crawler -- like many real crawlers -- can’t execute JavaScript, so heavily CSR pages risk being seen as near-empty by search engines that don’t render them either.
What it is: Checks whether this individual page sits within a logical category path rather than a flat, unstructured URL.
Why it matters: A page’s URL path is itself a signal of where it fits in the site’s topical hierarchy.
What it is: Checks use of semantic HTML5 elements (`<article>`, `<nav>`, `<main>`, `<aside>`, etc.) instead of generic `<div>` soup.
Why it matters: Semantic tags give both browsers and search engines a built-in outline of the page’s structure without extra markup.
Answer Engine and Generative Engine Optimization -- structuring content so AI assistants and answer engines can extract and cite it.
What it is: Checks for FAQPage structured data marking up question-and-answer content.
Why it matters: FAQ schema is one of the most direct ways to feed exact question/answer pairs to AI answer engines and traditional rich results alike.
What it is: Checks for Article/NewsArticle/BlogPosting structured data.
Why it matters: Article schema gives search and AI systems clean metadata -- headline, author, date -- for editorial content.
What it is: Checks for Organization structured data describing the publishing entity.
Why it matters: Organization schema helps establish who is actually behind the content, feeding both knowledge panels and AI trust assessments.
What it is: Checks for structured data explicitly identifying the content’s author.
Why it matters: Machine-readable authorship is a concrete E-E-A-T signal AI systems can parse without having to infer it from prose.
What it is: Checks for Person structured data describing an individual referenced on the page.
Why it matters: Person schema disambiguates named individuals for search and AI systems, useful for author bios, team pages, and expert quotes.
What it is: Checks for BreadcrumbList structured data (the AEO-focused counterpart of the technical breadcrumb check).
Why it matters: Breadcrumb schema gives AI systems a clean signal of how this page fits into the site’s broader topic hierarchy.
What it is: Checks for base WebPage structured data describing the page itself.
Why it matters: WebPage schema is a foundational entity that other, more specific schema types (Article, Product, etc.) build on top of.
What it is: Checks for HowTo structured data on step-by-step instructional content.
Why it matters: HowTo schema lets AI systems and rich results present your steps directly, which is exactly the format many how-to queries want.
What it is: Checks for Product structured data, where the page is describing a purchasable item.
Why it matters: Product schema feeds price, availability, and rating data directly into shopping-oriented search and AI experiences.
What it is: Checks for Review or AggregateRating structured data.
Why it matters: Review schema is what makes star ratings appear directly in search results and is heavily weighed in AI purchase-recommendation answers.
What it is: Checks for Speakable structured data marking sections suited for text-to-speech readout.
Why it matters: Speakable schema helps voice assistants identify exactly which part of the page is safe and appropriate to read aloud.
What it is: Checks whether the content references clear, named entities (people, places, organizations, products) rather than vague generalities.
Why it matters: AI systems reason in terms of entities and their relationships; content with weak entity presence is harder for them to place and cite.
What it is: Checks that entities are referred to consistently by name throughout the page rather than inconsistently across sections.
Why it matters: Consistent naming helps AI systems confidently link every mention back to the same real-world entity.
What it is: Evaluates whether the page addresses the full range of subtopics a comprehensive answer on this subject would cover.
Why it matters: AI answer engines favor sources that cover a topic completely enough to be cited as a single authoritative answer.
What it is: Checks how many headings are phrased as actual questions rather than statements.
Why it matters: Question-phrased headings map directly to how people phrase queries to search engines and AI assistants alike.
What it is: Checks whether questions posed in headings are followed immediately by a direct, extractable answer.
Why it matters: AI answer engines and featured snippets both favor a concise direct answer immediately after the question, not one buried paragraphs later.
What it is: Checks for clear, isolated definitions of key terms ("X is...") the content introduces.
Why it matters: A clean definition block is exactly the shape of content AI systems most reliably extract for "what is X" queries.
What it is: Checks for clearly sequenced, numbered instructional steps.
Why it matters: Sequential steps are easy for AI systems to extract and present as a structured how-to answer.
What it is: Checks for tables comparing multiple options, products, or approaches.
Why it matters: Comparison content is exactly what AI shopping and decision-support answers are built to extract and summarize.
What it is: Checks for an explicit pros-and-cons breakdown.
Why it matters: A clear pros/cons list is a compact, highly extractable format for AI systems answering comparison or decision questions.
What it is: Checks whether the content includes concrete statistics and factual data points, not just general claims.
Why it matters: Specific, citable numbers are more likely to be pulled into AI-generated answers than vague qualitative statements.
What it is: Checks for clear, self-contained statements an AI system could quote and attribute directly.
Why it matters: Content written in citable, standalone statements is easier for generative engines to lift and credit as a source.
What it is: Checks for visible links to About, Contact, and policy pages establishing who is behind the content.
Why it matters: AI systems weigh publisher trustworthiness when deciding which sources to cite, and these pages are a baseline signal of a real organization.
What it is: Checks whether the author’s credentials or relevant expertise are visibly stated, not just their name.
Why it matters: Demonstrated expertise (not just attribution) is what actually strengthens an E-E-A-T and AEO trust signal.
What it is: Evaluates whether the content reflects current information rather than stale or outdated facts.
Why it matters: AI systems and search engines both discount content that reads as out of date on fast-moving topics.
What it is: Checks for a visible last-updated date distinct from the original publish date.
Why it matters: An update timestamp signals the content is actively maintained, which matters more for AI trust scoring than a publish date alone.
What it is: Checks whether claims are backed by cited sources or references.
Why it matters: Cited sources let AI systems verify claims and are a direct component of how they assess content credibility.
What it is: Checks for signs of original analysis, data, or perspective rather than content that only restates common knowledge.
Why it matters: AI systems and search engines increasingly favor sources offering something genuinely new over rehashed summaries.
What it is: Checks for original visual assets (custom charts, screenshots, diagrams) rather than only stock imagery.
Why it matters: Original visuals are both harder to find elsewhere and a concrete signal of first-hand effort behind the content.
What it is: Evaluates overall organization -- logical flow from introduction through to conclusion.
Why it matters: A clearly organized page is easier for both readers and AI extraction systems to follow and summarize accurately.
What it is: Checks for concise, self-contained answer snippets in the ideal length range for featured snippets and voice answers.
Why it matters: This word count matches the typical length search engines and assistants read aloud or display as a direct answer.
What it is: Checks how tightly this page’s content relates to the broader topic cluster it belongs to on the site.
Why it matters: Content that stays tightly on-topic within a cluster reinforces the site’s overall topical authority for AI and search alike.
What it is: Aggregates the presence of Experience, Expertise, Authoritativeness, and Trust signals across the page.
Why it matters: E-E-A-T is explicitly part of Google’s quality rater guidelines and increasingly factors into how AI systems select sources to trust.
What it is: Checks whether the brand or organization is clearly named on the page itself.
Why it matters: AI systems attribute claims to a source; a page that never names the brand behind it is harder to credit or trust.
What it is: Checks whether the page clearly states what makes its offering or perspective distinct.
Why it matters: A clear value proposition helps both users and AI systems understand why this source, specifically, is worth citing or choosing.
What it is: Checks whether content is broken into clearly delimited, self-contained chunks rather than one continuous block.
Why it matters: AI systems retrieve and cite content in chunks; well-chunked content is more likely to be extracted cleanly and accurately.
What it is: Checks that tabular data uses real, properly structured `<table>` markup an AI system can parse programmatically.
Why it matters: A table rendered as styled `<div>`s or an image can’t be reliably parsed by AI systems the way a real HTML table can.
What it is: Checks that the writing reads naturally rather than as mechanically keyword-optimized text.
Why it matters: Both search quality systems and AI models are tuned to recognize and discount unnatural, keyword-stuffed writing.
What it is: Checks whether technical or specialized terms are briefly explained when first introduced.
Why it matters: Unexplained jargon makes content harder for a general audience -- and for AI systems generating answers for non-experts -- to use confidently.
What it is: Checks whether the page leads with a direct answer before diving into supporting detail.
Why it matters: Answer-first structure matches how AI systems prefer to extract a concise response before optionally including context.
What it is: Checks whether the page addresses the different intents a searcher on this topic might have (informational, comparative, transactional).
Why it matters: A single query can trigger different underlying intents; covering more of them widens the range of questions the page can answer.
What it is: Checks whether the content makes the relationships between named entities explicit rather than implied.
Why it matters: Explicit relationships ("X, the founder of Y") are far easier for AI knowledge extraction than context the reader has to infer.
What it is: Checks that the same concept is referred to with consistent terminology throughout, rather than switching synonyms.
Why it matters: Inconsistent terminology can make AI systems treat the same concept as multiple different things.
What it is: Checks whether existing structured data blocks are filled out completely rather than missing common optional fields.
Why it matters: A sparse schema block is valid but under-informative; filling recommended fields gives AI and search systems more to work with.
What it is: Checks overall formatting -- headings, chunking, structure -- for how easily a language model could parse the page.
Why it matters: Content that’s naturally easy for an LLM to parse is more likely to be retrieved, summarized, and cited accurately.
What it is: Evaluates how easily a reader (or an extraction system) can scan the page and locate specific information quickly.
Why it matters: Scannable content, with clear headings and formatting, serves both time-pressed human readers and automated extraction equally well.
What it is: Checks whether robots.txt explicitly allows or blocks known AI crawlers (GPTBot, Google-Extended, and similar).
Why it matters: If AI crawlers are blocked, the site can’t appear in AI-generated answers at all, regardless of how well-optimized the content is.
What it is: Checks for an llms.txt file at the domain root -- an emerging convention giving AI agents a concise, curated guide to the site.
Why it matters: llms.txt is a direct, purpose-built channel for telling AI agents what your site is and which pages matter most, ahead of them inferring it from a crawl.