Skip to main content
Archived

SEO Report for https://hitechinstitute.in

Your general SEO Checkup Score


SEO Score53/100
Average SEO score of top 100 sites: 75%This value indicates the average SEO score of the top 100 most visited websites in the US (in the past 12 months)
AI Visibility57/100
AI visibility score reflects brand reach in AI

Your site scored 53/100, well below the 75 average for top sites. We found 20 issues to fix, and clearing them is how you move up. And an AI Visibility Score of 57/100 means ChatGPT, Gemini and Perplexity mention your brand only occasionally, which is ground your competitors are leaving open.

20 Failed
5 Warnings
38 Passed

Want to fix these issues and track your progress?

Issues to fix

HIGH
To provide a good user experience, Google recommends that sites should aim for a Largest Contentful Paint duration of 2.5 seconds or less.
Details
HIGH
To address URL canonicalization issues, it is recommended to select a primary URL for your webpage and set up redirects from all other variations to the preferred one.
Details
HIGH
To improve the website experience for your visitors, it is recommended to eliminate any render-blocking resources on this webpage.
Details
HIGH
Users may abandon pages that take longer than 5 seconds to load, resulting in a potential loss of up to 50% of visitors. Faster loading pages can lead to increased traffic, better conversions, and higher sales.
Details
HIGH
H1 and H2 tags ensure better search engine visibility and ranking by providing structure and hierarchy to the content, improving readability, and providing opportunities for keyword optimization.
Details
HIGH
Add a sitemap file to help search engine crawlers index content more thoroughly and quickly.
Details
HIGH
Add a robots.txt file to properly communicate with web crawlers and prevent unwanted access to sensitive content.
Details
HIGH
Using images in a modern format can significantly reduce the file size and improve the loading speed of a webpage, providing a better user experience and potentially increasing engagement.
Details
HIGH
JavaScript errors can impact user experience and may prevent users from viewing the page properly.
Details
MEDIUM
Serve properly sized images to reduce page loading times and to improve user's experience.
Details
MEDIUM
By creating a custom 404 error page with helpful links and information, users are more likely to stay on the site and continue to explore.
Details
MEDIUM
To provide a good user experience, Google recommends that sites should aim for a First Contentful Paint value of 1.8 seconds or less.
Details
MEDIUM
Avoid performance and security issues by adding "rel=noopener" or "rel=noreferrer" to your "target=_blank" links.
Details
LOW
A proper character encoding declaration ensures that all characters, including non-ASCII characters, are displayed correctly in the browser, improving the readability and usability of the webpage.
Details
LOW
Resolving errors identified by the Chrome DevTools Console can improve user experience.
Details
LOW
While a canonical link tag can help in resolving duplicate content issues, it's important to verify that the specified URL is accurate, especially if the site's URL structure has been recently updated.
Details
LOW
Using more than 20 HTTP requests on a webpage can negatively impact the loading time.
Details
LOW
Strip out any unnecessary metadata to improve loading time, security, and privacy. Metadata should not exceed 16% of the image size.
Details
LOW
Consider adding the Strict-Transport-Security header to your webpage to ensure that web traffic is encrypted over HTTPS, mitigating the risk of man-in-the-middle attacks and other security threats.
Details

AI Insights

Score:0
Failed:0
Warnings:0
Passed:5
Domain Business Context
Understanding the business context of a domain can help you create content that is more relevant to your target audience and differentiate your website from competitors.

What is this domain about

Vocational training website for mobile, laptop, and chip-level electronics repair courses.

Industry Niche

Technical vocational training

Target Audience

Students and job seekers looking for practical technical training and placement support in device repair.

This test will check the business context of the domain associated with the analyzed webpage. The business context includes the domain's description, target audience and industry niche (if applicable). Understanding the business context of a domain can help you create content that is more relevant to your target audience and differentiate your website from competitors.
LLM Visibility Checker
LLM Visibility Checker

Track your brand across ChatGPT, Gemini and Claude

Get an AI Presence Score, see which of your pages get cited, and follow how you compare with competitors over time.

How visible your brand is to AI engines
Content Strengths and Weaknesses

This webpage is highly focused on repair-training courses and career outcomes, with clear calls to action, contact details, and multiple course pathways. However, the content is repetitive, promotional, and light on verifiable proof, detailed curriculum information, and independent credibility signals.

Content Strengths

  • Clear Course Focus
  • Strong Contact Access
  • Multiple Conversion Paths

Content Weaknesses

  • Repetitive Promotional Copy
  • Limited Curriculum Depth
  • Weak Evidence Quality
This test will analyze the content of the webpage to identify its strengths and weaknesses. The analysis includes factors such as keyword usage, readability, originality, and relevance to the target audience. By understanding the strengths and weaknesses of your content, you can make informed decisions about how to improve it and better meet the needs of your audience.
Content Trust
58%
Topical Relevance92%
Subject Expertise62%
Credibility45%

This webpage appears moderately trustworthy because it provides strong topical focus, visible contact information, a physical address, and policy links. Trust is reduced by promotional exaggeration, unsupported performance claims, and the absence of clear author bios, cited sources, or third-party validation on the page.

This test will evaluate the trustworthiness of the content on the webpage. It assesses factors such as the credibility of sources, accuracy of information, and overall reliability. A high level of content trust can enhance your website's reputation and improve its ranking in search engine results.
Visual SEO Analysis
Visual SEO Analysis

Find out if your page design converts the visitors you earn

We score six things that decide whether a visitor stays and acts, from the first screen to the path to action, and rank every fix by effort and impact.

How your page's design and UX affect conversions
Content Freshness
54%

The page feels partly current because it references active course offerings, ongoing batches, and recent-style promotional language. Still, the visible footer copyright ending in 2021 and the lack of explicit recent publish or update timestamps make the page appear somewhat dated overall.

Positive Signals

  • Ongoing batch timings
  • Active course offerings
  • Current promotional language

Staleness Signals

  • Copyright ends in 2021
  • No visible publish dates
  • Static homepage layout
This test will check the freshness of the content on the webpage. It evaluates how recently the content was created or updated, and whether it remains relevant to current trends and user interests. Fresh content can attract more visitors and improve your website's ranking in search engine results.
Content Opportunities

The website has strong demand-side potential because it already targets a clear vocational audience, but the content is still mostly promotional and surface-level. The biggest opportunities are to add proof, depth, and structured learning resources that help visitors evaluate courses and outcomes more confidently.

Quick Wins

  • •Add a full syllabus section to each main course page with modules, duration, and tools covered.
  • •Rewrite student testimonials to include full names, job roles, and course completion details.
  • •Expand the homepage blog previews into linked FAQ-style troubleshooting articles with step-by-step solutions.
This test will identify potential content opportunities for the webpage. It analyzes the current content landscape, identifies gaps in coverage, and suggests topics or keywords that could be targeted to attract more visitors and improve search engine rankings.

Common SEO issues

Score:50
Failed:7
Warnings:1
Passed:11
Meta Title Test
100% of top 100 sites passed
This webpage is using a title tag.
Text: Mobile Repairing Course | 9212577577 - Hitech
Length: 45 characters
The meta title is an HTML element that defines a page's title, displayed in search engine results, browser tabs, and bookmark lists. A concise, keyword-relevant title is a strong on-page ranking signal and a major driver of organic click-through rate. AI answer engines and LLM-driven search experiences also rely on the title to identify, summarize, and cite the page in generative results.
Meta Description Test
92% of top 100 sites passed
This webpage is using a meta description tag.
Text: Mobile Repairing Course - Hitech Best Institute for Mobile & Laptop Repairing Course. Get Live Training, 15+ Branches in India.1 Hour FREE Demo Class, Apply Now
Length: 160 characters
The meta description is an HTML tag that provides a short summary of a page's content, often shown beneath the title in search results. While not a direct ranking factor, an accurate and inviting description significantly improves click-through rate from organic listings. AI answer engines and social platforms also use it as a trusted summary when generating previews, citations and shareable snippets.
Google Search Results Preview Test
Desktop version
https://hitechinstitute.in/Mobile Repairing Course | 9212577577 - HitechMobile Repairing Course - Hitech Best Institute for Mobile & Laptop Repairing Course. Get Live Training, 15+ Branches in India.1 Hour FREE Demo Class, Apply Now
Mobile version
https://hitechinstitute.in/Mobile Repairing Course | 9212577577 - HitechMobile Repairing Course - Hitech Best Institute for Mobile & Laptop Repairing Course. Get Live Training, 15+ Branches in India.1 Hour FREE Demo Class, Apply Now
A simulated preview of how the page may appear in Google search results, combining the title, URL, and meta description as Google typically renders them. Useful for spotting truncated text, weak phrasing, or missing elements before publishing, since the snippet directly influences whether searchers click through.
Social Media Meta Tags Test
89% of top 100 sites passed
This webpage is using social media meta tags.
Open Graph Meta Tags
og:titleHitech Institute - Best institute for Mobile & Laptop Courses
og:site_nameMobile Repairing Course
og:urlhttps://www.hitechinstitute.in
og:imagehttps://www.hitechinstitute.in/images/logo.webp
og:image:secure_urlhttps://www.hitechinstitute.in/images/logo.webp
og:image:typeimage/jpeg
og:descriptionHitech Institute is best institute in whole Asia and provides best training for Mobile & Laptop Repairing course
og:typewebsite
og:localeen_US
Twitter Card Meta Tags
twitter:cardsummary_large_image
twitter:site@Hi Tech Institute
twitter:titleHitech Mobile Repairing Institute | Laptop Repairing Course in Delhi
twitter:descriptionMobile Repairing Course - Hitech Best Institute for Mobile & Laptop Repairing Course. Get Live Training, 15+ Branches in India.1 Hour FREE Demo Class, Apply Now
twitter:imagehttps://www.hitechinstitute.in/images/logo.webp
Open Graph and Twitter Card meta tags tell social platforms and link unfurlers how to display a page when its URL is shared. Well-formed tags produce richer previews with the intended title, description, and image, which improves click-through on social channels. They also serve as a structured signal that AI crawlers and answer engines can use when summarizing the page.
Most Common Keywords Test
There is likely no optimal keyword density (search engine algorithms have evolved beyond keyword density metrics as a significant ranking factor). It can be useful, however, to note which keywords appear most often on your page and if they reflect the intended topic of your page. More importantly, the keywords on your page should appear within natural sounding and grammatically correct copy.
31repairing
26course
20institute
18mobile
17tech
A frequency analysis of the most repeated words and phrases in the page's visible content. Useful for getting a quick sense of which topics search engines are likely to associate with the page, and for spotting cases where the actual content drifts from the intended subject.
Keywords Usage Test
48% of top 100 sites passed
The most common keywords of this webpage are distributed well across the important HTML tags. This helps search engines to properly identify the topic of this webpage.
Keyword
Title tag
Meta description
Headings
repairing
course
institute
mobile
tech
Cross-checks whether the most frequently used keywords on the page also appear in the title and meta description. Alignment between body content and metadata helps search engines confirm the page's topic and reinforces relevance for those terms.
Keywords Cloud Test
admission
advace
advance
advanced
affordable
apply
assistance
bagh
batches
beadonpura
best
branches
brochure
card
career
chip
city
class
classes
course
courses
days
delhi
demand
demo
discount
download
email
emmc
engineer
enroll
experience
expert
experts
faculty
free
future
ghaffar
gives
hands
have
high
hitech
hitechinstitute
india
industry
info
institute
iphone
iphones
join
karol
know
knowledge
laptop
latest
learn
level
make
marg
market
material
mobile
offer
offers
online
opportunity
placement
practical
practically
prepared
price
providing
questions
read
regent
repair
repairing
saraswati
schedule
select
session
short
special
specialist
student
students
study
support
tech
techniques
technology
term
theoretical
today
tower
training
work
world
years
A visual word cloud of the page's content, with more frequent terms shown in larger text. Provides a quick at-a-glance view of which words dominate the page, helping confirm that the visible content reflects the intended topic.
Competitor Domains Test
Competitor Domains

Understand your competitors' SEO and backlink profile

Get related competitors and their domain authority score in relation to your domain.

Identifies up to ten domains that compete for similar organic search results, ranked by overall domain authority based on the volume and quality of their backlink profiles. Useful for benchmarking the competitive landscape and prioritizing which sites to study for content and link-building strategy.
Heading Tags Test
62% of top 100 sites passed
This webpage does not contain H1 headings! H1 headings help indicate the important topics of your page to search engines. While less important than good meta-titles and descriptions, H1 headings may still help define the topic of your page to search engines.
H2 tags
HI-TECH से एडवांस कोर्स करके 40K से 50K अपनी इनकम स्टार्ट करें अभी Admission लेने पर Special Discount और Free Toolkit अभी Admission लेने पर Free Tool Kit & Study Material अभी Admission लेने पर पाए 29 Online Career Courses FREE
Laptop Repairing Course
Here is a gallery with awards.

Heading Tags Test

How to pass this test?

The H1 and H2 tags give search engines and assistive technology a clean outline of the page's topics. Fixing this issue means adding a single descriptive H1 and a logical hierarchy of H2 sub-sections so the page's structure is unambiguous to both users and machines. AI answer engines also use heading structure to segment content into discrete passages they can quote or summarize, so a clean hierarchy directly helps the page get picked up in generative results.

Example

<body>
  <h1>Lightweight Running Shoes for Marathons</h1>
  <h2>What to look for in a marathon shoe</h2>
  <h2>Top picks for 2026</h2>
  <h2>How we tested</h2>
</body>

Where to make the change

  • Raw HTML: add a single <h1> near the top of the page's main content, then use <h2> for major sections and <h3> for subsections under those.
  • WordPress: in the block editor, set the post title's heading level to H1 (themes usually do this automatically) and use the Heading block for in-body H2 and H3 sections.
  • Shopify: the product or page title field renders as an H1 in most themes. Use the rich-text editor to add H2 and H3 headings inside the body.
  • Wix or Squarespace: use the heading style picker in the block editor to assign H1, H2, and H3 levels rather than just changing font size.

Common causes and how to resolve them

  • No H1 on the page: add a single <h1> that names the page's primary topic. Many themes either skip the H1 or render the site logo as one.
  • Multiple H1s: while modern HTML allows multiple H1s, most SEO tools still flag them. Pick the most important one and demote the others to H2.
  • Headings used for visual styling only: bold or large text styled to look like a heading does not help search engines or screen readers. Use the actual heading tag and style it with CSS.
  • Hierarchy skips levels: jumping from H1 directly to H3 confuses assistive technology. Keep the order H1 then H2 then H3 without gaps.

Best practices

  • One H1 per page: reserve it for the page's main subject; treat it as the in-page equivalent of the title.
  • Make headings descriptive: each heading should make sense out of context. "How we tested" is better than "Methodology" alone if the page is a product review.
  • Include keywords naturally: H1 and H2 are mid-strength ranking signals. Use the focus keyword in the H1 and supporting terms in H2s when it reads naturally.
  • Outline the page from headings alone: if you can read just the H1 and H2s and understand what the page is about, the structure is doing its job.
Inspects the page for H1 and H2 heading tags and reports their structure. Headings give both users and search engines a clear outline of the page's topics, with the H1 acting as the primary subject and H2s framing major sections. A clean heading hierarchy also helps AI answer engines segment the content into discrete passages they can quote or summarize.
Robots.txt Test
99% of top 100 sites passed
This website lacks a "robots.txt" file. This file can protect private content from appearing online, save bandwidth, and lower load time on your server. A missing "robots.txt" file also generates additional errors in your apache log whenever robots request one. Read more about the robots.txt file, and how to create one for your site.

Robots.txt Test

How to pass this test?

The robots.txt file is the first resource most crawlers request and tells them which paths on your site they may or may not access. Fixing this issue means publishing a valid robots.txt at the site root so search engines, training crawlers, and answer-engine bots all have an explicit policy to follow. Without it, every crawler defaults to its own behavior, which can over-expose private sections or waste crawl budget on low-value URLs.

Example

User-agent: *
Disallow: /admin/
Disallow: /cart
Allow: /

Sitemap: https://example.com/sitemap.xml

Where to make the change

  • Raw HTML or static site: create a plain text file named robots.txt and upload it to the document root so it is served at https://example.com/robots.txt.
  • WordPress: WordPress generates a virtual robots.txt by default. Override it with a physical file in the site root, or use your SEO plugin's robots.txt editor.
  • Shopify: Shopify auto-generates robots.txt and exposes a robots.txt.liquid template you can edit from the theme code editor to add or remove rules.
  • Wix or Squarespace: both platforms generate robots.txt automatically and offer limited overrides through the SEO settings panel.
  • Headless or framework sites: add robots.txt to the project's public or static directory so it ships with the build.

Common causes and how to resolve them

  • File is missing entirely: create one. Even an empty file with User-agent: * and no rules is preferable to a 404.
  • File returns a 5xx error: some crawlers stop crawling the entire site when robots.txt is unreachable. Investigate server or CDN issues that block the path.
  • Accidentally blocking the whole site: a stray Disallow: / under User-agent: * hides every URL from search. Audit the file before deploying changes from staging.
  • Wrong location: robots.txt must sit at the site root, not in a subdirectory. Crawlers do not look elsewhere.

Best practices

  • Reference the sitemap: add a Sitemap: line so any crawler that fetches robots.txt also discovers your XML sitemap.
  • Keep it simple: a short, well-commented file is easier to audit than a sprawling one full of legacy rules. Remove directives whose original purpose is no longer relevant.
  • Do not rely on robots.txt for security: the file is public, so listing private paths in it advertises them. Block sensitive paths with authentication, not just Disallow.
  • Manage AI crawlers explicitly: if you want to allow or block bots like GPTBot, ClaudeBot, or PerplexityBot, add named User-agent sections for each. Defaulting to allow keeps your content eligible for citation in AI answer engines.
Verifies whether the site exposes a robots.txt file at the root domain. This file is the first resource most crawlers request, telling search engines and other bots which paths they may or may not access. It is also the standard mechanism for allowing or blocking modern AI crawlers used by training pipelines and answer engines.
Sitemap Test
83% of top 100 sites passed
This website lacks a sitemap file! Sitemaps can help robots index your content more thoroughly and quickly. Read more on Google's guidelines for implementing the sitemap protocol.

Sitemap Test

How to pass this test?

An XML sitemap gives search engines and AI crawlers an explicit, machine-readable list of the URLs you want indexed, along with metadata such as last-modified dates. Fixing this issue means generating a valid sitemap, publishing it at a stable URL, and pointing crawlers to it via robots.txt and Search Console. This is especially important for large sites, sites with weak internal linking, or sites where new content needs to be discovered quickly.

Example

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com/</loc>
    <lastmod>2026-04-15</lastmod>
  </url>
  <url>
    <loc>https://example.com/blog/getting-started</loc>
    <lastmod>2026-03-22</lastmod>
  </url>
</urlset>

Where to make the change

  • Raw HTML or static site: generate the XML at build time and publish it at /sitemap.xml. Many static-site generators have a built-in sitemap option.
  • WordPress: a dedicated SEO plugin will generate and update the sitemap automatically, typically at /sitemap_index.xml.
  • Shopify: Shopify generates /sitemap.xml automatically and updates it as products and collections change.
  • Wix or Squarespace: both platforms generate the sitemap automatically and serve it at the standard root path.
  • Headless or framework sites: use the framework's built-in sitemap module (for example next-sitemap for Next.js or the @astrojs/sitemap integration) so the file is regenerated on every build.

Common causes and how to resolve them

  • No sitemap published: generate one and publish it at the site root. Reference it from robots.txt with a Sitemap: line.
  • Sitemap lists URLs that 404 or redirect: stale entries waste crawl budget and trigger Search Console warnings. Regenerate the sitemap from current published URLs only.
  • Mixed canonical and non-canonical URLs: the sitemap should list canonical URLs only. Listing both http and https, or trailing-slash variants, splits crawl signals.
  • Sitemap exceeds size limits: a single sitemap may contain at most 50,000 URLs and 50 MB uncompressed. Split larger sites into multiple sitemaps and reference them from a sitemap index file.

Best practices

  • Submit to Search Console: add the sitemap URL in Google Search Console (and Bing Webmaster Tools) so the platform tracks coverage and surfaces errors.
  • Keep lastmod accurate: Google uses lastmod as a hint when prioritizing crawls. Update it whenever the page content meaningfully changes; do not bump it on every build.
  • Exclude noindex and disallowed URLs: the sitemap should describe what you want indexed. Listing pages that are blocked from crawling sends mixed signals.
  • Use sitemap index files for multi-sitemap setups: a sitemap index aggregates child sitemaps (for example one per content type) and is the single URL you submit to search engines.
Looks for an XML sitemap on the site and reports whether one is published. Sitemaps give search engines an explicit, machine-readable list of the URLs you want crawled, along with metadata such as last-modified dates, which speeds up discovery of new and updated pages. They are especially useful for large sites or those with weak internal linking.
Image Alt Test
78% of top 100 sites passed
This webpage is using "img" tags with empty or missing "alt" attribute!

Image Alt Test

How to pass this test?

Alt attributes provide a text alternative for images, used by screen readers when a user cannot see the image and by search engines and multimodal AI models to understand what the image depicts. Fixing this issue means writing concise, descriptive alt text for every meaningful image on the page, and using empty alt for purely decorative images so assistive technology can skip them. The same alt text helps multimodal LLMs and image search tools surface and cite your visuals.

Example

<img src="/images/marathon-shoes.jpg"
     alt="Side view of a lightweight neon-green marathon running shoe">

<img src="/images/divider.svg" alt="">

Where to make the change

  • Raw HTML: add the alt attribute to every <img> tag. For decorative images, use alt="" so screen readers skip them.
  • WordPress: the media library has an Alt text field on every uploaded image. Fill it once and the value is reused everywhere the image is inserted.
  • Shopify: in the product or page editor, click an image and use the Edit alt text option. Theme code that renders product images should pull image.alt.
  • Wix or Squarespace: click the image in the editor and use the Alt text or Image description field in the side panel.
  • Headless or framework sites: require an alt prop on every image component and lint for missing values during build.

Common causes and how to resolve them

  • Attribute missing: add alt="" at minimum so the page validates. Replace with descriptive text on any image that conveys information.
  • Alt text is the filename: "IMG_4837.jpg" tells the user nothing. Replace with a description of what is in the image.
  • Alt text duplicates the visible caption: screen readers will read both, doubling the user's listening time. Differentiate the alt from the caption or empty the alt.
  • Decorative images get descriptive alt text: background patterns and dividers should use alt="", otherwise screen readers narrate noise.
  • Bulk imports left alt blank: a one-off audit of the media library or a CMS-side script can fill missing alt values from product names, captions, or asset descriptions.

Best practices

  • Describe the function, not just the appearance: for a chart, describe what the chart shows. For a button image, describe what the button does.
  • Keep it concise: aim for under 125 characters. Screen readers do not pause mid-sentence, so long alt text is exhausting to listen to.
  • Skip "image of" or "picture of": the screen reader already announces it as an image.
  • Include the focus keyword when natural: alt text is a minor on-page signal, but stuffing keywords in unnatural alt text harms both accessibility and ranking.
Inspects whether images on the page include descriptive alt attributes. Alt text provides accessibility for screen readers, a fallback when images fail to load, and a textual signal that helps search engines understand image content. It also improves how AI crawlers and image search tools interpret and surface the visuals.
Responsive Image Test
29% of top 100 sites passed
Not all images in this webpage are properly sized! This webpage is serving images that are larger than needed for the size of the user's viewport.

Responsive Image Test

How to pass this test?

This test fails when one or more images on the page are served at dimensions significantly larger than the size at which the browser actually renders them. Fixing this issue means resizing the source files (or serving responsive variants) so the bytes downloaded match the pixels actually displayed. The result is faster page loads, lower data usage, and better Core Web Vitals scores.

Example

<img
  src="/images/hero-800.jpg"
  srcset="/images/hero-400.jpg 400w,
          /images/hero-800.jpg 800w,
          /images/hero-1600.jpg 1600w"
  sizes="(max-width: 640px) 100vw, 800px"
  alt="Marathon runners at sunrise"
  width="800" height="450">

Where to make the change

  • Raw HTML: use srcset and sizes to let the browser pick the right variant for the user's viewport. Always include intrinsic width and height attributes.
  • WordPress: WordPress generates multiple image sizes automatically. Use the the_post_thumbnail() helper or the block editor's image block, both of which emit responsive srcset markup.
  • Shopify: use the image_url Liquid filter with size parameters (for example {{ image | image_url: width: 800 }}) and pair with image_tag to emit a responsive image.
  • Wix or Squarespace: both platforms generate responsive variants automatically; this issue is typically caused by uploading a deliberately oversized image.
  • Headless or framework sites: use the framework's image component (for example next/image or astro:assets), which generates responsive variants and lazy-loads off-screen images.

Common causes and how to resolve them

  • Original camera or stock-photo file uploaded as-is: a 6000-pixel-wide JPEG rendered in a 400-pixel column wastes most of the bytes. Resize the source or generate responsive variants.
  • No srcset: the browser has no choice but to use the single source. Add multiple variants so mobile users get smaller files.
  • Hero images sized for ultra-wide displays: if your largest layout is 1600 pixels, do not ship a 4000-pixel original.
  • Background images set in CSS without responsive sources: use the image-set() CSS function or media queries to swap in different image files at different breakpoints.

Best practices

  • Generate variants at common widths: 400, 800, 1200, and 1600 pixels covers most viewports cleanly.
  • Always set width and height: intrinsic dimensions let the browser reserve space and avoid layout shift, helping CLS.
  • Lazy-load off-screen images: add loading="lazy" to images below the fold so the browser only downloads them when needed.
  • Pair with modern formats: resizing alone is good; resizing and serving WebP or AVIF compounds the savings.
Compares the natural dimensions of each image to the size at which it is actually rendered in the user's viewport. Serving images significantly larger than needed wastes bandwidth, slows page load, and forces the browser to scale assets unnecessarily, all of which hurt performance and user experience.
Image Aspect Ratio Test
75% of top 100 sites passed
All image display dimensions match the natural aspect ratio.
Compares each image's natural aspect ratio against the ratio at which it is displayed on the page. Significant mismatches result in stretched or squashed visuals that look unprofessional and degrade the user experience.
Deprecated HTML Tags Test
94% of top 100 sites passed
This webpage does not use HTML deprecated tags.
Scans the markup for HTML elements that are no longer part of the modern HTML specification. Deprecated tags may still render today, but browsers can drop support at any time, leading to broken layouts and rendering inconsistencies. Replacing them with current standards keeps the page resilient and easier to maintain.
Google Analytics Test
72% of top 100 sites passed
This webpage is using Google Analytics.
Detects whether the page is instrumented with Google Analytics tracking code. Analytics is not an SEO ranking factor, but having reliable traffic and behavior data is essential for measuring the impact of SEO work and identifying opportunities for improvement.
Favicon Test
100% of top 100 sites passed
favicon
This website appears to have a favicon.
Verifies whether the site declares a favicon and that it loads correctly. Favicons appear in browser tabs, bookmarks, and increasingly in search engine result pages, where they reinforce brand recognition and make a listing easier to spot at a glance.
JS Error Test
83% of top 100 sites passed
We've found JavaScript errors on this webpage!

JS Error Test

How to pass this test?

This test fails when the browser encounters JavaScript runtime errors as the page loads. Unhandled errors can break interactive features, leave content unrendered, and signal poor code quality, all of which hurt the user experience that search engines factor into rankings. Fixing this issue means identifying the offending script, reproducing the error in DevTools, and shipping a patch that handles the failure cleanly.

Where to make the change

  • Open browser DevTools: the Console tab lists every error with the file, line number, and stack trace. Reproduce the issue locally and use sourcemaps to map back to the original code.
  • Application code: wrap risky operations in try / catch, validate external data before using it, and provide fallbacks when DOM elements or APIs are missing.
  • Third-party scripts: check whether the error originates in an analytics, advertising, or chat-widget script. If yes, contact the vendor or load the script with defer so it does not block the rest of the page.

Common causes and how to resolve them

  • Calling a method on null or undefined: guard with optional chaining (?.) or check the value exists before calling.
  • Race condition between the DOM and the script: wait for DOMContentLoaded or place the script tag at the end of <body> with defer.
  • Missing or 404 script file: a typo in the src attribute or a deleted asset triggers a load error. Fix the path or remove the tag.
  • Unsupported syntax in older browsers: if you support legacy browsers, transpile modern JavaScript with a tool such as Babel and serve appropriate polyfills.
  • CORS error blocking a fetch: the API must include the correct Access-Control-Allow-Origin header. Either configure the API or proxy the request through your own backend.

Best practices

  • Add error monitoring: a service such as Sentry, Bugsnag, or Datadog RUM captures errors from real users and groups them by frequency, so you fix what hurts most first.
  • Fail loudly in development, gracefully in production: log unexpected errors but never let them break the rendered page. Show a fallback UI instead of a blank screen.
  • Treat errors as bugs in the build: add lint rules and unit tests for the most common error paths so they cannot ship again.
  • Defer non-critical scripts: using defer or async on third-party scripts limits the blast radius when one of them throws.
Inspects the page for JavaScript runtime errors that occur as it loads. Unhandled errors can break interactive features, leave content unrendered, and signal poor code quality, all of which hurt the user experience that search engines factor into rankings.
Console Errors Test
27% of top 100 sites passed
This webpage has some errors caught by the Chrome DevTools Console!

Console Errors Test

How to pass this test?

Console errors include any unhandled JavaScript exceptions, network request failures, security warnings, or deprecation notices the browser emits while loading the page. Fixing this issue means resolving the underlying problem each error reports rather than suppressing the message. Even errors that do not visibly break the page can degrade performance, leak data, or trip Core Web Vitals.

Where to make the change

  • Open DevTools, Console tab: expand each entry to see the file, line, and stack trace. Right-click an entry to filter, save, or jump to the source.
  • Application code: patch the offending script (see js-errors). For network failures, fix the failing endpoint or remove the stale request.
  • Third-party tags: if the error originates in an analytics, ad, or widget script, update the snippet, switch to the vendor's current loader, or remove unused tags.

Common causes and how to resolve them

  • JavaScript runtime errors: see the JS Error Test fix; the same approach applies.
  • Failed network requests (404 or 5xx): remove the dead request or fix the endpoint. Stale tracking pixels and removed assets are common culprits.
  • Mixed content warnings: the page is HTTPS but loads an HTTP resource. Update the resource URL to https://.
  • CORS or CSP violations: tighten or expand the policy as appropriate. CSP errors usually require allowlisting the offending origin in the response header.
  • Deprecation warnings: update the call site to use the recommended API. These do not break the page today but will when the deprecation cycle completes.

Best practices

  • Treat the console as a build artifact: a clean console is a sign of a healthy page. Aim for zero errors and zero warnings on production routes.
  • Use error monitoring in production: real users hit edge cases your local environment will never reproduce. A monitoring service surfaces them with frequency data.
  • Defer or remove unused third-party scripts: every removed script is one fewer source of console noise.
Reviews the browser console for warnings and errors emitted while the page loads. Console messages often expose underlying issues such as failed network requests, deprecated APIs, or security warnings that can quietly degrade the experience even when the page appears to work.
Charset Declaration Test
96% of top 100 sites passed
This webpage has a meta charset tag but is not fully contained in the first 1024 bytes of the HTML document! The element containing the character encoding declaration must be serialized completely within the first 1024 bytes of the document, otherwise it can significantly affect load performance.

Charset Declaration Test

How to pass this test?

The character encoding declaration tells the browser how to interpret the bytes in the HTML response. Without it, browsers must guess, which can produce garbled symbols, broken accented characters, and inconsistent rendering across devices. Fixing this issue means declaring UTF-8 as the very first element inside the page <head>.

Example

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Example page</title>
</head>

Where to make the change

  • Raw HTML: add <meta charset="UTF-8"> as the first child of <head>, before the title and any other meta tags.
  • WordPress, Shopify, Wix, Squarespace: all major CMS platforms emit the charset declaration automatically. If the test still fails, check for a custom theme that overrides the default head.
  • Headless or framework sites: verify the base layout file includes the meta charset; most starter templates do.

Common causes and how to resolve them

  • Tag is missing entirely: add <meta charset="UTF-8"> at the very top of the head.
  • Tag is present but appears too late in the head: the declaration must be within the first 1024 bytes of the HTML, otherwise the browser may have already started decoding incorrectly. Move the tag above any large inline content.
  • Conflicting Content-Type header: if the HTTP response declares a different charset, the header wins. Update the server configuration so both agree on UTF-8.
  • Legacy non-UTF-8 encoding: if the document was authored in ISO-8859-1 or Windows-1252, convert the file to UTF-8 in your editor; otherwise re-saving with the new declaration will mangle existing characters.

Best practices

  • Always use UTF-8: it covers every script in active use and is the de-facto standard on the modern web.
  • Declare the language too: a lang attribute on <html> helps screen readers, translation tools, and search engines correctly classify the content.
  • Configure the server: the response header (Content-Type: text/html; charset=UTF-8) and the meta tag should agree. The header is the authoritative source.
Checks whether the page declares a character encoding such as UTF-8. Without an explicit charset declaration, browsers must guess the encoding, which can lead to garbled symbols, broken accented characters, and inconsistent rendering across devices. UTF-8 is the modern standard recommended by Google.

Speed optimizations

Score:54
Failed:7
Warnings:2
Passed:11
HTML Page Size Test
23% of top 100 sites passed
The size of this webpage's HTML is 19.46 Kb and is under the average webpage's HTML size of 33 Kb. Faster loading websites result in a better user experience, higher conversion rates, and generally better search engine rankings.
Measures the size of the raw HTML document, excluding images and external CSS or JavaScript. Bloated HTML increases time to first byte and parsing time, slowing down rendering on mobile networks and lower-powered devices. Trimming inline styles, redundant markup, and oversized inline data keeps initial load fast.
DOM Size Test
56% of top 100 sites passed
The Document Object Model (DOM) of this webpage has 812 nodes which is less than the recommended value of 1,500 nodes.
Measures the size and depth of the page's Document Object Model, the tree of nodes the browser builds from the HTML. Very large DOMs increase memory usage, lengthen style and layout calculations, and slow down rendering, particularly on mobile devices. Keeping the DOM lean improves both load time and runtime responsiveness.
HTML Compression/GZIP Test
99% of top 100 sites passed
This webpage is successfully compressed using gzip compression on your code. The HTML code is compressed from 102.47 Kb to 19.46 Kb (81% size savings). This helps ensure a faster loading webpage and improved user experience.
Verifies whether the server delivers the HTML using a compression algorithm such as Gzip or Brotli. Compressed responses dramatically reduce transfer size with negligible decompression cost, translating directly into faster page loads, especially on slower connections.
Site Loading Speed Test
71% of top 100 sites passed
The loading time of this webpage (measured from N. Virginia, US) is around 11.11 seconds and is greater than the average loading speed which is 5 seconds!
Related Keywords

Accurate historical loading speed monitor and reports

Get detailed and accurate loading speed reports for your websites and see how your pages are being loaded over time.

Measures the overall time required to load the page in the browser. Page speed is a confirmed Google ranking factor and a strong driver of bounce rate, with slower pages losing a meaningful share of users before they even see the content. Faster pages also tend to convert better, making this a key metric for both SEO and revenue.
JS Execution Time Test
53% of top 100 sites passed
The JavaScript code used by this webpage is executed in less than 2 seconds.
Reports the total time the browser spends parsing, compiling, and executing JavaScript while the page loads. Heavy JavaScript work blocks the main thread and is the primary cause of poor Interaction to Next Paint, the Core Web Vital that replaced First Input Delay in 2024 and that Google uses as part of its ranking algorithms. Reducing bundle size and deferring non-critical scripts directly improves perceived performance.
Page Objects Test
7% of top 100 sites passed
This webpage is using more than 20 http requests, which can slow down page loading and negatively impact user experience!
Content size by content type
Content type
Percent
Size
image
46.2 %
1.31 Mb
javascript
38.8 %
1.10 Mb
css
10.3 %
297.95 Kb
font
3.6 %
105.92 Kb
html
1.0 %
28.67 Kb
other
0.1 %
1.69 Kb
TOTAL
100%
2.84 Mb
Requests by content type
Content type
Percent
Requests
image
46.8 %
52
javascript
28.8 %
32
css
9.9 %
11
other
6.3 %
7
html
5.4 %
6
font
2.7 %
3
TOTAL
100%
111
Content size by domain
Domain
Percent
Size
hitechinstitute.in
62.8 %
1.78 Mb
googletagmanager.com
24.6 %
714.61 Kb
connect.facebook.net
6.1 %
177.73 Kb
maxcdn.bootstrapcdn.com
3.0 %
85.74 Kb
sc-static.net
0.9 %
24.86 Kb
googleadservices.com
0.8 %
23.62 Kb
google-analytics.com
0.7 %
20.91 Kb
sc-events-sdk.sharechat.com
0.4 %
12.17 Kb
cdnjs.cloudflare.com
0.3 %
9.22 Kb
googleads.g.doubleclick.net
0.3 %
8.41 Kb
Other
0.1 %
3.08 Kb
TOTAL
100%
2.84 Mb
Requests by domain
Domain
Percent
Requests
hitechinstitute.in
70.3 %
78
googletagmanager.com
5.4 %
6
tr.snapchat.com
4.5 %
5
maxcdn.bootstrapcdn.com
2.7 %
3
connect.facebook.net
2.7 %
3
googleads.g.doubleclick.net
2.7 %
3
google.com
2.7 %
3
cdnjs.cloudflare.com
1.8 %
2
googleadservices.com
0.9 %
1
sc-static.net
0.9 %
1
Other
5.4 %
6
TOTAL
100%
111
Verifies that every resource the page requests, including images, scripts, stylesheets, and fonts, can be successfully retrieved. Broken or unreachable assets can leave the page rendered incorrectly, trigger console errors, and damage both user experience and how search engines perceive page quality.
CDN Usage Test
95% of top 100 sites passed
This webpage is not serving all resources (images, javascript and css) from CDNs!

CDN Usage Test

How to pass this test?

A Content Delivery Network serves static assets from edge locations close to the user, reducing latency, improving cache hit rates, and offloading traffic from the origin server. Fixing this issue means routing your images, JavaScript, CSS, and fonts through a CDN so visitors anywhere in the world get fast, consistent delivery.

Where to make the change

  • Cloud platforms: Cloudflare, Fastly, AWS CloudFront, Bunny.net, and similar providers offer free or low-cost CDN tiers. Sign up, point your domain through the CDN, and enable caching for static asset paths.
  • WordPress: use a CDN integration plugin or sign up directly with Cloudflare and update the site's nameservers.
  • Shopify: Shopify serves storefront assets through its own CDN automatically; the failure usually points at custom assets uploaded outside the platform.
  • Headless or framework sites: deploying to Vercel, Netlify, or Cloudflare Pages puts the entire site behind a global CDN by default.

Common causes and how to resolve them

  • No CDN at all: add one. Even a free Cloudflare account in front of an existing host produces measurable speed gains.
  • CDN configured but bypassed for some assets: ensure all img, script, link, and font URLs use the CDN hostname rather than the origin.
  • Cache headers prevent caching: long-lived assets need cache-control headers like public, max-age=31536000, immutable. Without them, the CDN cannot cache effectively.
  • Origin-only third-party scripts: many vendors already serve their scripts via their own CDN. Use the URL the vendor provides rather than self-hosting.

Best practices

  • Use a versioned asset path: filenames like app.a3f9.css let you set far-future cache headers without ever serving stale files. Update the filename when content changes.
  • Enable Brotli at the edge: most CDNs can compress responses on the fly, including text formats.
  • Pre-warm caches for new launches: after a major release, request key URLs through every region (or use the CDN's purge-and-prefetch tools) so users do not hit cold caches.
Detects whether static assets such as images, JavaScript, and CSS are delivered through a Content Delivery Network. CDNs serve files from edge locations close to the user, reducing latency, improving cache hit rates, and offloading traffic from the origin server. The result is faster, more consistent page performance worldwide.
Modern Image Format Test
43% of top 100 sites passed
This webpage is not serving images in a modern format! Image formats like JPEG 2000, JPEG XR, and WebP often provide better compression than PNG or JPEG, which means faster downloads and less data consumption.

Modern Image Format Test

How to pass this test?

This test fails when images are served in legacy formats such as JPEG and PNG instead of modern alternatives like WebP or AVIF. Modern formats compress significantly better at equivalent visual quality, which means smaller transfers, faster page loads, and lower data usage for visitors on metered connections. Fixing this issue means generating modern variants and serving them to browsers that support them.

Example

<picture>
  <source srcset="/images/hero.avif" type="image/avif">
  <source srcset="/images/hero.webp" type="image/webp">
  <img src="/images/hero.jpg" alt="Marathon runners at sunrise" width="1600" height="900">
</picture>

Where to make the change

  • Raw HTML: use the <picture> element with multiple <source> entries so the browser picks the best supported format.
  • WordPress: WordPress 6.x and later supports WebP natively. Use a media optimization plugin to convert existing JPEGs and PNGs and serve modern formats automatically.
  • Shopify: Shopify's image CDN can serve WebP automatically; using the image_url filter with format parameter or the image_tag helper handles negotiation.
  • Wix or Squarespace: both platforms convert and serve WebP automatically when supported by the visitor's browser.
  • Headless or framework sites: components like next/image and astro:assets generate AVIF and WebP variants at build time and serve the best format per request.

Common causes and how to resolve them

  • Only legacy formats published: add a build step or image CDN that generates WebP and AVIF alongside the original.
  • Single-format <img> tag: wrap the image in <picture> with <source> entries for AVIF and WebP, falling back to the JPEG.
  • Image CDN not negotiating format: enable automatic format conversion or pass a format=auto query parameter (depends on provider).
  • SVG used where a raster image would be smaller (or vice versa): illustrations and icons should be SVG; photos should be raster in a modern format. Mixing them up wastes bytes.

Best practices

  • AVIF first, WebP fallback, JPEG last: AVIF compresses best, WebP is widely supported, JPEG remains the universal fallback.
  • Match quality to use case: hero images can use higher quality settings; thumbnails can drop quality without visible loss.
  • Use an image CDN: services like Cloudflare Images, Cloudinary, or Imgix handle resizing, format conversion, and caching in one step.
Identifies images served in legacy formats such as JPEG and PNG instead of modern alternatives like WebP or AVIF. Modern formats compress significantly better at equivalent visual quality, which means smaller transfers, faster page loads, and lower data usage for visitors on metered connections.
Image Metadata Test
72% of top 100 sites passed
This webpage is using images with large metadata (more than 16% of the image size)! Stripping out unnecessary metadata tags can improve not only the loading time but also the security and privacy of a webpage.

Image Metadata Test

How to pass this test?

This test fails when one or more images carry disproportionately large embedded metadata such as EXIF data, thumbnails, color profiles, geolocation, and camera information. This metadata is rarely useful on the web and adds bytes to every request without any rendering benefit. Fixing this issue means stripping the metadata as part of your image processing pipeline.

Where to make the change

  • Image build pipeline: use a tool such as ImageMagick (mogrify -strip image.jpg), jpegoptim --strip-all, or oxipng --strip all to remove metadata at build time.
  • WordPress: a media optimization plugin will strip metadata automatically on upload.
  • Shopify, Wix, Squarespace: the platforms strip most metadata server-side. Failures usually point to images served from external sources you control.
  • Image CDN: Cloudflare Images, Cloudinary, and Imgix strip non-essential metadata by default during transformation.

Common causes and how to resolve them

  • Original camera files uploaded as-is: camera files contain large EXIF blocks (lens, GPS, embedded JPEG previews). Strip during upload or build.
  • Color profile larger than the image: embed a small sRGB profile or strip the profile entirely if the image is meant for the web.
  • Stock photo metadata: stock images often carry copyright notices, IPTC blocks, and watermarks larger than the image data itself.
  • Geolocation in personal photos: beyond bytes, EXIF GPS can leak the photographer's location. Strip for privacy as well as performance.

Best practices

  • Strip metadata on upload: make it part of the asset pipeline so no human action is required.
  • Preserve only essentials: a small ICC color profile is occasionally worth keeping for accurate color rendering; everything else can usually go.
  • Verify with a quick check: tools like exiftool image.jpg show what is left after stripping, so you can confirm only what you want remains.
Flags images carrying disproportionately large embedded metadata such as EXIF data, thumbnails, color profiles, geolocation, and camera information. This metadata is rarely useful on the web and adds bytes to every request without any rendering benefit, making it an easy win for shrinking image payloads.
Image Caching Test
95% of top 100 sites passed
This website is using cache headers for images and the browsers will display these images from the cache.
Inspects whether image responses include caching headers that allow browsers to store them for repeat visits. With proper caching directives, returning visitors retrieve images from the local cache instead of refetching them, producing noticeably faster subsequent page loads.
JavaScript Caching Test
96% of top 100 sites passed
This webpage is using cache headers for all JavaScript resources.
Inspects whether external JavaScript files are served with caching headers that allow browsers to store and reuse them. Cached scripts skip the network on repeat visits, reducing load time and bandwidth for returning users without sacrificing the ability to push fresh code by versioning file URLs.
CSS Caching Test
98% of top 100 sites passed
This webpage is using cache headers for all CSS resources.
Inspects whether external CSS files are served with caching headers that allow browsers to store and reuse them. Cached stylesheets skip the network on repeat visits, reducing load time for returning users while still allowing updates through versioned filenames.
JavaScript Minification Test
98% of top 100 sites passed
All JavaScript files used by this webpage are minified.
Detects whether external JavaScript files are minified by stripping whitespace, comments, and shortening identifiers. Minified scripts are substantially smaller and faster to download and parse, which lowers page load time and improves Core Web Vitals scores.
CSS Minification Test
100% of top 100 sites passed
All CSS resources used by this webpage are minified.
Detects whether external CSS files are minified by removing whitespace, comments, and unused characters. Minification reduces stylesheet size with no functional change, leading to faster downloads and quicker first render.
Render Blocking Resources Test
15% of top 100 sites passed
This webpage is using render blocking resources! Eliminating render-blocking resources can help this webpage to load significantly faster and will improve the website experience for your visitors.

Render Blocking Resources Test

How to pass this test?

This test fails when JavaScript or CSS resources block the browser from rendering visible content. Each render-blocking file delays the first paint, and on slower networks the cumulative impact can be severe. Fixing this issue means inlining the truly critical CSS, deferring or asynchronously loading non-essential scripts, and removing unused code.

Example

<head>
  <!-- Inline only above-the-fold critical CSS -->
  <style>/* critical styles here */</style>

  <!-- Load full stylesheet asynchronously -->
  <link rel="preload" href="/styles/main.css" as="style"
        onload="this.onload=null;this.rel='stylesheet'">

  <!-- Defer non-critical scripts -->
  <script src="/scripts/app.js" defer></script>
</head>

Where to make the change

  • Application code or templates: identify the CSS and JavaScript needed for the initial render and load only those synchronously. Defer the rest.
  • Build pipeline: use a critical CSS extractor (such as critical or penthouse) to generate the above-the-fold styles automatically.
  • WordPress: performance plugins offer "delay JS execution" and "load CSS asynchronously" options that handle most of this without code changes.
  • Headless or framework sites: use the framework's preload and code-splitting hints to control what blocks rendering.

Common causes and how to resolve them

  • Single large stylesheet blocking render: inline critical CSS for the first viewport, load the full stylesheet asynchronously.
  • Synchronous third-party scripts in the head: add defer or async, or move them to the end of the body.
  • Web fonts blocking text rendering: add font-display: swap in @font-face rules so the fallback font shows immediately.
  • Render-blocking @import in CSS: replace with separate <link rel="stylesheet"> tags so the browser can fetch them in parallel.

Best practices

  • Use defer for scripts that need the DOM: they execute after parsing but before DOMContentLoaded.
  • Use async for fully independent scripts: they execute as soon as they download, in any order.
  • Preload the critical request chain: tell the browser early about fonts and key assets with <link rel="preload">.
  • Audit with Lighthouse: the Render-blocking resources audit lists every offending file with the estimated time saved by deferring it.
Identifies JavaScript and CSS resources that the browser must download and process before it can render visible content. Each render-blocking file delays the first paint, and on slower networks the cumulative impact can be severe. Inlining critical styles, deferring non-essential scripts, and removing unused code all help unblock the rendering path.
URL Redirects Test
97% of top 100 sites passed
This URL doesn't have any redirects (which could potentially cause site indexation issues and site loading delays).
Counts the number of HTTP redirects required for the URL to resolve to its final destination. Each hop adds latency and can dilute link equity, while long redirect chains sometimes confuse crawlers and indexing pipelines. Keeping redirects short and direct is a Google recommendation for both performance and SEO.
Time To First Byte Test
99% of top 100 sites passed
The Time To First Byte value of this webpage is 0.803 seconds. To provide a good user experience, Google recommends that sites should strive to have a TTFB of 0.8 seconds or less.
0.803 s
0.8 s
1.8 s

Time To First Byte Test

How to pass this test?

Time to First Byte (TTFB) measures the delay between the browser requesting the page and the first byte of the response arriving. TTFB reflects backend, network, and CDN performance and effectively sets the floor for every other loading metric, since rendering cannot begin until bytes start flowing. Fixing this issue usually means improving server response time, adding edge caching, or reducing redirect chains.

Where to make the change

  • Server and hosting: upgrade to a faster host plan, move to a region closer to your users, and enable HTTP/2 or HTTP/3.
  • CDN: putting the site behind a CDN dramatically reduces TTFB for users far from the origin server. Cache HTML responses at the edge whenever possible.
  • Application code: profile slow endpoints, cache expensive database queries and external API calls, and use streaming or partial responses.

Common causes and how to resolve them

  • Slow server processing: profile the slowest controllers or routes. Database queries, N+1 loops, and synchronous third-party API calls are typical culprits.
  • No edge caching: caching HTML at the CDN reduces TTFB to a single edge round trip. Use rules to bypass cache for logged-in users.
  • Long redirect chains: each hop adds latency before bytes flow. Collapse chains so the URL the user requests resolves to its final destination in one step.
  • Origin in a distant region: a US-only origin makes Asian users wait. Add edge regions or move the origin closer to the audience.
  • HTTP/1.1 or no keep-alive: upgrading to HTTP/2 or HTTP/3 reduces connection setup overhead.

Best practices

  • Target sub-800 millisecond TTFB at the 75th percentile: Google's recommended threshold for a "good" experience.
  • Cache aggressively: the cheapest server work is the work you never do. Static and semi-static pages should be served from cache.
  • Use HTTP/3 where supported: it eliminates head-of-line blocking and reduces handshake latency, especially on mobile networks.
  • Stream the response when possible: sending the head before the rest of the body lets the browser start fetching subresources earlier.
Measures Time to First Byte, the delay between the browser requesting the page and the first byte of the response arriving. TTFB reflects backend, network, and CDN performance and effectively sets the floor for every other loading metric, since rendering cannot begin until bytes start flowing. Sustained high TTFB usually points to slow server processing, missing edge caching, or inefficient redirects.
First Contentful Paint Test
90% of top 100 sites passed
The First Contentful Paint value of this webpage is 6.048 seconds. To provide a good user experience, Google recommends that sites should strive to have a First Contentful Paint value of 1.8 seconds or less.
6.048 s
1.8 s
3 s

First Contentful Paint Test

How to pass this test?

First Contentful Paint (FCP) measures the time from when the page starts loading to when any part of its content is rendered on the screen. FCP is the user's first visual confirmation that the page is loading, and faster values are strongly correlated with lower bounce rates and better Core Web Vitals scores. Fixing this issue means reducing time to first byte, eliminating render-blocking resources, and serving above-the-fold content without delay.

Where to make the change

  • Server and CDN: reduce TTFB so the browser receives bytes sooner. Edge caching for HTML produces dramatic FCP wins.
  • Application code or templates: inline the critical CSS for above-the-fold content and defer everything not needed for the first paint.
  • Build pipeline: ensure JavaScript bundles are split so the initial load only includes what is needed for first render.

Common causes and how to resolve them

  • Slow TTFB: address the underlying server, redirect, or hosting issue (see Time to First Byte fix).
  • Render-blocking CSS: inline the critical CSS for the first viewport, load the full stylesheet asynchronously.
  • Render-blocking JavaScript in the head: add defer or move scripts to the end of the body.
  • Web fonts delaying text rendering: add font-display: swap so a fallback font is shown immediately while the custom font loads.
  • Heavy hero image without prioritization: add fetchpriority="high" to the hero image and <link rel="preload"> for it in the head.

Best practices

  • Target sub-1.8 second FCP at the 75th percentile: Google's recommended threshold for a "good" experience.
  • Inline critical CSS: the styles needed for the first viewport should not require an extra network round trip.
  • Preload key resources: hero image, key fonts, and critical scripts benefit from explicit preload hints.
  • Defer non-critical work: analytics, chat widgets, and below-the-fold content can wait until after first paint.
Measures First Contentful Paint, the moment when the browser renders the first piece of visible content from the DOM, such as text, an image, or an SVG. FCP is the first signal to the user that the page is actually loading, and faster values are strongly correlated with lower bounce rates and better Core Web Vitals scores.
Largest Contentful Paint Test
77% of top 100 sites passed
The Largest Contentful Paint duration of this webpage is 6.05 seconds. To provide a good user experience, Google recommends that sites should strive to have Largest Contentful Paint of 2.5 seconds or less.
6.05 s
2.5 s
4 s
Largest Contentful Paint element within the viewport:
<img src="https://www.hitechinstitute.in/images/sliders/slid..." alt="Institute Banner" decoding="async" style="width: 100%;" loading="eager" fetchpriority="high">

Largest Contentful Paint Test

How to pass this test?

Largest Contentful Paint (LCP) measures when the largest visible element in the viewport, such as a hero image or main heading, finishes rendering. LCP is one of Google's Core Web Vitals and a direct ranking factor, used as a proxy for when the user perceives the page as effectively loaded. Fixing this issue means identifying the LCP element and ensuring it loads as early as possible.

Where to make the change

  • Identify the LCP element: open Chrome DevTools, run a Performance trace, and find the LCP marker. The element it points at is the one to optimize.
  • Application code or templates: preload the LCP image, give it fetchpriority="high", and ensure it is in the initial HTML rather than injected by JavaScript.
  • Server and CDN: reduce TTFB and ensure the LCP image is served from a fast, geographically close origin.

Common causes and how to resolve them

  • Hero image loaded lazily: remove loading="lazy" from the LCP image; it should load eagerly.
  • LCP image not preloaded: add <link rel="preload" as="image" href="/hero.jpg" fetchpriority="high"> in the head so the browser fetches it before parsing the rest of the document.
  • LCP image too large or in legacy format: resize to displayed dimensions and serve as WebP or AVIF.
  • Slow TTFB or render-blocking resources: address the underlying TTFB and render-blocking issues; LCP cannot be fast if the page itself is slow to start.
  • Client-side rendered hero content: server-render or pre-render the LCP element so it appears in the initial HTML.
  • Web fonts delaying LCP text: use font-display: swap so the LCP heading renders immediately in a fallback font.

Best practices

  • Target sub-2.5 second LCP at the 75th percentile: the official Core Web Vitals threshold for a "good" experience.
  • Preload the LCP image: the single highest-impact LCP optimization on most sites.
  • Use fetchpriority="high": tells the browser to prioritize the resource ahead of others.
  • Ship modern image formats: AVIF and WebP cut hero image bytes substantially, which directly lowers LCP.
Measures Largest Contentful Paint, the time at which the largest visible element in the viewport, such as a hero image or main heading, finishes rendering. LCP is one of Google's Core Web Vitals and a direct ranking factor, used as a proxy for when the user perceives the page as effectively loaded.
Cumulative Layout Shift Test
91% of top 100 sites passed
The CLS score of this webpage is 0.0046. To provide a good user experience, Google recommends that sites should strive to have a CLS score of 0.1 or less.
0.0046
0.1
0.25
DOM element which contributes the most to CLS score:
Text: ABOUT US COURSES ONLINE COURSES SUPPORT BRANCHES CAREER BLOG CONTACTS
Html: <div id="main-menu" class="main-nav zn_mega_wrapper">
Score: 0.0031
Measures Cumulative Layout Shift, the total amount that visible elements move around unexpectedly while the page loads. Layout shifts cause users to misclick and feel the page is unstable, and CLS is one of Google's Core Web Vitals and a direct ranking factor. Common causes include images without explicit dimensions, late-loading fonts, and aggressively injected overlays such as cookie consent banners.

Server and security

Score:45
Failed:4
Warnings:1
Passed:2
URL Canonicalization Test
93% of top 100 sites passed
https://hitechinstitute.in/ and https://www.hitechinstitute.in/ should resolve to the same URL, but currently do not.

URL Canonicalization Test

How to pass this test?

This test fails when different URL variants of the site (apex versus www, HTTP versus HTTPS, with or without trailing slash) do not all resolve consistently to a single canonical version. When the same content is reachable at multiple URLs, search engines may split ranking signals across the variants. Fixing this issue means picking one canonical form for the site and 301-redirecting every other variant to it. See the Google Search Central canonicalization guide for the full specification.

Where to make the change

  • Server configuration: add 301 redirects in your web server config (Nginx, Apache, IIS) or via _redirects on Netlify, vercel.json on Vercel, or Cloudflare Page Rules.
  • CDN: most CDNs offer redirect rules that fire before the origin is hit, which is the cheapest way to enforce canonicalization.
  • Application code: as a backstop, applications can detect the wrong host or scheme and emit a 301 redirect to the canonical URL.

Common causes and how to resolve them

  • Both apex and www serve the same content: pick one (most sites prefer apex today) and 301-redirect the other to it permanently.
  • HTTP and HTTPS both serve content: redirect all HTTP requests to HTTPS, then add HSTS so browsers stop trying HTTP at all.
  • Trailing slash inconsistency: pick one form (with or without) and redirect the other.
  • Uppercase or mixed-case URLs: redirect uppercase paths to their lowercase canonical form.
  • Index page accessible at multiple paths: for example /index.html, /index.php, and / all serving the same content. Redirect everything to /.

Best practices

  • Use 301 (permanent) redirects: they pass the strongest ranking signal and are cached aggressively by browsers.
  • Pair with <link rel="canonical">: the canonical tag is a backup signal for cases the redirect cannot cover (parameterized URLs, syndicated content).
  • Avoid chains: redirect directly to the final URL in one hop.
  • Update internal links to canonical URLs: linking to non-canonical variants triggers unnecessary redirects on every visit.
Detects whether different URL variants of the site, such as the apex domain and the www subdomain or HTTP and HTTPS, all resolve consistently to a single canonical version. When the same content is reachable at multiple URLs without proper redirects, search engines may split ranking signals across the variants and become unsure which one to index.
SSL Checker and HTTPS Test
100% of top 100 sites passed
This website is successfully using the HTTPS protocol, but the SSL Certificate will expire in less than a month! Having an up-to-date certificate is an important security practice to ensure that your website is safe and provides trust, and any communication between the user's browser and your website (such as passwords, credit cards, or forms) is encrypted and private.
The certificate is not used before the activation date.
The certificate will expire in less than a month!
The hostname "hitechinstitute.in" is correctly listed in the certificate.
The certificate should be trusted by all major web browsers.
The certificate was not revoked.
The certificate was signed with a secure hash.
Certificate Chain:
Server certificate
Common Name
hitechinstitute.in
Subject Alternative Names
hitechinstitute.in, www.hitechinstitute.in
Not Valid Before
Fri, September 19, 2025 at 12:00:00 AM UTC
Not Valid After
Sat, September 19, 2026 at 11:59:59 PM UTC
Signature Algorithm
sha256WithRsaEncryption
Issuer
Sectigo Public Server Authentication CA DV R36
Intermediate certificate
Common Name
Sectigo Public Server Authentication CA DV R36
Organization
Sectigo Limited
Location
GB
Not Valid Before
Mon, March 22, 2021 at 12:00:00 AM UTC
Not Valid After
Fri, March 21, 2036 at 11:59:59 PM UTC
Signature Algorithm
sha384WithRsaEncryption
Issuer
Sectigo Public Server Authentication Root R46
Root certificate
Common Name
Sectigo Public Server Authentication Root R46
Organization
Sectigo Limited
Location
GB
Not Valid Before
Mon, March 22, 2021 at 12:00:00 AM UTC
Not Valid After
Wed, March 21, 2046 at 11:59:59 PM UTC
Signature Algorithm
sha384WithRsaEncryption
Issuer
Sectigo Public Server Authentication Root R46
Verifies whether the site is served over HTTPS with a valid TLS certificate. HTTPS encrypts the connection between visitor and server, protecting credentials and other sensitive data in transit, and Google has used it as a positive ranking signal since 2014. Modern browsers also flag non-HTTPS pages as Not Secure, which damages user trust.
Mixed Content Test (HTTP over HTTPS)
100% of top 100 sites passed
This webpage does not use mixed content - both the initial HTML and all other resources are loaded over HTTPS.
Detects whether a page served over HTTPS is loading any sub-resources such as images, scripts, or stylesheets over insecure HTTP. Mixed content weakens the security guarantees of HTTPS, and modern browsers either block the resources outright or warn the user, often breaking the page in the process.
HTTP2 Test
99% of top 100 sites passed
This webpage is using the HTTP/2 protocol.
Verifies whether the page and its resources are delivered over HTTP/2 or newer, rather than the legacy HTTP/1.1 protocol. HTTP/2 introduces multiplexing, header compression, and prioritization, which together reduce latency and allow the browser to load many resources from the same origin far more efficiently.
HSTS Test
84% of top 100 sites passed
This webpage is not using the Strict-Transport-Security header! This is a security header that was created as a way to force the browser to use secure connections when a site is running over HTTPS.

HSTS Test

How to pass this test?

The Strict-Transport-Security (HSTS) response header tells browsers to access the site only over HTTPS, automatically upgrading future requests and refusing to fall back to HTTP. Fixing this issue means configuring the server to send the header on every HTTPS response.

Example

Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

Where to make the change

  • Server configuration: add the header in Nginx (add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;), Apache (Header always set Strict-Transport-Security ...), or your application's response middleware.
  • CDN: Cloudflare, Fastly, and CloudFront let you set HSTS at the edge so it applies regardless of origin configuration.
  • Cloud platforms: Netlify and Vercel allow HSTS via headers files (_headers on Netlify, vercel.json on Vercel).

Common causes and how to resolve them

  • Header not sent: add it in the server or CDN config. Confirm in DevTools, Network tab.
  • Header sent only on HTTP responses: HSTS is only honored over HTTPS, so the header must accompany the HTTPS response.
  • Short max-age: a max-age below a few months provides little protection. Bump to a year (31536000) once you are confident HTTPS is stable.
  • includeSubDomains breaking subdomains that lack HTTPS: only add this directive after every subdomain serves HTTPS. Otherwise users will lose access to the HTTP-only ones.

Best practices

  • Start with a short max-age, then ramp up: a one-week max-age lets you back out quickly if something breaks. Increase to a year once stable.
  • Add preload after testing: submit your domain to hstspreload.org so browsers ship with HSTS for your site baked in. Note that removing a preloaded site is slow.
  • Pair with HTTP-to-HTTPS redirects: HSTS only kicks in after a successful HTTPS visit. Until then, redirects do the work.
Checks whether the server sends a Strict-Transport-Security header instructing browsers to only access the site over HTTPS. HSTS protects users from protocol downgrade attacks and accidental exposure to insecure connections, and is a baseline requirement for any site handling sensitive data.
Plaintext Emails Test
97% of top 100 sites passed
We've found 1 email addresses in your page code! We advise you to protect email links in a way that hides them from the spam harvesters.

Plaintext Emails Test

How to pass this test?

This test fails when the page exposes one or more email addresses in plain text. Spam-harvesting bots scrape pages for plaintext addresses and add them to bulk mailing lists. Fixing this issue means obfuscating contact addresses, using a contact form, or rendering them via JavaScript so simple scrapers cannot read them.

Where to make the change

  • Application code or templates: replace plain contact@example.com text with one of the obfuscation techniques below.
  • WordPress: a contact form plugin handles email submissions without exposing the address. Some SEO and security plugins also offer email obfuscation.
  • Shopify, Wix, Squarespace: use the platform's built-in contact form blocks rather than displaying the email address directly.

Common causes and how to resolve them

  • Plain text address in a paragraph or footer: replace with a contact form, an obfuscated rendering (HTML entities, CSS reversal), or a JavaScript-built mailto link.
  • Mailto link with the address visible: the visible text is what bots read. Make the visible text a label like "Email us" while the href still works.
  • Address baked into images is fine for SEO but bad for accessibility: screen readers cannot read it. Pair an image with a contact form instead.

Best practices

  • Prefer contact forms: they reduce spam and make analytics easier.
  • Use HTML entity encoding: writing &#99;&#111;... for the address defeats the simplest scrapers, though sophisticated ones decode it.
  • Render via JavaScript: building the mailto link client-side blocks scrapers that only read static HTML.
  • Consider a Cloudflare-style email obfuscation: some CDNs automatically rewrite plaintext emails to obfuscated equivalents.
Scans the page for email addresses written in plain text. Spambots harvest such addresses to add them to bulk mailing lists, so obfuscating contact emails or replacing them with contact forms helps reduce inbox spam without hiding the address from legitimate visitors.

Mobile usability

Score:100
Failed:0
Warnings:0
Passed:3
Meta Viewport Test
92% of top 100 sites passed
This webpage is using a viewport meta tag.
<meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1" />
Checks whether the page declares a viewport meta tag that controls how the layout scales on mobile devices. Without it, mobile browsers render the page at a default desktop width and shrink it to fit, producing unreadable text and unusable touch targets. A correct viewport declaration is the foundation of responsive design.
Media Query Responsive Test
98% of top 100 sites passed
This webpage is using CSS media queries, which is the base for responsive design functionalities.
Detects whether the page's stylesheets use CSS media queries to adapt the layout to different screen sizes. Media queries are the primary mechanism for responsive design, allowing typography, spacing, and component arrangement to adjust gracefully from phones to large desktops. Because Google now indexes the web mobile-first, the responsive mobile layout is effectively the version search engines crawl, evaluate, and rank.
Mobile Snapshot Test
Mobile view
A rendered screenshot of how the page appears on a mobile device. Useful for visually confirming that responsive layouts work as intended and for spotting issues such as overflowing content, illegible text, or broken images that automated checks alone may miss.

Advanced SEO

Score:55
Failed:2
Warnings:1
Passed:6
Structured Data Test
66% of top 100 sites passed
This webpage is using structured data.
Inspects the page for structured data markup such as JSON-LD or Microdata that follows schema.org vocabularies. Structured data helps search engines understand entities and relationships on the page, often unlocking rich result features in SERPs such as star ratings, FAQs, recipes, and product cards. It is also a primary signal AI answer engines use to extract precise facts when generating responses.
Custom 404 Error Page Test
80% of top 100 sites passed
This website is not using a custom 404 error page! Default 404 error pages result in a poor experience - it can mislead users into thinking an entire site is down or broken, greatly increases the chance they leave the website entirely, and looks unprofessional. We recommend to have a custom 404 error page in order to improve the website's user experience by letting users know that only a specific page is missing/broken (and not the entire site), providing them helpful links, the opportunity to report bugs, and potentially track the source of broken links.

Custom 404 Error Page Test

How to pass this test?

This test fails when the site does not serve a branded, helpful page for missing URLs. A custom 404 keeps users on the site by offering navigation, search, and suggested links rather than dropping them at the browser's generic error screen. Fixing this issue means designing a 404 template, ensuring it returns the correct HTTP 404 status, and pointing your server at it.

Where to make the change

  • Server configuration: point your web server at a custom 404 page. In Nginx, use error_page 404 /404.html;. In Apache, use ErrorDocument 404 /404.html.
  • WordPress: create a 404.php template in your theme. WordPress invokes it automatically for missing URLs.
  • Shopify: edit the 404.liquid template in the theme code editor.
  • Wix or Squarespace: use the platform's built-in 404 page editor in site settings.
  • Headless or framework sites: Next.js uses not-found.js, Astro uses 404.astro, and similar frameworks all have a convention for the missing-route page.

Common causes and how to resolve them

  • No custom 404 at all: create one. The minimum is the site header, navigation, a clear "page not found" message, and links to popular sections.
  • 404 page returns HTTP 200: a "soft 404" confuses search engines. Verify the response status with DevTools or curl, and configure the server to return 404 for missing routes.
  • 404 page redirects to homepage: redirecting users to the homepage hides broken URLs from analytics and search engines. Show a real 404 instead.
  • Generic browser error visible: the server is not invoking the custom template. Check the configuration directive.

Best practices

  • Keep the site chrome: show the header, footer, and navigation so users do not feel lost.
  • Offer next steps: a search box, popular links, or category navigation help users get back on track.
  • Track 404s: log missing-URL hits in analytics so you can spot broken inbound links worth fixing or redirecting.
  • Be clear about the error: "Sorry, that page does not exist" is better than vague messaging that confuses users.
Detects whether the site serves a branded, helpful page when a requested URL is not found, instead of the browser's generic error screen. A custom 404 keeps users on the site by offering navigation, search, or suggested links, which reduces frustration and protects engagement metrics that influence both UX perception and indirect SEO outcomes.
Noindex Tag Test
99% of top 100 sites passed
This webpage does not use the noindex meta tag. This means that it can be indexed by search engines.
Detects whether the page is being excluded from search engine indexes via a noindex directive in the robots meta tag or X-Robots-Tag HTTP header. A noindex on the wrong page is one of the most common ways important content silently disappears from search results, so verifying its absence on pages meant to rank is critical.
Canonical Tag Test
93% of top 100 sites passed
This webpage is using the canonical link tag. This tag specifies that the URL: https://www.hitechinstitute.in should be the preferred version of this page. The canonical tag can be useful when there are similar versions of the same content on several URLs (e.g., such as e-commerce sites where URL modifiers like sort parameters are appended to a product page's URL). Please ensure that this specification is correct, as canonical tags are often hard-coded and may not always reflect the latest changes in a site's URL structure.
<link href="https://www.hitechinstitute.in" rel="canonical"/>

Canonical Tag Test

How to pass this test?

The canonical link tag declares the preferred URL for a page when the same or similar content is reachable at multiple URLs. Fixing this issue means adding a <link rel="canonical"> tag to every page that points at the URL you want indexed, which consolidates ranking signals onto the canonical version and helps AI crawlers identify the source of truth when citing the page. See the Google canonicalization guide for the full specification.

Example

<head>
  <link rel="canonical" href="https://example.com/shoes/marathon">
</head>

Where to make the change

  • Raw HTML: add a single <link rel="canonical"> inside the <head>. The href must be an absolute URL.
  • WordPress: a dedicated SEO plugin emits canonical tags automatically. Override per-post when the auto-derived URL is wrong.
  • Shopify: the default Liquid layout emits canonical tags from {{ canonical_url }}. Confirm your custom theme has not removed them.
  • Wix or Squarespace: both platforms emit canonical tags automatically; per-page override fields are available in SEO settings.
  • Headless or framework sites: emit the canonical tag from the framework's metadata API alongside title and description.

Common causes and how to resolve them

  • No canonical tag at all: add one pointing at the page's preferred URL.
  • Canonical points to the wrong page: a templating bug can point every page's canonical at the homepage. Verify the value matches the current URL on a sample of pages.
  • Canonical uses a relative URL: always use the full https:// URL. Relative paths can be misinterpreted.
  • Multiple canonical tags on the same page: only one should exist. A theme and an SEO plugin sometimes both emit one. Pick a single source.
  • Canonical conflicts with a noindex tag: if a page is noindexed, the canonical pointing at it has no effect. Resolve which signal you actually want.

Best practices

  • Self-canonicalize when in doubt: if a page has no duplicates, it should canonicalize to itself.
  • Pair with consistent internal linking: link to the canonical URL from internal navigation, not to query-parameter variants.
  • Use canonicals for pagination and filters: filtered or sorted product list URLs typically canonicalize to the unfiltered base view.
  • Verify with URL Inspection: Google Search Console reports the canonical Google has chosen, which may differ from the one you declared.
Detects whether the page declares a canonical link tag indicating its preferred URL. Canonical tags consolidate ranking signals across duplicate or near-duplicate URLs onto a single authoritative version, which prevents search engines from splitting authority across variants caused by query parameters, session IDs, or alternate paths. They also help AI crawlers identify the source of truth when citing the page.
Nofollow Tag Test
This webpage does not use the nofollow meta tag. This means that search engines will crawl all links from this webpage.
Detects whether the page applies a nofollow directive, either through a robots meta tag, an X-Robots-Tag header, or per-link rel attributes, that tells search engines not to follow outbound links. Google recommends nofollow for sponsored links and for user-generated content where the linked sites are not vetted, so its presence or absence has real consequences for how link equity flows.
Disallow Directive Test
This website lacks a "robots.txt" file. This file can protect private content from appearing online, save bandwidth, and lower load on your server. A missing "robots.txt" file also generates additional errors in your apache log whenever robots request one.
Surfaces the disallow rules declared in the site's robots.txt file. Disallow directives tell search engine crawlers not to access specific files, paths, or directories, which is useful for keeping admin sections and duplicate content out of indexes but dangerous when applied too broadly, since over-blocking can hide important pages from search.
Meta Refresh Test
98% of top 100 sites passed
This webpage is not using a meta refresh tag.
Detects whether the page uses a meta refresh tag to automatically reload or redirect after a delay. Meta refresh is largely obsolete, hurts accessibility by jumping focus and disorienting screen reader users, and is a weaker signal to search engines than a proper server-side 301 redirect. Its presence usually indicates outdated implementation worth updating.
SPF Records Test
94% of top 100 sites passed
This DNS server is using an SPF record.
v=spf1 +a +mx +ip4:119.18.54.11 +ip4:119.18.54.19 +include:websitewelcome.com ~all
Checks the domain's DNS for a Sender Policy Framework record. SPF lets receiving mail servers verify that messages claiming to come from the domain were actually sent by an authorized mail server, which significantly reduces the chance of legitimate email being marked as spam and protects the domain's sender reputation.
Ads.txt Validation Test
67% of top 100 sites passed
We cannot access the ads.txt file in order to perform our test!

Ads.txt Validation Test

How to pass this test?

The ads.txt file is a public list of the advertising vendors authorized to sell your inventory programmatically. A correctly formatted ads.txt protects against domain spoofing in the ad supply chain and is required for inclusion in many premium advertising marketplaces. Fixing this issue means publishing a valid ads.txt at the site root with current authorized seller entries.

Example

google.com, pub-0000000000000000, DIRECT, f08c47fec0942fa0
example-ssp.com, 12345, RESELLER
contact=ads@example.com

Where to make the change

  • Raw HTML or static site: upload ads.txt to the site root so it is served at https://example.com/ads.txt.
  • WordPress: use a small plugin or upload the file via FTP. Some advertising plugins manage it automatically based on connected accounts.
  • Shopify: upload the file through the theme code editor as an asset, then expose it at the root via a route configuration.
  • Cloudflare or similar CDN: serve ads.txt from a worker if you do not have file-system access at the origin.

Common causes and how to resolve them

  • File missing: create one with at least your direct advertising relationships.
  • File at the wrong path: ads.txt must be at the domain root, not in a subdirectory.
  • Wrong relationship value: use DIRECT for direct seller relationships, RESELLER for authorized resellers. Other values are invalid.
  • Stale entries: partners change; remove relationships you no longer have so spoofers cannot exploit them.
  • Returning HTML instead of plain text: the file must be served as text/plain. A page that returns HTML or a 404 fails validation.

Best practices

  • Audit quarterly: stale entries are the main source of ads.txt vulnerabilities.
  • Mirror app-ads.txt for mobile inventory: apps use a parallel app-ads.txt file with the same syntax.
  • Add a contact line: include a contact=email@example.com line so vendors can reach the right person about ad-quality issues.
Validates the format of the site's ads.txt file, which publishers use to declare which advertising vendors are authorized to sell their inventory programmatically. A correctly formatted ads.txt protects against domain spoofing in the ad supply chain and is required for inclusion in many premium advertising marketplaces.

Dominate search today on Google and AI Engines.

Join 85,000+ SaaS Marketers, Growth Agencies, Content-Led Companies and E-commerce Brands.

See Pricing
Dashboard preview showing SEO site checkup metrics, page group insights, and issue prioritization