Issue Rules Reference

Every crawled page is evaluated against 17 issue rules organized into eight groups. Each rule carries a severity level and produces a finding when its condition is met. The same rule set runs across the desktop app, CLI, cloud tier, and API, so a page flagged in one surface is flagged in all of them.

Severity levels

Each rule is assigned one of three severity levels. Severity is fixed per rule, not configurable per crawl.

Severity	Meaning
Critical	Blocks indexing or breaks the page. These findings require immediate attention: a server error prevents the page from being served, and a missing title prevents search engines from generating a meaningful snippet.
Warning	Harms SEO or user experience. The page works, but something about it is likely to reduce its visibility or usability: a title that truncates in search results, thin content, or a slow response.
Notice	Informational, and may be intentional. A redirect is not necessarily wrong; a page canonicalised elsewhere may be deliberate. Notices surface facts worth knowing, not problems that must be fixed.

Response codes

Response code rules fire based on the HTTP status code returned by the server. They run before any content analysis, since a non-200 response changes what the remaining rules can meaningfully evaluate.

Rule key	Name	Severity	Condition
`status_5xx`	Server error (5xx)	Critical	`status_code >= 500`
`status_4xx`	Client error (4xx)	Critical	`status_code >= 400` and `< 500`
`status_3xx`	Redirect (3xx)	Notice	`status_code >= 300` and `< 400`

Page titles

Title rules inspect the contents of the <title> element. A missing title prevents search engines from generating a meaningful snippet, while an overly long title will be truncated in search results.

Rule key	Name	Severity	Condition
`title_missing`	Missing	Critical	Title is empty or absent
`title_too_long`	Over 60 characters	Warning	`title_length > 60`
`title_too_short`	Below 30 characters	Notice	Title present and `title_length < 30`

Meta description

Meta description rules inspect the <meta name="description"> tag. Search engines may use this value as the page snippet, and its absence means the engine must extract one from the page body, which may not represent the page well.

Rule key	Name	Severity	Condition
`description_missing`	Missing	Critical	Meta description is empty or absent
`description_too_long`	Over 155 characters	Warning	`meta_description_length > 155`
`description_too_short`	Below 70 characters	Notice	Meta description present and `meta_description_length < 70`

H1

H1 rules check how many <h1> elements appear on the page. A page without an H1 is missing its primary heading signal, and a page with more than one dilutes it.

Rule key	Name	Severity	Condition
`h1_missing`	Missing	Critical	No H1 elements on the page
`h1_multiple`	Multiple	Warning	More than one H1 element

Canonicals

Canonical rules inspect the <link rel="canonical"> tag. A missing canonical leaves search engines to decide which URL is authoritative, while a canonical pointing elsewhere signals that this page is a duplicate of the target.

Rule key	Name	Severity	Condition
`canonical_missing`	Missing	Warning	No canonical tag present
`canonical_non_self`	Canonicalised elsewhere	Notice	Canonical present but differs from the page URL

Content

Content rules evaluate the body text of pages that returned a successful response. A low word count is often a sign that a page lacks enough substance to rank, though some page types (login, contact) are naturally short.

Rule key	Name	Severity	Condition
`content_thin`	Low word count (under 200)	Warning	`word_count < 200` and `status_code < 300`

Performance

Performance rules flag pages that are slow to respond or unusually large. Both affect user experience and can influence crawl budget allocation by search engines.

Rule key	Name	Severity	Condition
`slow_response`	Slow response (over 2s)	Warning	`response_time_ms > 2000`
`large_page`	Over 1 MB	Notice	`size_bytes > 1,048,576`

Architecture

Architecture rules evaluate how a page sits within the overall site structure. Depth is measured as the minimum number of clicks from the start URL required to reach the page during the crawl.

Rule key	Name	Severity	Condition
`deep_page`	Deep (4+ clicks from home)	Notice	`depth > 3`

Session-level checks

Three checks operate on the full set of crawled pages rather than on individual pages. They are computed after the crawl completes and do not use the per-page rule keys listed above.

Check	What it detects
Duplicate titles	Two or more pages sharing the same `<title>` text. Each group of duplicates is reported together so you can see which pages collide.
Duplicate descriptions	Two or more pages sharing the same meta description. Like duplicate titles, each group is reported as a set.
Duplicate content	Pages whose body content is substantially similar based on content hashing. This catches near-duplicates that differ only in boilerplate, navigation, or minor wording.

Because these checks compare pages to each other, they require the full crawl to finish before results are available. In the desktop app and cloud tier they appear once the crawl completes; in the CLI and API they are included in the final output.

The rule keys (status_5xx, title_missing, and so on) are the stable identifiers used in the API, CLI JSON output, and webhook payloads. They do not change between versions, so any integration that filters or routes findings by key will continue to work across upgrades.