Mobile Simulator — a tablet and phone simulator for previewing any site in the browser

• Mobile Simulator

  This page

  PricingMobile Simulator leads

  • Free, with no account, no signup and no API key
  • Stated as free forever rather than as a free plan with an upgrade path
  • Installs as a browser extension and adds no separate subscription
  • Nothing in the product is metered, so there is no credit to run out of

• Chrome DevTools

  PricingMobile Simulator leads

  • Free and already installed in the browser you are debugging in
  • No extension, no account and nothing to grant permission to
  • The full set of features is available to every user with no tiering
  • Cost is in time rather than money: one viewport at a time

• Mobile FIRST

  PricingMobile Simulator leads

  • Free to install, with no account required to start
  • The extension is offered for Chrome and Firefox
  • Device list and capture export are part of the free product
  • No per-device or per-seat charge is presented on the landing page

• Mobile Ready

  PricingMobile Simulator leads

  • A free plan that covers the core simulation and device frames
  • HD captures and team features sit behind a paid upgrade
  • The upgrade is presented as optional rather than as a trial expiry
  • Free tier is described as suitable for getting started rather than as a demo

1. Mobile Simulator — official site
2. Mobile Simulator — device library
3. Mobile Simulator — browser store listing
4. Chrome DevTools — device mode documentation
5. Mobile FIRST — official site
6. Mobile Ready — official site

Free tier

Yes

Pricing summary

The commercial answer here is unusually short and worth taking at face value: the extension is free, there is no account, no signup and no API key, and the product describes that as permanent rather than as an introductory offer. Nothing is metered, so there is no credit balance to monitor and no feature that stops working at the end of the month. In a category where the neighbours are free-with-an-upgrade or free-with-an-account, the missing account is the meaningful part — there is nothing to sign into, no profile holding your projects, and no billing relationship to keep current. The costs that do exist are the ones that do not appear on a pricing page. The first is the permission grant: a browser extension that reads the pages you open is asking for something real, and that is worth a look at the store listing before installing regardless of how the price is described. The second is the ceiling of the approach itself. This renders your site through Chrome inside a device frame with a spoofed user agent, which is a different thing from a tablet — so a page that looks correct here can still break on hardware, and the tool cannot tell you about the cases where it will. The third is subtle and worth saying plainly: because the checks are easy and instant, it is tempting to treat a green pass across four panels as verification. It is a fast first look, not a substitute for the hardware you ship to. If the free tier ever changes, this page will be updated — but nothing about the current product suggests a paid gate is coming, and treating it as free is accurate today.

Reviewed on 19 September 2026 · Mobile Simulator — official site

• Several device panels in one tab, with linked scrolling and clicking

  The core of the product: three to five devices open simultaneously, all following the same scroll position, and a click in one registering in the others. That last detail is the one that saves the most time, because a navigation change, a modal or an accordion is exactly the kind of thing that breaks differently at different widths, and seeing all four reactions at once is faster than discovering them one after another.

• Genuine user agent and client hint headers

  The server sees a real iPhone or Android, including the modern client hint headers that some sites check before the user agent string. That matters more than it sounds. Plenty of sites serve a different template to mobile visitors, and a viewport resize that leaves the desktop user agent in place shows you a desktop page squeezed into a narrow frame rather than the mobile experience you are trying to review.

• Independent light and dark theming per panel

  Each panel can be forced to light or dark on its own, so the same page can be inspected in both themes side by side instead of toggling the operating system and reloading. It is a small feature that removes a genuinely tedious loop from dark-mode work, and it is the kind of thing that only makes sense in a multi-panel interface.

• Screenshot export of one device or the whole set

  PNG export at a single click, either from one panel or as a composite of everything currently open. The composite is the feature with the clearest practical use: a client update, a pull-request comment or a bug report that shows all four breakpoints in one image is materially more useful than four attachments, and building that by hand is the sort of task that quietly consumes an afternoon.

• A current device library, including tablets and foldables

  The library covers recent Apple, Samsung and Google flagships along with tablets and foldables, and it is presented as a maintained list rather than a snapshot. For the tablet case specifically — which is where the search traffic for this category concentrates — having iPad and Android tablet presets with accurate dimensions is the whole reason someone reaches for a simulator instead of a ruler and a resized window.

• Custom viewports that can be saved as presets

  Any width and height can be entered manually and kept as a reusable preset, which is what you need when the breakpoint that matters is not a device at all but a specific grid tier your own CSS defines. Saving it means the check becomes one click on every subsequent pass rather than a repeated arithmetic exercise.

• Works on any URL Chrome can open, including local and private ones

  Production, staging, localhost, file URLs and intranet hosts all work, because the extension operates on the tab rather than by fetching the page from somewhere else. This is the practical difference between a simulator and a web-based previewer: the online tools cannot reach a development server on your machine, and many cannot reach anything behind an authentication wall.

• No account, and no data collected from the pages you preview

  The product states that previewed URLs and page contents are not collected, and the absence of an account means there is nothing to associate with them in the first place. Everything runs locally in the browser, which is the useful property when the pages you are testing are unreleased, behind a login, or belong to a client who would prefer they were not sent to a third party.

1. 1

   Start from the page you are already working on, not from a pasted URL

   The extension acts on the open tab, so the natural workflow is to have the page you are building in front of you, click the icon, and open the sizes you care about. Staying in the same tab also preserves the session — which is the practical reason this beats a web-based previewer for anything behind a login or on a local development server.

2. 2

   Check the mobile template actually served, not just the narrow layout

   Once the user agent is spoofed, look at whether the site responded by serving its mobile template or merely reflowed the desktop one. Many responsive bugs are not layout bugs at all — they are a conditional that fired the wrong branch, or a component that assumed a desktop-only feature. If the content differs from what you expected, the user agent is doing its job and you have found something worth knowing.

3. 3

   Use the dark-mode toggle on both panels before you call it done

   A palette that works in one theme frequently fails in the other, and the failure is usually contrast on a surface that changed underneath it. Toggling both panels takes seconds here, which removes the excuse for skipping the check — and it is the single easiest accessibility problem to catch before a user does.

4. 4

   Treat a clean pass as a first filter, not as verification

   The most expensive mistake with any simulator is trusting it too far. This renders through the same desktop engine you are already using, so it cannot show you WebKit-specific behaviour, real touch physics, keyboard handling on a phone, or how the page performs on a mid-range device. Use it to catch the obvious and to make the later hardware pass shorter, and do the hardware pass for anything going live.

5. 5

   Save the breakpoints your own CSS defines as custom presets

   Device presets cover the popular hardware; your own grid tiers are what your layout actually breaks at. Enter those widths once, save them, and the recurring check becomes one click rather than a calculation. This is the step most people skip, and it is the one that turns the tool from an occasional novelty into part of the routine.

6. 6

   Capture the composite for anything that will be discussed by other people

   Because the export includes every open panel in one image, the screenshot can carry the whole argument — here is the layout at four widths, here is what broke. It removes a round of "which size were you seeing?" and it gives a designer or a reviewer the evidence in the format they need rather than a link they have to go and reproduce.

• Front-end developers working on responsive layouts

  The clearest fit. A layout change normally needs checking at three or four widths, and the multi-panel view turns that from a sequence of resizes into a single look. The synchronised scrolling is what makes it work: you scroll once, and you see all four versions of the same moment at the same time, which is when the differences actually become visible.

• Designers reviewing an implementation rather than designing it

  Reviewing someone else’s build is mostly a comparison task, and a simulator makes the comparison cheap. Having the four breakpoints on screen with the theme toggled is enough to say whether the spacing, hierarchy and contrast survived the translation from the design file — which is precisely the pass that tends to get compressed when the tooling makes it awkward.

• Agencies and freelancers producing client-facing captures

  The composite screenshot export is built for this audience. A single image showing the site at four device sizes is a deliverable in itself — for a client update, a proposal, or the before-and-after that accompanies a redesign — and producing it without this kind of tool means either four screenshots in a row or a paid mockup generator.

• Anyone testing pages that a hosted previewer cannot reach

  Development servers on localhost, staging environments behind authentication, internal tools on an intranet — the browser-based previewers in this category cannot see any of them, because they fetch the page from their own servers. An extension operating on the open tab has no such limitation, which makes it the practical choice for internal work even where a web tool would be more convenient.

• Teams that need to check tablet widths specifically

  Tablets are the size class most often neglected, because developers own phones and work on laptops and the middle ranges get assumed rather than tested. Tablet presets with accurate dimensions — including the larger iPad sizes where a two-column layout breaks into something odd — make the pass quick enough that it stops being the step everyone means to do later.

A browser extension, not a virtual machine or a real device

This is the single most important thing to understand. The extension renders the page through your desktop browser’s engine inside a device frame, changing the viewport dimensions, the pixel ratio and the request headers. That gets you accurate layout behaviour, correct media-query firing and the right server response — and it does not get you the device’s rendering engine, its scrolling physics, its touch behaviour or its performance characteristics. The product’s own language about real devices describes the headers and the frames, not the hardware.

User agent and client hints are the mechanism that makes it useful

Spoofing the user agent is what separates a simulator from a narrow window. It is also why the tool is more informative than a simple resize: sites that branch on the request rather than on the viewport will serve what a real visitor would receive, and that is often where the interesting differences are. As with any user-agent override, a server can also be configured to ignore it, in which case you will see the desktop response and should not mistake that for a layout bug.

Everything runs locally, and no account is required

The pages you preview are loaded by your own browser rather than fetched by a vendor service, there is no sign-in, and the product states that previewed URLs and page contents are not collected. In practice this is what allows it to work on localhost, private staging hosts and intranet addresses — the places a server-side previewer cannot reach — and it is also the reason there is no synced library, no saved history across machines and no team workspace.

A Chrome extension with the permission model that implies

It installs from the browser store into Chromium-based browsers, and like every extension of this type it holds permissions to read and modify the pages you open. That is inherent to how it works rather than a red flag, but it is the thing to review in the store listing before installing, particularly on a work machine where the browser profile may hold sessions for other systems.

Where it stops being useful

It will not run a tablet app, which is the other meaning of the phrase people search for. It will not produce visual-regression diffs, run a device matrix in CI, or test on hardware you do not own. It cannot tell you about performance, battery or thermal behaviour. And it does not replace a genuine device pass before release — treating a clean pass here as proof of correctness is the one way to get real value out of it and still ship a bug.

What it does not cost you in maintenance

Because it is an extension rather than a dependency, there is nothing to add to a project, no configuration to keep in sync and nothing to remove from a build. Uninstalling it leaves no trace in the repository. The only upkeep is the browser store updating it, which is the same arrangement as any other extension you rely on.