SEO Glossary Terms

TypeIssueDescription
Accessibilityid attribute value must be uniqueThe value assigned to the id=”” attribute must be unique to prevent the second instance from being overlooked by assistive technology. Put another way, id attributes may not be used more than once in the same document in order to differentiate each element from another.
AccessibilityLinks must have discernible textLink text (and alternate text for images, when used as links) must be discernible by a screen reader, must not have a duplicate label, and must be focusable.
AccessibilityZooming and scaling must not be disabledThe document must not use the user-scalable=no parameter in the <meta name=”viewport”> element because it disables text scaling and zooming which is essential to users with low vision.
AccessibilityElements must have sufficient color contrastAll text elements must have sufficient contrast between text in the foreground and background colors behind it in accordance with WCAG 2 AA contrast ratio thresholds.
AccessibilityElements should not have tabindex greater than zeroA tabindex attribute must never have a value greater than 0 to prevent an unexpected tab order that can give the appearance of skipping some elements entirely.
AccessibilityForm elements must have labelsEach form element must have a programmatically associated label element.
AccessibilityEnsure buttons have discernible textButtons must have discernible text that clearly describes the destination, purpose, function, or action for screen reader users.
AccessibilityDocuments must have <title> element to aid in navigationThe HTML document must have a <title> element to provide users with an overview of its content, and when present, it must not be empty
AccessibilityEnsure that lists are structured correctlyLists must be marked up correctly, meaning they must not contain content elements other than <li> elements.
AccessibilityImages must have alternate textAll images must have alternate text to convey their purpose and meaning to screen reader users.
AccessibilityData or header cells should not be used to give caption to a data tableData table markup can be tedious and confusing. Screen readers have a number of features to make table navigation easier, but tables must be marked up accurately for these features to work properly. Some tables use cells with a colspan to visually indicate a caption, instead of using an actual caption element.
Accessibility<audio> elements must have a captions trackFor each HTML 5 <audio> element, the <track> element must be present, with kind=”captions” set as a property. Captions are text—synchronized with the audio file—of the dialog, narration, and any important auditory information, for the benefit of deaf users.
AccessibilityEnsure <dl> elements are structured correctlyDefinition lists (<dl>) must contain only properly-ordered <dt> and <dd> groups, <script> or <template> elements.
Accessibility<dt> and <dd> elements must be contained by a <dl>Definition list items (<dt> and/or <dd>) must be wrapped in parent <dl> elements to be valid. This enables screen reader users to understand the proper hierarchy of information in the list.
Accessibility<html> element must have a lang attributeThe HTML document must contain a valid lang attribute or must correspond to a valid lang code for multilingual screen reader users who may prefer a language other than the default.
Accessibility<html> element must have a valid value for the lang attributeThe HTML document must contain a valid lang attribute or must correspond to a valid lang code for multilingual screen reader users who may prefer a language other than the default.
AccessibilityEnsures <li> elements are used semanticallyAll list items (<li>) must be contained within <ul> or <ol> parent elements.
AccessibilityEnsure <marquee> elements are not used<marquee> elements must not be present because they are deprecated, increase difficulty for users with limited dexterity, and are distracting for users with cognitive or attention deficits.
Accessibility<object> elements must have alternate textAll embedded objects must have text alternatives to be read out to screen reader users.
Accessibility<video> elements must have captionsAn HTML5 <video> element must include a <track> element with kind=”captions” set as a property. The captions should convey all meaningful auditory information in the video including dialogue, musical cues, sound effects, and other relevant information for deaf users.
Accessibility<video> elements must have an audio description trackThe HTML 5 <video&gt element must have an audio description track to provide blind users with information the dialogue does not.
Accessibilityaria-hidden=”true” must not be present on the document bodyWhen an aria-hidden attribute with a value of ‘true’ is present in the body of the document, the content won’t be accessible to assistive technology.
Accessibilityaccesskey attribute value must be uniqueAll accesskeys in the document must be unique. Put another way, accesskeys must not be repeated to prevent unexpected effects for keyboard users.
AccessibilityTable headers in a data table must refer to data cellsData table markup can be tedious and confusing. It is important that it is done semantically and with the correct header structure. Screen readers have a number of features to make table navigation easier, but tables must be marked up accurately for these features to work properly.
AccessibilityEnsure that each table header in a data table refers to data cellsData table markup can be tedious and confusing. It is important that it is done semantically and with the correct header structure. Screen readers have a number of features to make table navigation easier, but tables must be marked up accurately for these features to work properly.
AccessibilityEnsure that each non-empty data cell in a large table has one or more table headersData table markup can be tedious and confusing. It is important that it is done semantically and with the correct header structure. Screen readers have a number of features to make table navigation easier, but tables must be marked up accurately for these features to work properly.
AccessibilityARIA attributes must conform to valid namesARIA attributes (i.e. starting with aria-) must have valid names. Referring to a misspelled attribute or to one that does not exist will result in an invalid attribute and thus failure of this Rule.
AccessibilityARIA attributes must conform to valid valuesARIA attributes (i.e. starting with aria-) must contain valid values. These values must be spelled correctly and correspond to values that make sense for a particular attribute in order to perform the intended accessibility function.
AccessibilityARIA roles used must conform to valid valuesValues assigned to ARIA roles (role=””) must be valid. This means values must be spelled correctly, must correspond to existing ARIA role values, and must not be abstract roles in order to correctly expose the purpose of the element.
AccessibilityCertain ARIA roles must be contained by particular parentsCertain ARIA roles must be contained by particular parent roles in order to perform the intended accessibility functions.
AccessibilityCertain ARIA roles must contain particular childrenThere are some ARIA parent roles that must contain specific child roles to perform their intended accessibility function.
AccessibilityElements must only use allowed ARIA attributesNot all ARIA role-attribute combinations are valid. This Rule checks that each role is supplied with allowed attributes.
AccessibilityImage buttons must have alternate textWhen an image is being used as an <input> button, it must have alternate text to allow screen reader users to know its purpose.
Accessibilitylang attribute must have a valid valueThe language specified in the HTML document must be one of the valid languages to ensure text is pronounced correctly for screen reader users.
AccessibilityLayout tables must not use data table elementsIf a table is being used for layout purposes only, it must not use data table elements such as a header, caption, and summary to prevent confusion by screen reader users who would otherwise expect data to be contained within the cells.
AccessibilityPage must have means to bypass repeated blocksEach page must have a <main> landmark to provide a mechanism to bypass repeated blocks of content or interface elements (like header and navigation) and quickly arrive at the main content.
AccessibilityRequired ARIA attributes must be providedARIA widget roles must have appropriate attributes describing the state or properties of the widget.
AccessibilityThe page should have a skip link as its first linkThe page must have a link at the top (before the navigation) that allows users to skip lengthy navigation and proceed to a page’s main content to save time.
AccessibilityTimed refresh must not exist“The document must not use <meta http-equiv=”refresh”> because it can prevent control over when the refresh occurs for users with disabilities.”
CanonicalCanonical points to a different internal URLURLs that specify a canonical URL which is not self-referential, and instead points to another internal URL. This Hint is flagged as Advisory as it could be the case that nothing is actually wrong here – canonicals are used as a valid means of avoiding duplicate content issues – so you may simply wish to check that the canonicals are pointing at the ‘right’ URLs.
CanonicalNext/Prev Paginated URL is canonicalized to different URLURLs that are canonicalized (i.e the canonical URL points to another URL), where the URL also has next/prev pagination elements. This is typically seen where rel=canonical points to the first page of a paginated series. Using rel=canonical in this manner can result in content on paginated pages not being indexed at all.
CanonicalCanonical points to a redirecting URLURLs that specify a canonical URL which returned Redirect (3XX) when crawled by Sitebulb. This indicates to search engines that the canonical information is inaccurate, and as such, the canonical instruction may be ignored.
CanonicalCanonical is a relative URLURLs that specify a canonical URL using a relative URL. Search engines do not recommend using relative URLs for canonicals as they can lead to future issues (even if there are no issues currently).
CanonicalCanonical is malformed or emptyURLs that specify a canonical URL which is invalid or undefined. If canonical URLs are undefined (e.g. <link rel=”canonical” href=””>) or invalid (e.g. <link rel=”canonical” href=”http//example.com/”>) this indicates a configuration issue and should be addressed.
CanonicalCanonical loopURLs that specify a canonical URL, where the canonical URL also specifies a canonical, which in turn points back to the original URL. This causes a canonical loop (e.g. URL1 -> URL2 -> URL1) and could cause search engines to completely ignore all canonical instructions.
CanonicalCanonical outside of headURLs that have a canonical link element in the HTML which has been placed outside the <head>. Search engines will ignore canonical designations that do not appear in the <head>, so this issue could cause indexing problems.
CanonicalCanonical points to a disallowed URLURLs that specify a canonical URL which is disallowed by robots.txt. Search engines will be unable to crawl the disallowed URL, so the canonical instruction will likely be ignored.
CanonicalNoindex found on rel Next/Prev Paginated URLURLs that are noindex where the URL also has next/prev pagination elements. This Hint is flagged as Advisory as it could be the case that nothing is actually wrong here – noindex and rel=’next’/’prev’ are entirely independent annotations – so you may simply wish to check that this deliberate and working as expected.
CanonicalCanonical points to a noindex nofollow URLURLs that specify a canonical URL which is noindex nofollow. This constitutes conflicting messages to search engines, and as such the canonical instruction will likely be ignored.
CanonicalCanonical points to a noindex URLURLs that specify a canonical URL which is noindex. This constitutes conflicting messages to search engines, and as such the canonical instruction will likely be ignored.
CanonicalCanonical points to a URL that is Error (5XX)URLs that specify a canonical URL which returned Error (5XX) when crawled by Sitebulb. This can indicate to search engines that the canonical information is inaccurate, and as such, the canonical instruction may be ignored. Server errors can be transient, so it is worth double checking the error URLs to verify there is an issue.
CanonicalCanonical points to a URL that is Not Found 404URLs that specify a canonical URL which returned Not Found (4XX) when crawled by Sitebulb. This indicates that the canonical URL has either been removed or misconfigured, and as such, the canonical instruction is likely to be ignored by search engines.
CanonicalCanonical points to another canonicalized URLURLs that specify a canonical URL, where the canonical URL also specifies a (different) canonical URL. This causes a canonical chain (e.g. URL1 -> URL2 -> URL3) and could cause search engines to completely ignore all canonical instructions.
CanonicalCanonical points to external URLURLs that specify a canonical URL which is on a different domain or subdomain. This Hint is flagged as Advisory as it could be the case that nothing is actually wrong here – cross-domain canonicals are used as a valid means of avoiding duplicate content issues – so you may simply wish to check that the canonicals are pointing at the ‘right’ URLs.
CanonicalCanonical points to HTTP versionHTTPS URLs that specify a canonical URL which is the HTTP version of the same URL (i.e. mismatched protocol). This could lead to search engines indexing the ‘wrong’ version of the URL, or ignoring the canonical instruction entirely.
CanonicalCanonical points to HTTPS versionHTTP URLs that specify a canonical URL which is the HTTPS version of the same URL (i.e. mismatched protocol). This could lead to search engines indexing the ‘wrong’ version of the URL, or ignoring the canonical instruction entirely.
CanonicalCanonical tag in HTML and HTTP headerURLs that have a canonical URL defined both in the HTML and in the HTTP header. This Hint is flagged as Advisory as it is not ‘wrong’ per se, but could lead to future complications if changes are made to one canonical element but not both. As such, we recommend only using one method of declaring canonical URLs.
CanonicalMismatched canonical tag in HTML and HTTP headerURLs that have a canonical URL defined both in the HTML and in the HTTP header, which are specifying different canonical URLs. This constitutes conflicting messages to search engines, and as such the canonical instruction will likely be ignored.
CanonicalMultiple canonical tagsURLs that specify a canonical URL more than once, either in the HTML, in the HTTP header, or in both. This Hint is flagged as Advisory as it may not be ‘wrong’ per se, but could lead to future complications if changes are made to one canonical element but not the other. As such, we recommend that canonicals are only declared once on any given URL, using a single method (HTML or HTTP header).
CanonicalMultiple, mismatched canonical tagsURLs that specify a canonical URL more than once, either in the HTML, in the HTTP header, or in both, where the canonical URLs do not match. This constitutes conflicting messages to search engines, and as such the canonical instruction will likely be ignored. In this circumstance, we recommend selecting the correct canonical URL, and ensuring that canonical URLs are declared only once on any given URL, using a single method (HTML or HTTP header).
CanonicalCanonical URL has no incoming internal linksURLs that are declared as the canonical URL (on another URL), but which have no incoming anchor links from internal URLs (i.e. the only links they have are from the canonical link element). This means that a canonical URL is not part of the overall site architecture. This is an unusual situation, as any URL which is deemed important enough to act as a canonical should also be part of the overall site architecture.
CanonicalPaginated URL missing next/prev canonicalsURLs that contain pagination HTML elements, but do not include next/prev canonicals in the HTML or in HTTP Headers. This Hint is flagged as Advisory as it not technically necessary to use next/prev elements, however it is recommended by search engines and considered best practice.
CanonicalCanonical only found in rendered DOMURLs that contain a canonical link element on the rendered version of the page, but do not contain one in the HTML source. Google have stated categorically that the rendered canonical is not taken into account, so relying on it for indexing purposes is not recommended.
Duplicate ContentURLs with duplicate h1sURLs that have the exact same header 1 (h1) tag as at least one other indexable URL. If multiple pages have the same h1, this can make it difficult for search engines to differentiate the ‘best’ page for a given search query, which can result in keyword cannibalization (multiple pages on your own site competing for the same search terms, and hurting each others’ rankings).
Duplicate ContentURLs with duplicate contentURLs that have identical HTML content to at least one other indexable URL. If this sort of duplication occurs, you have a relatively serious issue, whereby URLs with identical content are accessible to search engine crawlers. If this results in large scale duplicate content issues on the site, you could trip quality algorithms like Google’s Panda, which can depress organic search traffic to the site as a whole.
Duplicate ContentURLs with duplicate page titlesURLs that have the exact same page title as at least one other indexable URL. If multiple pages have the same title, this can make it difficult for search engines to differentiate the ‘best’ page for a given search query, which can result in keyword cannibalization (multiple pages on your own site competing for the same search terms, and hurting each others’ rankings).
Duplicate ContentURLs with duplicate meta descriptionsURLs that have the exact same meta description as at least one other indexable URL. If lots of meta descriptions are duplicate, this represents a missed optimization opportunity. It may make it difficult for users to differentiate similar pages in search results, and may result in search engines simply re-writing the descriptions for you (sometimes with disastrous results).
Duplicate ContentURLs with duplicate title and meta descriptionsURLs that have the exact same page title and meta description as at least one other indexable URL. If multiple pages have the same title, this can make it difficult for search engines to differentiate the ‘best’ page for a given search query, which can result in keyword cannibalization. If a page has both a duplicate title AND a duplicate meta description, this may indicate a more systemic issue at play (than simply a copy/paste human error).
Duplicate ContentDuplicate URLs (technical duplicates)URLs that are technically identical to at least one other indexable URL. This could be URLs that are only different based on case, or have the same query string parameters and values (but in a different order). If this sort of duplication occurs, you have a relatively serious issue, whereby identical URLs are being generated and are accessible to search engine crawlers.
External URLsBroken external URL (4XX or 5XX)URLs on a subdomain or external domain, which are linked to by internal URLs, that weren’t successfully audited. This includes crawl statuses of Not Found, Error, Forbidden and Timeout.
Front-endDocument Compatibility Mode Meta Position InvalidURLs where document compatibility mode meta tag position is set too low in the <head>. The meta tag should be included before the <title> and the other <meta> tags to ensure Internet Explorer is instructed what mode to use as early as possible.
Front-endLogs messages in the browser’s consoleHTML URLs that contain browser console log messages. Console messages are good for debugging during development and should be removed when in the live environment. Writing to the console can be costly, especially when logging large object variables. The console object was introduced into Internet Explorer 10. All previous versions will error if the console object is called and fail to continue executing JavaScript, which could cause the HTML not to be rendered correctly.
Front-endContains duplicate element id valuesHTML URLs that contain DOM elements with duplicate id attribute values. This can cause issues if the JavaScript is parsing or calling DOM elements based on these id values. Another issue is it can confuse Screen readers, as they use id values to expose a relationship between page elements.
Front-endContains an attribute with an unsafe characterHTML URLs that have one or more DOM elements, which uses an unsafe character, such as &, “, > and <. Such characters are considered unsafe because they make the page vulnerable to a cross-site-scripting attack (or accidentally breaking the page with innocent input).
Front-endContains an uppercase attributeHTML URLs that have one or more DOM element attributes with uppercase letters in its name. Whilst fixing this issue will not make noticeable performance gains, it is considered a best practice recommendation. Having clean, standardised code makes it easier for other developers to work on, and makes the code easier for search engine crawlers and browsers to parse.
Front-endDocument Compatibility Mode Not SetURLs that do not have the document compatibility mode set. Internet Explorer 8/9/10/11 support document compatibility modes. Setting it, allows you to control what rendering engine is used, rather Internet Explorer deciding for itself. For example, without this setting, it is possible for Internet Explorer 9 to use the Internet Explorer 6 rendering engine.
Front-endDocument Compatibility Mode In <head> And Headers DifferURLs that have the document compatibility mode is set in the <head> and the HTTP headers, and their values are different. This could lead to the incorrect mode being used, because the <head> value will be ignored as the HTTP Header takes priority.
Front-endCSS content has errorsStyle Sheets that contain one or more syntax errors, which could cause the CSS rules to incorrectly parsed or ignored.
Front-endCSS content empty rulesStyle Sheets that contain one or more empty rules. Empty rules add unnecessary bytes to the file size and although minimal, increase browser resources for rendering.
Front-endCSS content contains unknown CSS propertiesStyle Sheets that contains one or more unknown CSS properties, which will be ignored by browsers. These properties add unnecessary bytes to the file size and although minimal, increase browser resources for rendering.
Front-endCSS content contains duplicate CSS propertiesStyle Sheets that contain one or more duplicate CSS properties. These duplicate properties could be a coding error, or be in place to deal with browser support. For example, some browsers support RGBA color while others do not, so it’s quite common to include both options.
Front-endCSS contains @importStyle Sheets that contain one or more @import at-rule, which stops of parallel downloads and increase the page render time. When the browser parses finds a @import rule, it stops and starts to download the specified file. The browser will not continue downloading any other style sheets until this @import file has finished.
Front-endCSS contains universal selectorStyle Sheets that contain one or more universal selectors. The universal selector (*) is convenient for selecting a group of elements, but should be avoided as causes performance issues when used as the key part (far-right) of a selector. The more complex the selector containing *, the slower the evaluation becomes.
Front-endCSS contains unqualified attributesStyle Sheets that contain one or more unqualified attribute selectors. Unqualified attribute selectors, such as [type=text], match all elements first and then check their attributes. This means unqualified attribute selectors have the same performance characteristics as the universal selector (*). Similar to the universal selector, unqualified attribute selectors cause performance issues when used as the key part (far-right) of a selector.
Front-endCSS contains zero unit declarationsStyle Sheets that contain one or moreo zero unit declarations. The value of 0 works without specifying units in all situations where numbers with length units or percentages are allowed. There is no difference between 0px, 0em, 0%, or any other zero-value. The units aren’t important because the value is still zero. CSS allows you to omit the length units for zero values and still remain valid CSS. It’s recommended to remove units for all zero length values because these units aren’t being used by the browser and therefore can be safely removed to save bytes.
Front-endCSS contains overqualified selectorsStyle Sheets that contain one or moreo overqualified selectors. Writing selectors such as li.active are unnecessary unless the element name causes the class to behave differently. In most cases, it’s safe to remove the element name from the selector, both reducing the size of the CSS as well as improving the selector performance (doesn’t have to match the element anymore). Removing the element name also loosens the coupling between your CSS and your HTML, allowing you to change the element on which the class is used without also needing to update the CSS.
Front-endCSS contains duplicate background imagesStyle Sheets that contain one or more of the selectors are using the same background image. You should ensure image URLs are only used once, as duplicating them will increase the size of the Style Sheet and have a small performance hit.
Front-endDoes not contain any HTML when JavaScript is turned offHTML URLs that do not contain any content when the JavaScript is turned off. If a user was to view this page with JavaScript disabled or a screen reader, they would be faced with a blank page.
Front-endMissing <noscript> tag in the <body>HTML URLs that use JavaScript, but does not include a <noscript> tag as fallback in case the user has JavaScript disabled.
Front-endContains Javascript ErrorsHTML URLs that contain JavaScript errors, which could cause the HTML not to be rendered correctly.
Front-endContains an un-encoded special characterHTML URLs that have DOM elements with text content that contains one or more special characters, that has not been escaped/encoded. These special characters could be incorrectly interpreted browser and cause problems when rendering the page.
Front-endContains a broken tagHTML URLs that have one or more HTML tags that are broken and must be paired. These could be incorrectly interpreted browser and cause problems when rendering the page.
Front-endContains an uppercase tag nameHTML URLs that have one or more HTML tags with uppercase letters in its name. Whilst fixing this issue will not make noticeable performance gains, it is considered a best practice recommendation. Having clean, standardised code makes it easier for other developers to work on, and makes the code easier for search engine crawlers and browsers to parse.
Front-endContains a duplicate attributeHTML URLs that have one or more DOM elements with the same attribute is specified twice (e.g. an image with two src attributes). Browsers will use the first attribute value, and ignore subsequent attribute values. It is important these are cleaned up and fixed to ensure the correct value is used.
Front-endContains an attribute whose value is not enclosed in double quotesHTML URLs that have one or more DOM element attribute value that is not enclosed by double quotes tags, which could result in browsers ignoring the attribute.
Internal URLsURL resolves under both HTTP and HTTPSURLs that resolve under both HTTP and HTTPS protocols. This could pose a security risk if users are able to access insecure content (which should be secure) and may also lead to duplicate content issues, if search engines end up crawling both HTTP and HTTPS versions.
Internal URLsBroken internal URLsAll internal URLs that weren’t successfully audited, and had a crawl status of either Not Found, Error, Forbidden or Timeout. Broken URLs are unwelcome, as they result in a poor user experience, and can also have a negative SEO impact, depending on the type and scale of the issue.
Internal URLsURL contains upper case charactersURLs that contain upper cases characters in the URL (e.g. http://example.com/ContactUs). Ideally URLs should be lower case and not be mixed case, as mixed case URLs can lead to duplicate content, a loss of link equity to the correct version and wasted crawl budget.
Internal URLsURL contains whitespaceURLs that contain one or more whitespace characters in the path (e.g. http://example.com/page 1). URLs with whitespace characters are not recommended as they could cause issues when site visitors share or link to the URL, potentially leading to broken links and a loss of potential link equity.
Internal URLsURL contains repetitive elementsURLs that contain repetitive elements in the URL path, which can cause duplicate content issues or broken internal links. Repetitive elements in URL paths are usually caused when the crawler comes across links with relative URLs and the page doesn’t have a base URL e.g. https://example.com/pages/pages/page1. They can be generated by Content Management Systems, plugins or broken HTML. A common false positive for this Hint is dates in the path – these can normally be ignored e.g. https://example.com/2017/11/11/page-name
Internal URLsQuery string contains a question markURLs that contain more than one question mark in the URL path (e.g. http://example.com/page?a=1?&a=1). If you include a second question mark in the query, this would be treated as a literal question mark (i.e. it has no significance beyond that of a regular character). Whilst this is not invalid, it is quite unusual, and may indicate some sort of issue with how URLs are generated, so it could warrant further investigation.
Internal URLsQuery string contains more than three parametersURLs that contain a query string with more than 3 parameters (e.g. http://example.com/page?a=1&b=2&c=3&d=4). URLs with more than 3 parameters could be considered highly dynamic, for example, faceted search URLs that include multiple filters and sorts. If these are accessible to search engines, they could lead to issues with crawl budget or duplicate content.
Internal URLsQuery string contains paginated parametersURLs that contain a query string with apparent pagination parameters (e.g. http://example.com/search?w=shoes&p=2). URLs with lots of parameters can be considered highly dynamic, for example, faceted search URLs that include multiple filters and sorts. If these also contain pagination parameters, they could lead to issues with crawl budget or duplicate content.
Internal URLsQuery string contains repetitive parametersURLs that contain repetitive parameters in the query string (e.g. http://example.com/page?a=1&a=1). Since the second parameter is redundant, the existence of these URLs could lead to duplicate content issues, since the content would be identical to the equivalent URLs with a single parameter. This could also indicate a much bigger problem, as it might imply an issue with the logic of the underlying software which generates the URLs in the first place.
Internal URLsQuery string contains search or filter parametersURLs that contain a query string with apparent search or filter parameters (e.g. http://example.com/search?w=shoes). Since ‘search’ URLs present the same content in a different order, they don’t offer a way for search engines to discover new content, so you typically don’t want them spending time crawling these URLs if there are more important unique URLs that are being neglected from a crawl perspective.
Internal URLsQuery string contains sort parametersURLs that contain a query string with apparent sort parameters (e.g. http://example.com/search?w=shoes&sort=name). Since ‘sort’ URLs present the same content in a different order, they don’t offer a way for search engines to discover new content, so you typically don’t want them spending time crawling these URLs if there are more important unique URLs that are being neglected from a crawl perspective.
Internal URLsURL contains a double slashURLs that contain a double slash in the path (e.g. http://example.com//page1). A double slash in the URL path is valid and will respond in the browser, but is typically unwelcome, as this could cause duplicate content issues if the CMS delivers the same content on two URLs (i.e. single slash and double slash).
Internal URLsURL contains non-ASCII charactersURLs that contain characters outside the ASCII set (e.g. http://example.com/pagé). This is dangerous as you cannot be certain how search engines or browsers will handle these characters, which could cause unwelcome results if there are issues with the encoding procedure.
InternationalMissing hreflang annotationsURLs that are not specified as translations through hreflang annotations. This may be intentional – if a URL does not have a translation – however this may also highlight instances where URLs are missing hreflang markup, yet should have it.
InternationalHas outgoing hreflang annotations to broken URLsURLs with hreflang annotations that have at least one outgoing hreflang annotation which returned as Not Found (4XX) or Error (5XX) when Sitebulb attempted to crawl the outgoing URLs. This is problematic as it means that the hreflang equivalent URLs are inaccessible, which either means that the annotation is incorrect (e.g. typo) or the target page does not exist.
InternationalHas outgoing hreflang annotations to canonicalized URLsURLs with outgoing hreflang annotations where one or more of the annotation URLs is canonicalized to another URL. This is a conflicting signal for search engines, and may lead them to ignore the hreflang or canonical instruction (or both).
InternationalCanonicalized URL has incoming hreflangURLs that are defined as a hreflang alternate, yet also have a canonical tag pointing at a different URL. This is a conflicting signal for search engines, and may lead them to ignore the hreflang or canonical instruction (or both).
InternationalHas outgoing hreflang annotations to disallowed URLsURLs with outgoing hreflang annotations where one or more of the annotation URLs is disallowed. Disallowed URLs are not crawlable, which means that search engines will ignore the hreflang instructions.
InternationalDisallowed URL has incoming hreflangURLs with incoming hreflang annotations that yet are disallowed in robots.txt. Disallowed URLs are not crawlable, which means that search engines will ignore the hreflang instructions.
InternationalHas conflicting incoming hreflang annotationsURLs that have multiple, different incoming hreflang annotations – causing a conflict between the differing annotations. This sort of conflicting signal will cause search engines to ignore the hreflang instruction.
InternationalHas conflicting outgoing hreflang annotationsURLs with hreflang where one or more outgoing hreflang annotations specify the same URL, but with different hreflang – so there is a conflict between the two annotations. This sort of conflicting signal will cause search engines to ignore the hreflang instruction.
InternationalHas multiple self-referencing hreflang annotationsURLs with hreflang where a URL contains multiple self-referenced hreflang, using multiple different hreflang, so the ‘correct’ one is ambiguous. This sort of conflicting signal may cause search engines to ignore the hreflang instruction.
InternationalHas outgoing hreflang annotation to multiple URLsURLs with hreflang where one or more outgoing hreflang annotation is specified against more than one URL – so there is a conflict between the various annotations. This sort of conflicting signal will cause search engines to ignore the hreflang instruction.
InternationalHreflang annotation also x-defaultURLs with hreflang annotations where one of the alternate URLs is also defined as the x-default hreflang. This means that the page marked as x-default is specified as a language alternate, but also as the default ‘fallback’ page. If this setup is intentional, this is not an issue. Sometimes, x-default has been included by accident, and the page is not a suitable fallback for the rest of the world.
InternationalHas outgoing hreflang annotations using relative URLsURLs with hreflang annotations that have at least one outgoing hreflang annotation which is referenced as a relative URL. Using relative URLs for hreflang increases the chances that something will go wrong in the future, even if the setup is valid right now.
InternationalInvalid HTML lang attributeURLs that have defined the language/region attribute using HTML lang, but either the language code or the geography code is invalid (or both are invalid). Invalid HTML lang will cause you issues in search engines that still support HTML lang (e.g. Bing), and they won’t serve the correct localised content in different regions.
InternationalInvalid incoming hreflang annotationsURLs that are referenced by at least one incoming hreflang annotation which is invalid (e.g. invalid language or country code). This will cause search engines to ignore the hreflang annotation.
InternationalHas invalid outgoing hreflang annotationsURLs with hreflang annotations where one or more of the outgoing annotations is invalid (e.g. invalid language or country code). This will cause search engines to ignore the hreflang annotation.
InternationalMismatched hreflang and HTML lang declarationsURLs with hreflang annotations and HTML lang attributes, which do not match. This implies that an error has been made with either the hreflang annotation, or with HTML lang (or both), and may cause search engines to include the incorrect language version in localised search results.
InternationalMissing canonical URLURLs with hreflang annotations, but with no canonical tag. URLs with hreflang do not need to have canonical tags – so it is NOT a problem if your site does not use them. However, it is worth considering that canonicals and hreflang are both indexing instructions. If you can give more precise, consistent indexing signals to search engines, not only will their indexing and linking properties be more accurate, but they will be better able to serve users the URL of their preferred language.
InternationalMissing HTML lang attributeIndexable URLs that have not defined the language/region attribute using HTML lang. Some search engines rely on HTML lang (instead of hreflang) to determine the language of a page, so if it is missing the language may not be correctly interpreted.
InternationalMissing reciprocal hreflang (no return-tag)URLs with hreflang annotations where at least one of the alternate hreflang URLs does not reciprocate. Hreflang must reciprocate, if it does not then search engines will ignore the hreflang instruction.
InternationalMissing self-reference hreflang annotationURLs with hreflang annotations which do not include a self-reference, using any method (HTML, HTTP header, or XML Sitemap). It is not necessary for URLs to include a hreflang self-reference, but it is considered best practice.
InternationalHas outgoing hreflang annotations to noindex URLsURLs with hreflang annotations where one or more of the annotation URLs is noindex. As these URLs are not indexable, this offers a conflicting signal to search engines, which means they may ignore the hreflang instructions.
InternationalNoindex URL has incoming hreflangURLs with hreflang annotations that have self-referencing hreflang, yet are also noindex URLs. This sort of conflicting signal will cause search engines to ignore the hreflang instruction.
InternationalHas outgoing hreflang annotations to redirecting URLsURLs with hreflang annotations that have at least one outgoing hreflang annotation which returned as a Redirect (3XX) when Sitebulb attempted to crawl the outgoing URLs. Hreflang alternate URLs should not redirect, and this conflicting signal may cause search engines to ignore the hreflang instruction.
InternationalHas unsupported or misconfigured hreflangURLs with hreflang annotations where one or more of the hreflang tags is configured using regular anchor links (e.g. in a HTML tag instead of a link rel). This is invalid, so the hreflang markup will not be considered by search engines at all.
InternationalHas hreflang annotations using multiple methodsURLs with hreflang annotations defined using more than one method (HTML, HTTP Header or XML Sitemap). Whilst this is not invalid unless the annotations conflict, it opens up a greater opportunity for inconsistencies to occur in the future.
InternationalHas hreflang annotations without HTML langURLs with hreflang annotations, that have not defined the language/region attribute using HTML lang. Some search engines rely on HTML lang (instead of hreflang) to determine the language of a page, so if it is missing the language may not be correctly interpreted.
LinksHas a link with no href attributeURLs that contain at least one outgoing anchor link which has no href attribute. These type of links are often used as internal jump points, since anchor tags which have no href attribute can be used for internal anchors. However, they may also represent an error – where the hyperlink was intended but accidentally not set.
LinksHas one or more outgoing followed links with non descriptive anchor textThe URL contains outgoing anchor links which do not use descriptive anchor text (they instead have anchor text like ‘click here’, go’, ‘here’, etc…). Descriptive anchor text can help search engines and users alike to better understand your content.
LinksHas only one followed internal linking URLURLs that only have a followed incoming link from one other URL on the website. URLs with only a single followed incoming link only inherit a small amount of link equity, which can make ranking very difficult.
LinksHas incoming followed links that do not use descriptive anchor textThe URL receives incoming followed links from other internal URLs, which do not use descriptive anchor text (they instead have anchor text like ‘click here’, go’, ‘here’, etc…). Descriptive anchor text can help search engines and users alike to better understand your content.
LinksHas an internal link with no anchor textURLs that contain at least one outgoing anchor link which has no anchor text. This represents a missed opportunity to provide additional information about the target page to search engines, which could have an impact on this page’s ability to rank for relevant search queries.
LinksURL is orphaned and was not found by the crawlerURLs that are not part of the crawlable website architecture. Orphaned URLs were not found as part of the website crawl, so were instead picked up by a different crawl source (XML Sitemap, URL List, Google Analytics or Google Search Console). The presence of orphaned URLs is not necessarily bad, however the cases you need to pay attention to are when you find orphaned URLs that return a 200 (OK) response. These are typically old URLs that need to be removed, or URLs that should be linked to, but aren’t for some reason.
LinksHas an anchored image with no alt textURLs that contain anchor links to image URLs with no alt text, or no alt attribute. For linked images, the alt text is considered equivalent to anchor text, and represents an opportunity to communicate meaning and context to search engines.
LinksOnly receives nofollow links or links from canonicalized URLsURLs found by the crawler that only receive incoming nofollow links, or incoming links from canonicalized URLs. In other words, the URL only receives links from URLs that do not pass Link Equity – which means that the URL has no power to rank in search results.
LinksHas a link with whitespace in href attributeURLs that contain at least one outgoing anchor link which has trailing or leading whitespace character in the href attribute. Whitespace in href atrributes may cause a loss or dissipation of link equity, if search engines treat the link targets as distinct URLs.
LinksHas link with a URL in onclick attributeURLs that contain at least one outgoing anchor link with a URL in an onclick attribute. This means that the link destination is JavaScript dependent, which search engines can struggle with.
LinksHas a link with an empty href attributeURLs that contain at least one outgoing anchor link which has an empty href attribute. This may be because a link was intended to be added, but was not. It also may represent a bug in the underlying code, which is adding <a>tags where it should not.
LinksPagination URL has no incoming internal linksURLs that are declared as a pagination URL, via rel=next/prev links on another URL, but which has no incoming anchor links from internal URLs. Typically, this is a result of a misconfiguration in the website platform or CMS, which erroneously adds pagination markup and spawns pages that should not exist.
LinksHas link with a URL referencing LocalHost or 127.0.0.1URLs that contain at least one outgoing anchor link with a URL referencing LocalHost or 127.0.0.1. These links are normally the accidental remains of development work, and will not be publicly accessible, so site visitors and search engines will be unable to follow the link.
LinksHas link with a URL referencing a local or UNC file pathURLs that contain at least one outgoing anchor link with a URL referencing a local or UNC file path. These links are normally left in by accident, and will not be publicly accessible, so site visitors and search engines will be unable to follow the link.
LinksHas no outgoing linksURLs that don’t link to any other URL, internal or external. If you have URLs with no outgoing links, this means that they are unable to pass on link equity to other URLs within the website architecture. As such, they act link a PageRank black hole – they accumulate link equity from incoming links, but don’t pass it back out to other URLs on the website.
LinksHas outgoing links with malformed href dataURLs that contain at least one outgoing anchor link which has malformed href data. This means that link equity will not be passed through to the link target, as the link itself is invalid. It may also mean that crawlers are unable to find the destination URL, so crawling, indexing and ranking may all be affected.
LinksAlternate URL has no incoming internal linksURLs that are declared as an alternate URL (on another URL), but which have no incoming anchor links from internal URLs (i.e. the only links they have are from the alternate link element). This means that the page cannot accumulate PageRank and will have no ability to rank in the search results. This Hint is Advisory since there are plenty of common situations where it is deliberate for alternate URLs to not be a part of the ‘user-facing’ website structure.
LinksHas link to a non-HTTP protocolThe URL contains outgoing anchor links which use a non-HTTP protocol (e.g. link to ftp://example.com/page). If you have links with a non-HTTP protocol, there is no guarantee how they would be handled by the user’s browser. For example, using the FTP protocol in a HTML link will cause the link to be opened by the users’ default FTP client.
LinksURL receives both follow & nofollow internal linksURLs that have a mixture of followed and nofollowed incoming links. If a given URL receives nofollowed links, this is usually a deliberate act, either because the website owner does not want to pass link equity to the linked URL, or they do not want search engines to crawl it. However, if even one other URL links to this page using followed links, this can negate the affect that the website owner was trying to achieve with the nofollow.
Mobile FriendlyTotal page size too big for 3G connectionsURLs for which the total byte size of the page and all the resources is greater than 1600KB, which is theoretically too big for a time-to-interactive of 10 seconds on a 3G connection. This means that the page is very slow loading on mobile, which negatively affects user experience.
Mobile FriendlyThe viewport <meta> tag has scaling issuesURLs for which the viewport <meta> tag is not set up correctly for scaling. You can use the meta viewport tag to control the width and scaling of the browser’s viewport: include ‘width=device-width’ to match the screen’s width in device-independent pixels, include ‘initial-scale=1’ to establish a 1:1 relationship between CSS pixels and device-independent pixels, and ensure the page is accessible by not disabling user scaling.
Mobile FriendlyThe viewport <meta> tag prevents the user from scalingURLs for which the viewport <meta> tag has a user-scale value that prevents the user from scaling. This means that the attribute ‘user-scalable’ is set to ‘0’ or ‘no’, which essentially disables user scaling, meaning that users cannot zoom in/out on mobile devices, and may cause accessibility issues.
Mobile FriendlyThe viewport <meta> tag has a maximum-scale setURLs for which the viewport <meta> tag has a maximum-scale value. Setting a value for the ‘maximum-scale’ attribute could prevent the user from scaling properly, meaning that users may not be able to zoom in/out on mobile devices, and may cause accessibility issues.
Mobile FriendlyThe viewport <meta> tag has a minimum-scale setURLs for which the viewport <meta> tag has a minimum-scale value. Setting a value for the ‘minimum-scale’ attribute could prevent the user from scaling properly, meaning that users may not be able to zoom in/out on mobile devices, and may cause accessibility issues.
Mobile FriendlyMultiple viewport <meta> tags were found in the <head>URLs that contain multiple viewport <meta> tags in the <head>. Only one viewport tag is required, and if more than one is used this could lead to the wrong one being selected, which may cause rendering issues.
Mobile FriendlyMissing viewport <meta> tag in the <head>URLs that do not contain the viewport <meta> tag in the <head>. Without a viewport, mobile devices will render the page at a typical desktop screen width, scaled to fit the screen.
Mobile FriendlyThe viewport <meta> tag does not have a width setURLs for which the viewport <meta> tag does not have a width set. You can control the page dimensions on different devices by includings ‘width=device-width’, which matches the screen’s width in device-independent pixels. If you don’t set the width, mobile browsers will render the page at a desktop screen width, and then try to make the content look better by increasing font sizes and scaling the content to fit the screen, which means that font sizes may appear inconsistent to users, who may have to double-tap or pinch-to-zoom in order to see and interact with the content.
Mobile FriendlyThe viewport <meta> tag has a specific width setURLs for which the viewport <meta> tag has a specific width set. You can control the page dimensions on different devices by includings ‘width=device-width’, which matches the screen’s width in device-independent pixels. If you set a specfic width, mobile browsers will render the page at the width even on devices that are larger or smaller, and then try to make the content look better by increasing font sizes and scaling the content to fit the screen, which means that font sizes may appear inconsistent to users, who may have to double-tap or pinch-to-zoom in order to see and interact with the content.
Mobile FriendlyThe viewport <meta> tag is missing an initial-scaleURLs for which the viewport <meta> tag is missing an initial-scale. Some browsers keep the page’s width constant when rotating to landscape mode, and zoom rather than reflow to fill the screen. Adding the attribute ‘initial-scale=1’ instructs browsers to establish a 1:1 relationship between CSS pixels and device-independent pixels regardless of device orientation, and allows the page to take advantage of the full landscape width.
Mobile FriendlyThe viewport <meta> tag initial-scale is incorrectURLs for which the viewport <meta> tag initial-scale is not set to 1. Adding the attribute ‘initial-scale=1’ instructs browsers to establish a 1:1 relationship between CSS pixels and device-independent pixels regardless of device orientation, and allows the page to take advantage of the full landscape width when rotating the screen. Unless the width attribute is set to a specific value, setting the initial-scale to a value other than 1 will make the page content appear zoomed in (or out) on mobile devices.
Mobile FriendlyFont size is too small for mobile devicesURLs that contain some text which is too small, and not legible for mobile devices. It is recommended to use a base font size of 12 CSS pixels on the <body> or <html> tag, anything smaller is considered illegible.
Mobile FriendlyContent does not size correctly to viewportURLs for which the page content is not responsive. When the screen is made smaller or larger than viewport width, the content does not size accordingly, which often means that the page is not optimized for mobile devices.
Mobile FriendlyTap targets are too small or closeURLs that contain touch targets (such as buttons and links) which are too small or close to each other. This makes it difficult for mobile users to tap a desired element with their finger without also tapping a neighboring element. The minimum recommended touch target size is around 48 pixels on a page that has a mobile viewport set. Smaller touch targets should be spaced about 32 pixels apart, both horizontally and vertically.
Mobile FriendlyHas one or more image-map <map> tagsURLs that contain image-map tags. Image maps rely on hard coded coordinate data for each different link, which do not scale well in mobile browsers.
Mobile FriendlyUnsupported browser plugins foundURLs that utilize unsupported browser plugins. Plugins are not widely supported by mobile devices (and by default most desktop browsers restrict them), which makes the content unavailable on mobile devices.
On Page<head> contains a <noscript> tagURLs where the <head> contains a <noscript> tag. You need to be very careful using <noscript> tags in the <head>, as you can very easily break the <head>, which can cause problems for search engines as they may be unable to find important head-only tags, such as hreflang.
On PageURL contains no Google Analytics codeURLs that do not contain a Google Analytics code. This may simply be because the website does not use Google Analytics, but may also represent instances where the Google Analytics code is accidentally missing. Note that this Hint is independent of any Google Tag Manager implementation, and simply means that no Google Analytics code was found on the page.
On PageMeta description is missingURLs that do not contain a meta description. The meta description is considered important to help users quickly understand what content they can expect to find on the page, when clicking through from the search engine results page. Well written meta descriptions typically achieve a better click-through-rate. If the meta description is missing, this represents a missed optimization opportunity.
On Page<h1> length too shortURLs that contain a header 1 with too few words. If the <h1> does not use many words, in may not be well optimized to effectively communicate the desired message. It is considered best practice to try and include the main target keywords for the page in the <h1>, whilst also communicating ‘what the page is about.’
On PageHas images with missing alt textURLs that contain images with no alt attribute or missing alt text. Alt text is important for accessibility, to communicate meaning and context about the image to visually impaired users. Search engines also use alt text to understand the meaning and context, so images with no alt text represent poor accessibility, and a missed SEO opportunity.
On PageTitle tag length too shortURLs that contain a title tag with too few characters. If the title uses too few characters, it may not be sufficient to effectively communicate the desired message.
On PageTitle tag length too longURLs that contain a title tag with too many characters. If the title uses too many characters, it may not be well optimized to effectively communicate the desired message. Depending on the query, search engines may truncate or rewrite titles that are too long.
On Page<h1> tag is missingHTML URLs that do not contain a header 1. The header 1 (h1) tag is considered important to help both users and search engines to quickly understand what content they can expect to find on the page. If the <h1> is not present, this represents a missed optimization opportunity.
On PageURL contains a form with a GET methodURLs that contain a form element with the method set to GET, which creates submission URLs with the form data in the query string. This presents a potential vulnerability for a large number of URLs to be created and/or cached, which could cause issues with crawl efficiency or index bloat
On PageTitle tag is emptyHTML URLs that contain an empty <title> element. The title tag is considered one of the most important on-page SEO factors, so if it is not present this represents an issue that may affect search engine rankings and click-through-rate from the search results.
On Page<h1> length too longURLs that contain a header 1 with too many words. If the <h1> uses too many words, in may not be well optimized to effectively communicate the desired message. It is considered best practice to try and include the main target keywords for the page in the <h1>, whilst also communicating ‘what the page is about.’
On PageMultiple <h1> tagsURLs that contain multiple header 1s. Having more than one <h1> tag can be a sign of poor content structure, and could de-emphasize keyword associations with the page.
On PageMeta description length too shortURLs that contain a meta description with too few characters. If the meta description is particularly short, this may mean it has been automatically generated or is not well optimized, and may achieve poor click-through-rate as a result.
On Page<head> contains invalid HTML elementsURLs where the <head> contains invalid DOM elements. Valid elements that can be used inside the <head> element are <title>, <meta>, <base>, <link>, <script>, <noscript>, <style> and <template>. Including invalid elements can lead to the HTML document not being parsed correctly, as the presence of other elements breaks the <head>, which may cause important tags (e.g. meta robots) to be missed.
On PageMeta description length too longURLs that contain a meta description with too many characters. If the meta description is very long, this may mean it has been automatically generated or is not well optimized, and may achieve poor click-through-rate as a result. Depending on the query, search engines may truncate or rewrite meta descriptions that are too long.
On Page<head> contains a <noscript> tag, which includes an imageURLs where the <head> contains a <noscript> tag, which includes an image. Including an <img> tag in the <head> is invalid. This can be problematic for search engines crawlers that do not render JavaScript (i.e. most crawlers, most of the time), as the presence of the <img> tag breaks the <head>, which may cause important tags (e.g. meta robots) to be missed.
On PageHTML is missing or emptyURLs do not contain any HTML. If there is no HTML content, then users and search engines alike will not be able to access any visible content.
On Page<h1> tag is emptyHTML URLs that have an empty header 1. The header 1 (h1) tag is considered important to help both users and search engines to quickly understand what content they can expect to find on the page. If the <h1> is empty, this represents a missed optimization opportunity.
On PageBase URL malformed or emptyURLs that specify a base URL which is malformed or empty. The base tag is used to determine the URL base for all relative links used within a page. If the base tag is malformed or empty, this may cause problems for search engines crawling relative links.
On PageMeta description is emptyURLs that have an empty meta description. The meta description is considered important to help users quickly understand what content they can expect to find on the page, when clicking through from the search engine results page. Well written meta descriptions typically achieve a better click-through-rate. If the meta description is empty, this represents a missed optimization opportunity.
On PageMultiple base URLsURLs that specify more than one base URL. The base tag is used to determine the URL base for all relative links used within a page. A document can have no more than one base element, so multiple base tags is invalid, and this may cause problems for search engines crawling relative links.
On PageMultiple meta descriptionsURLs that contain multiple meta descriptions. If there are multiple meta descriptions on the page, it may lead to search engines displaying the ‘wrong’ one, which in turn may lead to lower engagement or CTR from search results.
On PageMultiple title tagsURLs that contain more than one <title> element. If there are multiple title tags on the page, it may lead to search engines displaying the ‘wrong’ one, which in turn may lead to lower engagement or CTR from search results, and may also have an SEO impact.
On PageMultiple, mismatched base URLsURLs that specify more than one base URL, and the URLs are different. The base tag is used to determine the URL base for all relative links used within a page. A document can have no more than one base element, so multiple base tags is invalid, and this may cause problems for search engines crawling relative links – particularly as the base URLs are different, there is no guarantee they will select the ‘right’ one.
On PageTitle and meta description are the sameURLs that have identical text for the title and meta description. The title and meta description serve very different purposes, and if they are identical then this is usually the result of a misconfigured plugin or script.
On PageTitle tag is missingHTML URLs that do not contain the <title> element. The title tag is considered one of the most important on-page SEO factors, so if it is missing this represents an issue that may affect search engine rankings and click-through-rate from the search results.
On PageURL contains more than one Google Analytics codeURLs that contain multiple Google Analytics codes. Whilst valid, and sometimes deliberate, this might imply a configuration error – such as a plugin inserting an additional code.
On PageURL contains more than one Google Tag Manager codeURLs that contain multiple Google Tag Manager codes. Whilst it is valid, Google advise to keep the number of Google Tag Manager containers on the page minimal, for best performance.
On PageURL contains no Google Tag Manager codeURLs that do not contain a Google Tag Manager code. This may simply be because the website does not use Google Tag Manager, but may also represent instances where the Google Tag Manager code is accidentally missing.
Page SpeedDOM width exceeds recommended 60 nodes wideURLs for which the DOM has a parent node with more than the recommended 60 child nodes. While browsers can handle larger DOM trees, they are optimized for a maximum of 60 elements wide. A large DOM tree can harm network efficiency and load performance, runtime performance and memory performance.
Page SpeedHas too many synchronous JavaScript requestsURLs that contain more than 3 synchronous JavaScript files. For every JavaScript file that the browser needs to load, it will send a separate HTTP request to the server. If these are synchronous requests then the browser will need to allow each one to finish before moving on to the next. Fewer files means fewer requests, and therefore a faster load speed.
Page SpeedContains one or more single point of failureURLs that have one or more single point of failure (SPOF). If you load 3rd party JavaScript, CSS or fonts synchronously inside the HTML <head>, these files could fail to load and stop the entire page from loading.
Page SpeedLoads offscreen images that appear below the foldURLs that load offscreen, below-the-fold images, during the initial request. Users cannot initially see below-the-fold images, so these can be lazy loaded with JavaScript, to reduce time to interactive.
Page SpeedLoads oversized images which are scaled in the browserURLs that load oversized images which are then scaled by the browser. Scaling images in the browser is bad for performance as it takes extra CPU time and the user ends up downloading data they don’t use. Instead create multiple versions of the same image server-side and serve the appropriate one to the user.
Page SpeedCritical (Above-the-fold) CSS was found in the <head> but not loaded early enoughURLs that do include critical CSS content in the <head> (as recommended), but do not load it early enough. Critical CSS should be rendered before any JavaScript or style sheets, and ideally immediately after critical meta data.
Page SpeedLoads in too many webfontsURLs that load in more than 5 webfonts. Loading in lots of webfonts can slow down the rendering of content.
Page SpeedServer response too slow with a Time-to-First-Byte greater than 600msURLs that had a Time-to-First-Byte (TTFB) greater than 600ms. TTFB is a measure of how long it takes to receive data from the server, and high TTFB is a cause of slow page load.
Page SpeedTotal combined CSS content size is too big (over 500KB)URLs for which the total byte size of the CSS resources is greater than 500KB. If the total downloaded CSS is too big, then the browser needs to do more work parsing CSS ready against the HTML, which makes rendering slower.
Page SpeedTotal combined JavaScript content size is too big (over 500KB)URLs for which the total byte size of all the JavaScript resources is greater than 500KB. If the total downloaded JavaScript is too big, then the browser needs to do more work parsing and compiling the scripts, which makes rendering slower.
Page SpeedLoads overweighted webfontsURLs that load in one or more webfonts that are above 50KB. Webfonts that are over this size are probably not optimized for the web, and slow down rendering.
Page SpeedTotal combined size of the webfonts used is too big (over 200KB)URLs that contain webfonts with a total combined size of over 200KB, which is not well optimized for the web. This could be a compresson issue, a font that contains too many glyphs or a font with complex shapes.
Page SpeedToo many requests per domainURLs that make more than 30 concurrent requests to any one domain. When using HTTP/1, browsers have a limit on how many concurrent requests they can do per domain. Once this limit is hit, the browser will need to wait before it can download more assets on that domain – so avoid this additional wait time by having less requests per domain. Note that this hint can be ignored for any website implementing HTTP/2.
Page SpeedURL loads in one or more identical CSS ResourceURLs that load in one or more identical CSS resource (that have the same content but are loaded from different URLs). Duplicate CSS resources hurt performance by creating unnecessary HTTP requests.
Page SpeedURL loads in one or more identical JavaScript ResourceURLs that load in one or more identical JavaScript resource (that have the same content but are loaded from different URLs). Duplicate JavaScript resources hurt performance by creating unnecessary HTTP requests.
Page SpeedHTML content is not minifiedURLs that contains HTML which is not minified or could be minified further. Minification works by analyzing and rewriting the text-based parts of a file to reduce its overall size, resulting in faster response times and lower bandwidth costs.
Page SpeedTransferred image size is over 100KBImage URL files that are over 100KB, which is generally considered large. One of the easiest ways you can improvem page load speed is by optimizing images and properly sizing them to the size that is rendered.
Page SpeedTotal combined Image content size is too big (over 1MB)URLs for which the total byte size of all image content is greater than 1MB. Large images, lots of images, or poorly compressed images will have a negative effect on load time and increase bandwidth.
Page SpeedUncompressed text content resourcesURLs that contain text content which has not been compressed. Text compression minimizes the byte size of network responses that include text content. Compressing text content with gzip saves download bytes and reduces bandwidth for the user.
Page SpeedJavaScript content is not minifiedURLs that load JavaScript files which contain JavaScript content that is not minified or could be minified further. Minification works by analyzing and rewriting the text-based parts of a file to reduce its overall size, resulting in faster response times and lower bandwidth costs.
Page SpeedStyle Sheet is larger than 14.5KBURLs that use a CSS file which is greater than 14.5KB. The browser can download the CSS faster if each CSS response is small (less than 14.5 KB), so the page will start to render earlier.
Page SpeedCSS content is not minifiedURLs that use a a Style Sheet which contains CSS content that is not minified or could be minified further. Minification works by analyzing and rewriting the text-based parts of a file to reduce its overall size, resulting in faster response times and lower bandwidth costs.
Page SpeedKeep-alive not set on page resources that are used multiple timesPage resources that close the connection and do not use keep-alive in the HTTP header. If you have multiple requests to the same domain, you can use keep-alive headers so the connection is not closed until all the requests are made.
Page SpeedResources that do not specify cache headersResource URLs, such as images or JavaScript files, that do not specify a cache header. Fetching something over the network is both slow and expensive. Large responses require many roundtrips between the client and server, which delays when they are available and when the browser can process them, and also incurs data costs for the visitor. Setting a cache header on your server response will tell the browser that it doesn’t need to download assets again, which avoids unnecessary requests to the server.
Page SpeedCharacter Set Is Not UTF-8URLs which have the character set defined as a value other than UTF-8. The HTML5 specification advises the use of UTF-8, which can support many languages and can accommodate pages and forms in any mixture of those languages. Its use also eliminates the need for server-side logic to individually determine the character encoding for each page served or each incoming form submission, which can have an impact on load time.
Page SpeedCharacter Set Not Specified In Head Or HeadersURLs which do not specify the character set in the <head> or HTTP Headers. It is important to specify a character set early (ideally in the HTTP response headers) to allow the browser to begin parsing HTML and executing scripts immediately. Without specifying a character set the browser is left to figure it out on its own which takes time and therefore negatively impacts page load times.
Page SpeedChar Set Meta Is Not First Element In HeadURLs which specify the character set in the <head>, where it is not the first element. It is important to specify a character set as early as possible (ideally in the HTTP response headers) to allow the browser to begin parsing HTML and executing scripts immediately.
Page SpeedCharacter Set missing from the HTTP HeadersURLs which do not specify the character set (charset) in the HTTP Headers. It is important to specify a character set as early as possible – ideally in the HTTP response headers – to allow the browser to begin parsing HTML and executing scripts immediately. Without specifying a character set the browser is left to figure it out on its own which takes time and therefore negatively impacts page load times.
Page SpeedStyle sheets are not loaded first in the <head>URLs that contain Stylesheet <link> elements in the <head>, which are loaded after a <script> element. CSS blocks rendering, so if it is not the first thing loaded on the page, this will cause the page to render more slowly.
Page SpeedDOM depth exceeds recommended 32 nodes deepURLs for which the DOM has nodes exceeding the maximum recommended depth of 32. While browsers can handle larger DOM trees, they are optimized for a maximum of 32 elements deep. A large DOM tree can harm network efficiency and load performance, runtime performance and memory performance.
Page SpeedCritical (Above-the-fold) CSS was not foundURLs that do not include critical CSS content in the <head>. Optimize the critical rendering path by inlining critical CSS in the <head>, which allows above-the-fold content to render in the browser without waiting for the rest of the CSS to load.
Page SpeedContains redirecting page resourcesURLs that contain page resources which redirect. A redirect adds an additional step for the browser to download the resource, so avoiding redirects helps with load speed.
Page SpeedDownloaded HTML is greater the 500KBURLs for which the total byte size of the downloaded HTML is greater than 500KB, which is considered large. Pages with a lot of HTML content are very slow to load.
Page SpeedStyle sheet is loaded in with media=’print’URLs that load in a specific Style Sheet just for printing. This requires the browser to load the printing Style Sheet, even if it is not going to be used. These styles should be moved to a print @media query.
Page SpeedContains DOM elements with empty src or href attributesURLs that contains DOM elements with empty src or href attributes. If the browser finds an empty src or href attribute, it attempts to resolve it to the current URL or parent directory. This will cause unnecessary requests to the server, which will waste bandwidth and server resources.
Page SpeedLoads hidden imagesURLs that load in images which are not visible (their style ‘display’ property is set to ‘none’, or one of their parents is). These images will be loaded in by the browser even though they are not visible. This will increase page load time and potentially waste additional bandwidth if the user does end up seeing them.
Page SpeedUnoptimized JPEG images that could be compressed furtherJPEG image files that are unoptimized, and could be compressed further. Unoptimized images are slower to download and consume more bandwidth.
Page SpeedHas an excessive number of DOM nodes (greater than 1500)URLs that contain more than 1500 elements in the DOM. While browsers can handle larger DOM trees, they are optimized for a maximum of 1500 nodes in total. A large DOM tree can harm network efficiency and load performance, runtime performance and memory performance.
Page SpeedStatic resources have private a cache-control headerResource URLs, such as images or JavaScript files, that specify a private cache-control header. These responses are typically intended for customizing the browsing experience for a single user. Static content should be cached and used by all users, so avoid setting the cache to private.
Page SpeedResources that do not specify long cache headersResource URLs, such as images or JavaScript files, that do specify cache headers, but for less than 30 days. For files that do not tend to change, such as images, you should look to increase the cache time period, which means the files stay in the browser cache for longer, thus avoiding extra requests to the server. You will need to manually check which files do not change regularly, and would benefit from longer cache headers.
Page SpeedDuplicate Javascript FilesJavaScript file URLs that are technically duplicated – the URLs are the same other than a query string, and the file size and body content are identical. This typically comes from developers adding version numbers or timestamps to page resources, and can be problematic as you lose the ability to cache the resources across multiple pages. In reality, if this only affects a handful of URLs this is not a big issue, but if it affects thousands of URLs then it is a much bigger problem.
Page SpeedDuplicate Style SheetsCSS file URLs that are technically duplicated – the URLs are the same other than a query string, and the file size and body content are identical. This typically comes from developers adding version numbers or timestamps to page resources, and can be problematic as you lose the ability to cache the resources across multiple pages. In reality, if this only affects a handful of URLs this is not a big issue, but if it affects thousands of URLs then it is a much bigger problem.
RedirectsExternal redirected URLsExternal URLs that redirect (3XX) to another URL. This Hint is Advisory as it does not represent an SEO issue, simply a (relatively small) user issue. Whereas internal redirects can have an impact upon crawl budget and load speed, this does not apply to external redirects.
RedirectsInternal redirected URLsInternal URLs that redirect (3XX) to another URL. Redirects add an extra ‘hop’ to the request, which means it takes longer for the content to become available, which is a bad user signal, and means that search engine crawlers have to do additional ‘work’ to find the content.
RedirectsExternal URL redirect broken (4XX or 5XX)External URLs that redirect to a URL which is Not Found (4XX) or Error (5XX). This is a bad experience for users and search engines alike, as they will be unable to reach the content.
RedirectsInternal URL redirect broken (4XX or 5XX)URLs that redirect to a URL which is Not Found (4XX) or Error (5XX). This is a bad experience for users and search engines alike, as they will be unable to reach the content.
RedirectsInternal URL redirects back to itselfInternal URLs that redirect in a loop (e.g. URL 1 -> URL 1). This is bad for SEO as search engine crawlers will be unable to access the page content to index it. It is also bad for users, who will be shown an error page (e.g. ‘Website redirected you too many times’).
RedirectsRedirects using a Meta refreshThe Meta refresh is a simple on page redirect, and is usually used when it is not possible to implement a HTTP redirect. Search engines will follow a meta refresh, and pass on some link equity, but they offer a poor user experience so are not recommended.
RedirectsResource URL redirect broken (4XX or 5XX)Resource URLs that redirect to a URL which is Not Found (4XX) or Error (5XX). The URL in question is a page resource URL (e.g. CSS or JavaScript file), which means it is used for rendering the content on a page. If the resource is no longer accessible, this may affect how it is rendered, which could cause a poor user experience.
RedirectsPage resource URL redirects back to itselfPage resource URLs that redirect in a loop (e.g. URL 1 -> URL 1). This means that the resource is inaccessible, which may affect how page content is rendered.
RedirectsRedirected page resource URLsPage resource URLs, such as JavaScript and CSS files, that redirect to another URL – which may affect load time and cause page content to render incorrectly.
RedirectsPage resource URL is part of a chained redirect loopPage resource URLs that are part of a redirect chain which results in a redirect loop (e.g. URL 1 -> URL -> 2 -> URL 3 -> URL 1). This means that the resource is inaccessible, which may affect how page content is rendered.
RedirectsInternal URL is part of a chained redirect loopInternal URLs that are part of a redirect chain which results in a redirect loop (e.g. URL 1 -> URL -> 2 -> URL 3 -> URL 1). This is bad for SEO as search engine crawlers will be unable to access the page content to index it. It is also bad for users, who will be shown an error page (e.g. ‘Website redirected you too many times’).
RobotsMismatched nofollow directives in HTML and headerURLs with the robots follow/nofollow directive specified in both the HTML <head> and also in the X-Robots-Tag, where the directives do not match. This means that one location uses ‘follow’ and the other uses ‘nofollow’, and net result of this is that search engines will consider the page ‘nofollow’. This may cause crawling and indexing issues on important pages.
RobotsMismatched noindex directives in HTML and headerURLs with the robots index/noindex directive specified in both the HTML <head> and also in the X-Robots-Tag, where the directives do not match. This means that one location uses ‘index’ and the other uses ‘noindex’, and net result of this is that search engines will consider the page ‘noindex’, which may cause important pages to end up not indexed.
RobotsMultiple nofollow directivesURLs with the robots nofollow directive specified in more than one location (e.g. two SEO plugins that both add robots directives to the HTML). It is considered best practice to only specify robots directives once on any given URL, as this helps avoid potential issues in the future.
RobotsMultiple noindex directivesURLs with the robots noindex directive specified in more than one location (e.g. two SEO plugins that both add robots directives to the HTML).It is considered best practice to only specify robots directives once on any given URL, as this helps avoid potential issues in the future.
RobotsNofollow in HTML and HTTP headerURLs with the robots nofollow directive specified in both the HTML <head> and also in the X-Robots-Tag. It is considered best practice to only specify robots directives once on any given URL, as this helps avoid potential issues in the future.
RobotsNoindex in HTML and HTTP headerURLs with the robots noindex directive specified in both the HTML <head> and also in the X-Robots-Tag. It is considered best practice to only specify robots directives once on any given URL, as this helps avoid potential issues in the future.
RobotsDisallowed imageImage URLs that are disallowed in robots.txt, which may affect how search engines render page content. If these page resource URLs are disallowed in robots.txt, it means that Googlebot may be unable to correctly render the page content. Google relies on rendering in a number of their algorithms – most notably the ‘mobile friendly’ one – so if content cannot be properly rendered, this could have a knock on effect in terms of search engine rankings.
RobotsDisallowed JavaScript fileJavaScript files that are disallowed in robots.txt, which may affect how search engines render page content. If these page resource URLs are disallowed in robots.txt, it means that Googlebot may be unable to correctly render the page content. Google relies on rendering in a number of their algorithms – most notably the ‘mobile friendly’ one – so if content cannot be properly rendered, this could have a knock on effect in terms of search engine rankings.
RobotsDisallowed Style SheetCSS files that are disallowed in robots.txt, which may affect how search engines render page content. If these page resource URLs are disallowed in robots.txt, it means that Googlebot may be unable to correctly render the page content. Google relies on rendering in a number of their algorithms – most notably the ‘mobile friendly’ one – so if content cannot be properly rendered, this could have a knock on effect in terms of search engine rankings.
RobotsHas noindex and nofollow directivesInternal URLs with both the noindex and nofollow robots directives. This means that search engines are being instructed not to include the URL in their index, and to not schedule and crawl any of the links found on the pages. This Hint is Advisory since using these type of robots directives is a common way to control what content search engines can crawl and index (e.g. a user login area). However it is worth double checking that there are no URLs using these directives that you actually want to be properly crawled and indexed.
RobotsInternal Disallowed URLsInternal URLs that are disallowed in robots.txt. Disallowed URLs are not crawlable by search engines, which means that content from disallowed pages is not indexable. This Hint is Advisory since disallowing URLs is a common method for managing search engine crawlers, so they do not end up crawling areas of a website that you don’t want them to crawl (e.g. a user login area). However it is worth double checking that there are no URLs that are being disallowed which should not be disallowed.
RobotsURL only has nofollow incoming internal linksURLs that do not have any followed internal links pointing at them – only nofollow links. If a given URL receives only nofollow links from all the internal URLs that link to it, that means it will no accumulate link equity, and as such would have no power to rank for search queries. This Hint is Advisory since, in some cases, it is entirely appropriate for a URL to have only nofollow links pointing at it (e.g. a user login page). However it is worth double checking that there are no such URLs that you actually want to be properly crawled and indexed.
SecurityStrict-Transport-Security HTTP (HSTS) header is missingHTTP Strict Transport Security (HSTS) strengthens your implementation of TLS by getting the User Agent to enforce the use of HTTPS.
SecurityReferrer-Policy HTTP header is missingReferrer Policy is a new header that allows a site to control how much information the browser includes with navigations away from a document and should be set by all sites.
SecurityX-Content-Type-Options HTTP header is missingX-Content-Type-Options stops a browser from trying to MIME-sniff the content type and forces it to stick with the declared content-type. The only valid value for this header is “X-Content-Type-Options: nosniff”.
SecurityContent-Security-Policy HTTP header is missing or invalidA Content Security Policy is an effective measure to protect your site from XSS attacks. By whitelisting sources of approved content, you can prevent the browser from loading malicious assets.
SecurityLoads page resources using protocol relative URIsLoading a resource using protocol relative URIs allow it to be requested over HTTP and opens the door for Man-on-the-side attacks. If a resource is available over SSL, then always use the https:// URI.
SecurityX-Frame-Options HTTP header is missing or invalidX-Frame-Options tells the browser whether you want to allow your site to be framed or not. By preventing a browser from framing your site you can defend against attacks like clickjacking. Recommended value “x-frame-options: SAMEORIGIN”.
SecurityX-XSS-Protection HTTP header is missing or invalidX-XSS-Protection sets the configuration for the cross-site scripting filter built into most browsers. Recommended value “X-XSS-Protection: 1; mode=block”.
SecurityHas style sheets served via a CDN without subresource integrityA CDN is in control of some or all of the style sheets on this URL, which means a third-party could make unwanted changes to the script. Using a specification called Subresource Integrity, a website can include CSS that will stop working if it has been modified.
SecurityHas JavaScript served via a CDN without subresource integrityA CDN is in control of some or all of the JavaScript files on this URL, which means a third-party could make unwanted changes to the script. Using a specification called Subresource Integrity, a website can include JavaScript that will stop working if it has been modified.
SecurityLeaks server information useful for compromising serversServers will commonly reveal what software is running on them, what versions of the software are on there and what frameworks are powering it. Reducing the amount of information you divulge is always a benefit.
SecurityHTTPS URL links to an HTTP URLHTTPS URLs that contain one or more outgoing internal links to URLs which are HTTP.
SecurityHas external opener links vulnerable to tabnappingContains links to external URLs that use target=’_blank’ to open a new tab/window. The browser opens a new tab for the link, but also, for a very brief moment, allows the new tab to communicate with the original tab using a browser feature called the window.opener API. An attacker can place malicious code on the newly opened website, check the source of the click, and force the original tab to open a new URL.
SecurityMixed content (loads HTTP resources on HTTPS URL)URLs that are loaded over a secure HTTPS connection, with some resources that are loaded over an unsecure HTTP connection (mixed content).
SecurityHTTP URL contains a password input fieldURLs that are using an unsecure HTTP protocol and contain a form that posts potentially sensitive password data.
SecurityHTTPS URL contains a form posting to HTTPHTTPS URLs that contain a form which posts to HTTP (protocol change).
SecurityHas deprecated Public-Key-Pins HTTP headerThe Public-Key-Pins header has limited support and is being deprecated. It is also easily create a lot of problems with this header is not set up correctly.
SecurityHas deprecated Public-Key-Pins-Report-Only HTTP headerThe Public-Key-Pins-Report-Only header has limited support and is being deprecated. It is also easily create a lot of problems if this header is not set up correctly.
XML SitemapsNoindex URL in XML SitemapsURLs that are noindex, yet are included in an XML Sitemap. XML Sitemaps should only contain URLs you wish for search engines to index. If a URL is noindex, this is an explicit statement to search engines that you do NOT wish for the URL to be indexed. As such, including a noindex URL in a sitemap provides conflicting information to search engines, and may result in unintended URLs getting indexed.
XML SitemapsRedirect (3XX) URL in XML SitemapsURLs that returned Redirect (3XX), yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. URLs in your sitemaps should be clean – i.e. sitemaps should only include URLs that are HTTP status 200 (OK), indexable, canonical and unique. If search engines find ‘dirt’ in sitemaps, such as 301 pages, they may stop trusting the sitemaps for crawling and indexing signals.
XML SitemapsCanonicalized URL in XML SitemapsURLs that are canonicalized to another URL, yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. If a URL is canonicalized, this is an explicit statement to search engines that you do NOT wish for the URL to be indexed, and instead wish for the canonical URL to consolidate indexing signals. These are conflicting signals, and may result in the canonical being ignored, which could lead to indexing issues.
XML SitemapsDisallowed URL in XML SitemapsURLs that are disallowed in robots.txt, yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. If a URL is disallowed, this means that search engines are unable to crawl and properly index the content. Including a disallowed URL in a sitemap provides conflicting information to search engines, which could result in pages getting indexed that should not be indexed.
XML SitemapsError (5XX) URL in XML SitemapsURLs that returned Error (5XX), yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. URLs in your sitemaps should be clean – i.e. sitemaps should only include URLs that are HTTP status 200 (OK), indexable, canonical and unique. If search engines find ‘dirt’ in sitemaps, such as 500 pages, they may stop trusting the sitemaps for crawling and indexing signals.
XML SitemapsForbidden (403) URL in XML SitemapsURLs that returned Forbidden (403), yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. URLs in your sitemaps should be clean – i.e. sitemaps should only include URLs that are HTTP status 200 (OK), indexable, canonical and unique. If search engines find ‘dirt’ in sitemaps, such as 403 pages, they may stop trusting the sitemaps for crawling and indexing signals.
XML SitemapsNot Found (4XX) URL in XML SitemapsURLs that returned Not Found (4XX), yet are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. URLs in your sitemaps should be clean – i.e. sitemaps should only include URLs that are HTTP status 200 (OK), indexable, canonical and unique. If search engines find ‘dirt’ in sitemaps, such as 404 pages, they may stop trusting the sitemaps for crawling and indexing signals.
XML SitemapsTimed out URL in XML SitemapsURLs that Timed Out, which are included in an XML Sitemap. Your XML Sitemap should only contain URLs you wish for search engines to index. URLs in your sitemaps should be clean – i.e. sitemaps should only include URLs that are HTTP status 200 (OK), indexable, canonical and unique. If search engines find ‘dirt’ in sitemaps, such as pages that time out, they may stop trusting the sitemaps for crawling and indexing signals.
XML SitemapsURL in multiple XML SitemapsURLs that are included in more than one XML Sitemap. While including URLs in multiple sitemaps is not a bad thing at all, it might obscure some of the insight you can obtain from useful tools, such as the Google Search Console ‘Sitemaps’ report.