Best Mobile-Friendly Test Tools 2027 (Google's Tool Retired)

Google retired its Mobile-Friendly Test in 2023. The best mobile-friendly test tools for 2027, plus a 25-page phone test that found small tap targets on all.

· BugViso Team

10 min read

Google retired its Mobile-Friendly Test, the test's API and Search Console's Mobile Usability report on 1 December 2023, so the best mobile-friendly test tools for 2027 are Lighthouse (in PageSpeed Insights or Chrome), Chrome DevTools device mode, real phones, and a site-wide checker such as BugViso. None of them gives the old single "mobile-friendly" verdict; each checks specific problems.

To see what those problems look like on a real site, we loaded 25 of our own pages in a phone-sized browser. All 25 had a correct viewport tag and none scrolled sideways. But every one of them had at least one tap target smaller than 24 × 24 pixels, the size WCAG 2.2 sets as the minimum.

By the end you will know what replaced Google's test, which tool checks which mobile problem, and how to run a phone-sized check on any page for free.

Data used: 25 bugviso.com pages (10 product and feature pages, 15 blog posts chosen at random with seed 20261116), loaded on 2026-11-16 in headless Chromium 128 through Playwright, at a 375 × 812 viewport with touch and mobile mode on. We measured the viewport tag, horizontal overflow, interactive elements smaller than 24 px in either dimension, and paragraph or list text below 12 px. The script is in this post. We make BugViso, one of the tools listed.

What Happened to Google's Mobile-Friendly Test

Google announced in April 2023 that it would retire the Mobile-Friendly Test, the Mobile-Friendly Test API and the Mobile Usability report from 1 December 2023. The announcement, in its post on page experience in Search, made clear that mobile usability still matters; only the tools went away.

The old test gave one yes/no answer. Its replacement is a set of narrower checks: does the page set a viewport, does content fit the screen, are buttons big enough to tap, is the text readable, and is it fast on a phone. That is better in practice, because "mobile-friendly: yes" hid problems that real users hit.

What We Found on 25 Pages at Phone Width

Our pages passed the two checks Google's old test focused on, viewport and sideways scroll, and still had small tap targets everywhere. Here are the results.

Check (25 pages at 375 px)Pages passingDetail
Viewport meta tag present25 of 25width=device-width on every page
No horizontal scroll25 of 250 px overflow on every page
No tap target under 24 × 24 px0 of 251 to 15 per page, median 7
No paragraph or list text under 12 px2 of 25Every blog post had the same 14, so it's a shared template

The small tap targets were mostly breadcrumb links like "Home" and "Blog" and small text links in cards. That needs a careful reading. WCAG 2.2's target size minimum (success criterion 2.5.8) sets 24 × 24 CSS pixels, but exempts links inside a sentence and small targets with enough space around them. So a raw count overstates the failures; each flagged target needs a quick look.

That is the honest lesson about mobile testing: a "pass" on the big checks says little about the small ones, and the small ones are what make a page fiddly to use on a phone.

The 6 Best Mobile-Friendly Test Tools

ToolBest forChecksPrice
PageSpeed Insights (Lighthouse)A quick mobile check of one URLViewport tag, mobile speed, accessibility basicsFree
Chrome DevTools device modeSeeing and fixing layout at phone sizesAny layout problem you can seeFree
Real phonesTouch, keyboard and real-network behaviourEverything emulation missesFree if you own them
Search Console Core Web Vitals reportReal-user mobile speed across your siteLCP, INP, CLS on mobileFree
BugViso site auditMobile layout checks on every crawled pageTap targets, horizontal overflow, mobile emulationFirst report free
The script belowA phone-sized check of any URL listViewport, sideways scroll, tap targets, small textFree

PageSpeed Insights and Lighthouse: the closest replacement

Running Lighthouse in mobile mode, through PageSpeed Insights or in Chrome, is the closest thing to the old Mobile-Friendly Test. It checks that the page sets a viewport, runs accessibility checks, and scores performance on a throttled mobile connection, which matters more on phones than anywhere else. It tests one URL at a time.

Chrome DevTools device mode: see it, then fix it

DevTools device mode shows the page at phone sizes, simulates touch and lets you throttle the network. It's where you fix what other tools flag: open the page at 375 px, find the element that overflows or the button that is too small, and edit the CSS live.

Real phones: what emulation can't show

Emulation doesn't reproduce a real on-screen keyboard covering a form, a slow phone's CPU, or a fingertip missing a small link. Check your main journeys (sign-up, checkout, contact) on at least one real Android phone and one iPhone before a launch.

Search Console Core Web Vitals: real users on mobile

The Core Web Vitals report in Search Console groups your URLs by real-user mobile speed, using Chrome UX Report data. It doesn't check layout, but slow loading and layout shifts are the mobile problems that most often hurt rankings and conversions. Our guide on why LCP is slow on mobile but fast on desktop covers the usual causes.

BugViso: mobile checks on every page

BugViso loads each crawled page in mobile emulation (iPhone 16 Pro and Pixel 9) and flags tap targets under 24 × 24 px and horizontal overflow, next to its accessibility and speed checks. It's built to find the template that breaks on phones across a whole site. Where others go further: emulation is not a real device, so keep a real-phone check for your key journeys.

The free script: a phone-sized check of any URL

The script below is the test we ran for the table above. It needs Playwright, takes any list of URLs and prints one line per page.

How to Fix the Most Common Mobile Problems

Three fixes cover most mobile problems: set the viewport, stop wide elements overflowing, and give tap targets room. Here is each one.

html
<!-- ✅ Every page needs this, or phones render a shrunken desktop page -->
<meta name="viewport" content="width=device-width, initial-scale=1">
css
/* ✅ Stop wide media and code blocks from pushing the page sideways */
img, video, iframe { max-width: 100%; height: auto; }
pre, table { overflow-x: auto; }

/* ✅ Give small links and icon buttons a 24 px minimum hit area without changing the look */
nav a, .breadcrumb a, .icon-button { display: inline-block; min-height: 24px; min-width: 24px; padding-block: 2px; }

When a page still scrolls sideways, find the culprit in DevTools by running [...document.querySelectorAll('*')].filter(e => e.scrollWidth > innerWidth) in the console. The step-by-step version is in our guide to fixing horizontal scroll on mobile.

Run It Yourself: A Phone-Sized Check of Any Page

This script opens each URL in a phone-sized Chromium with touch on, then reports the viewport tag, sideways overflow in pixels, tap targets under 24 px and text under 12 px. It needs Python and Playwright.

python
#!/usr/bin/env python3
"""Mobile-friendly check in a real phone-sized browser: viewport, sideways scroll, small tap targets.

Usage: python3 mobile_check.py <url> [more urls ...]
Needs: pip install playwright && playwright install chromium
"""
import sys
from playwright.sync_api import sync_playwright

JS = """() => {
  const vp = document.querySelector('meta[name=viewport]');
  const small = [...document.querySelectorAll('a[href], button, input, select, textarea, [role=button]')]
    .filter(el => { const r = el.getBoundingClientRect(), s = getComputedStyle(el);
      return r.width > 0 && r.height > 0 && s.visibility !== 'hidden' && (r.width < 24 || r.height < 24); });
  const fonts = [...document.querySelectorAll('p, li')].filter(el => parseFloat(getComputedStyle(el).fontSize) < 12);
  return { viewport: vp ? vp.content : null,
           overflow_px: document.documentElement.scrollWidth - window.innerWidth,
           small_targets: small.length, small_text: fonts.length,
           example: small[0] ? (small[0].innerText || small[0].getAttribute('aria-label') || small[0].tagName).trim().slice(0, 40) : '' };
}"""

with sync_playwright() as p:
    browser = p.chromium.launch()
    ctx = browser.new_context(viewport={"width": 375, "height": 812}, device_scale_factor=3,
                              is_mobile=True, has_touch=True)
    page = ctx.new_page()
    for url in sys.argv[1:]:
        try:
            page.goto(url, wait_until="networkidle", timeout=60000)
            r = page.evaluate(JS)
        except Exception as e:  # one dead URL shouldn't stop the rest
            print(f"FAIL  {url}: {type(e).__name__}")
            continue
        print(f"viewport={'yes' if r['viewport'] else 'NO '}  sideways={max(r['overflow_px'], 0):>4}px  "
              f"small_targets={r['small_targets']:>3}  small_text={r['small_text']:>3}  {url}  {r['example']!r}")
    browser.close()

Three lines from our run, unedited:

text
viewport=yes  sideways=   0px  small_targets=  1  small_text=  0  https://bugviso.com/  'Start tracking'
viewport=yes  sideways=   0px  small_targets= 12  small_text=  6  https://bugviso.com/features/ai-visibility-tracker  'Home'
viewport=yes  sideways=   0px  small_targets=  6  small_text= 14  https://bugviso.com/blog/inp-vs-fid-difference-why-google-changed  'Blog'

The script counts every small target, including the inline links WCAG exempts, so treat the number as a list to review rather than a list of failures. The example column names the first one it found, which is usually enough to locate the pattern.

How BugViso Checks Mobile Layout on Every Page

BugViso's mobile checks run in the same real-browser crawl as the rest of the audit: each page is loaded in iPhone 16 Pro and Pixel 9 emulation, and the engine flags tap targets under 24 × 24 px (WCAG 2.2 SC 2.5.8) and content that overflows the screen sideways. Findings name the page and the element.

Because the same audit runs axe-core for WCAG 2.2 A and AA and measures Core Web Vitals, a page that is slow, hard to tap and inaccessible shows all three problems in one ranked fix list instead of three tools. The accessibility and mobile feature page lists the checks.

Frequently Asked Questions

Does Google still have a Mobile-Friendly Test?

No. Google retired the Mobile-Friendly Test, its API and Search Console's Mobile Usability report on 1 December 2023. Mobile usability still matters for users and for Google's page experience guidance. For a quick check today, run Lighthouse in mobile mode through PageSpeed Insights or Chrome DevTools.

How do I check if my website is mobile-friendly?

Check four things at phone width: the page has a viewport meta tag, nothing scrolls sideways, buttons and links are at least 24 × 24 pixels or well spaced, and body text is readable without zooming. Lighthouse covers some of these; the script in this post checks all four for any URL.

What size should tap targets be?

WCAG 2.2 success criterion 2.5.8 sets a minimum of 24 × 24 CSS pixels, with exceptions for links inside a sentence and small targets that have enough space around them. Larger is better for primary buttons; many design systems use 44 or 48 pixels for main actions.

Is mobile-friendliness a ranking factor?

Google uses mobile-first indexing, so it mainly looks at the mobile version of your pages, and mobile usability is part of its page experience guidance. A page that is hard to use on a phone loses visitors whatever its ranking, which is the bigger cost for most sites.

Can I test mobile pages without a phone?

Yes, for most layout problems. Chrome DevTools device mode, Lighthouse in mobile mode and the script in this post all emulate a phone. Emulation misses real touch behaviour, the on-screen keyboard and slow phone processors, so check key journeys on a real device before launch.

The Mobile Check Most Sites Skip

Viewport and sideways scrolling are usually fine on modern sites; small tap targets are not, and they are what makes a page frustrating with a thumb. Run the script on your top templates, review every flagged target, and run a BugViso audit to see the same check across the whole site.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.