Web Manifest Checker

Server assisted New Website & HTTP Diagnostics

Give a page URL and the checker follows its link rel="manifest" through the Mutqan server, or give the manifest URL itself, or paste the JSON to validate it in your browser. It checks the members against the W3C Web Application Manifest, the same-origin rules for start_url, scope and shortcuts, the display mode and the 192 and 512 pixel icons Chromium asks for, and can request each icon file to confirm it exists.

Privacy: The Mutqan server sends the small, fixed test requests described on this page to the host you name, and nothing is stored. Use it only against systems you are authorised to test.

What is a web app manifest?

A web app manifest is a JSON file, linked from a page with link rel="manifest", that tells the browser how to install the site as an app: its name and short_name, the start_url it opens, the scope it controls, the display mode and the icons for each surface. start_url and scope resolve against the manifest's own URL and must stay on its origin, and Chrome offers installation only when the manifest has a name, a start_url, an installable display mode and 192 and 512 pixel icons, on a page served over HTTPS.

How to use Web Manifest Checker

  1. Enter a page URL (the checker follows its manifest link) or the manifest URL itself — or paste the manifest JSON into the second field.
  2. Leave "Request the icon files" on to check that the icons a fetched manifest lists really exist.
  3. Press Check manifest and read the Install criteria table first: every Fail is a reason Chrome will not offer to install the app.
  4. Fix the Errors, consider the Warnings (description, id, maskable icon, screenshots), and check again.

Web Manifest Checker features

  • Finds the manifest from a page URL by reading its link rel="manifest", or reads a manifest URL directly, through the Mutqan server
  • Validates pasted manifest JSON entirely in your browser, with an optional URL to resolve start_url, scope and icon paths
  • Checks every member the W3C Web Application Manifest and current browsers use: name and short_name, id, start_url and scope (same-origin, start_url inside scope), display and display_override, orientation, dir, lang, colors, icons, shortcuts, screenshots and legacy members
  • Evaluates Chrome's documented install criteria one by one — HTTPS, a name, a same-origin start_url, an installable display mode, 192 and 512 pixel icons with purpose any, prefer_related_applications not true — and says which could not be checked
  • Lists the icons with sizes, type and purpose, and can request each icon file (up to eight, HEAD only) to confirm it exists and is served as an image
  • Warns when the manifest is not served with a JSON media type (application/manifest+json is the one registered for manifests) and when a manifest URL returns an HTML page

Inputs and outputs

Inputs

  • Page or manifest URL — a public page that links a manifest, or the manifest's own URL; with pasted JSON it only resolves relative members.
  • Or paste the manifest JSON — validated in the browser, nothing sent.
  • Request the icon files — on by default; checks up to eight icon URLs of a fetched manifest with HEAD.

Outputs

  • Summary — whether Chrome's install criteria are met, not met or not fully checked, and the counts of errors, warnings, icons and members.
  • Install criteria (Chrome) — each criterion with Pass, Fail or Not checked.
  • Errors and Warnings — every problem the validation found, in plain sentences.
  • Manifest — the effective name, short_name, id, start_url, scope, display and colors, the manifest URL, the page that linked it and its Content-Type.
  • Icons — each icon's resolved URL, sizes, type, purpose, HTTP status and served type; downloadable as CSV.

Web Manifest Checker example

A manifest linked from a page, with three install blockers

Input:

Page or manifest URL: https://www.example.com/ · Request the icon files: on

Output:

Install criteria Not met · Errors 5 · Warnings 7 · Icons 1 · Members 5
Served over HTTPS Pass · start_url on the manifest's origin Fail · Installable display mode Fail · Icon of 512×512 or larger with purpose any Fail
The start_url resolves to https://other.example.org, another origin than the manifest (https://www.example.com); start_url must be on the same origin.
The display "browser" is not installable; use "standalone", "minimal-ui" or "fullscreen".
The theme_color "blue-ish" is not a CSS color.
The icon https://www.example.com/i/192.png could not be loaded: HTTP 404.
The manifest is served as text/plain, not as JSON; the specification asks for application/manifest+json (any JSON media type is accepted).

How to read the Web Manifest Checker results

Errors break the manifest or installation: invalid JSON, a missing name or start_url, a start_url on another origin, a display of "browser", or missing 192 and 512 pixel icons with purpose any. Browsers ignore invalid members, so an error also means that setting has no effect.

Warnings are improvements: a description and screenshots for the richer install dialog, an explicit id so start_url can change later, a maskable icon for Android, a short_name of 12 characters or fewer.

Not checked means the information was not available — HTTPS and the same-origin rules cannot be judged for pasted JSON without the manifest's real URL — so "Not fully checked" is not a pass.

Meeting the criteria lets Chrome offer installation; it does not guarantee the prompt appears at once, because the browser also waits for user engagement and some browsers apply criteria of their own.

When to use Web Manifest Checker

  • Find out why the browser's install button never appears for your progressive web app.
  • Review a manifest before release: same-origin start_url and scope, icon sizes and purposes, colors and display mode.
  • After moving a site or changing its CDN, confirm the manifest and its icons are still served, and with which Content-Type.
  • Validate a manifest you are still editing by pasting it, with no deployment needed.

Troubleshooting

  • "The manifest URL returned an HTML page, not JSON": the link points to a path that answers with an error page or the site's home page. Check the href of link rel="manifest" and that the file is deployed.
  • "The page links no web app manifest": the link is missing from the HTML the server sends — perhaps it is added later by JavaScript, which the checker does not run. Enter the manifest URL directly.
  • start_url fails the same-origin check after a move to a CDN host: start_url and scope must be on the manifest's own origin, so serve the manifest from the app's origin or use relative URLs.
  • Icons answer 404 although they exist: icon src values resolve against the manifest's URL, not the page's; a manifest in /static/ with src "icons/a.png" points to /static/icons/a.png.
  • "The icon files could not be requested" with the request-limit message: each icon URL uses one of the 10 file checks allowed a minute without signing in (30 when signed in), and the page and its manifest use two of the 10 page fetches shared with other tools. Wait a minute, or untick "Request the icon files" to validate the manifest alone.

Frequently asked questions about Web Manifest Checker

What makes a web app installable in Chrome?

Chrome's documented criteria are: served over HTTPS, a manifest with name or short_name, icons of 192 and 512 pixels, a start_url, a display of fullscreen, standalone, minimal-ui or window-controls-overlay, and prefer_related_applications absent or false. The browser also waits for some user engagement before it offers the install prompt; users can still install from the menu without it.

Why must start_url and scope be on the same origin as the manifest?

The manifest describes one app, and an app is bound to one origin. A start_url on another origin is ignored and replaced by the page that linked the manifest; a scope that does not contain start_url falls back to the default scope. The checker reports both against the manifest's own URL.

What is a maskable icon?

An icon with purpose "maskable" keeps its important content inside a central safe zone, so Android can crop it to a circle, a squircle or another adaptive shape without cutting the logo. Without one, Android places the regular icon on a white tile. Keep a purpose "any" icon as well: maskable-only icons do not count for installation.

Can I check a manifest that is not online yet?

Yes. Paste the JSON into the second field: it is validated in your browser and nothing is sent. Add the page or manifest URL as well if the manifest uses relative URLs, so start_url, scope and icons are resolved and the same-origin rules can be checked.

Is there a limit on how many manifests I can check?

Yes. A check that starts from a page URL makes two page fetches (the page, then its manifest, plus one for each redirect followed) out of the 10 allowed a minute without signing in (30 when signed in), shared with other tools, and then up to eight icon-file requests from a separate allowance of 10 a minute (30 signed in). A pasted manifest uses neither: it is validated in your browser.

Technical notes

The W3C Web Application Manifest defines the members and their processing: start_url and scope are resolved against the manifest URL and must share its origin, start_url must lie within scope, display falls back to "browser", and each icon is described by src, sizes, type and purpose (any, maskable, monochrome). The specification registers the media type application/manifest+json.

In URL mode the page is requested through POST /api/v1/internet/http/fetch (DNS over HTTPS first, private addresses refused, up to five redirects); a JSON or manifest Content-Type, or a body that starts with "{", is taken as the manifest, otherwise the first link rel="manifest" in the HTML is resolved against the page URL and fetched the same way. Icon files go to POST /api/v1/internet/http/assets with HEAD.

The install table follows Chrome's published criteria (web.dev, "What does it take to be installable?"). The engagement heuristics Chrome also applies — a click on the page and some time spent on it — depend on a real visitor and are not part of the check.

Limitations and methodology

Only the manifest is validated; the service worker, offline behaviour and engagement heuristics are not evaluated, and other browsers may use slightly different install criteria.

Pages and manifests are fetched once from the Mutqan server on Cloudflare's network, without running JavaScript, and at most 512 KiB of each is read.

Icon files are checked with HEAD only and at most eight per check; their real pixel size and appearance are not verified.

Security and privacy

Pasted JSON never leaves your browser. In URL mode the Mutqan server receives the URL you entered, the manifest URL it links and up to eight icon URLs, requests them with fixed headers and none of your cookies, and stores nothing.

References

  • Web Application ManifestW3CThe specification of the manifest: its members (name, short_name, start_url, scope, display, icons and more), how they are resolved against the manifest URL, the same-origin rules and the application/manifest+json media type.
  • Web application manifest — MDNMDN Web Docs (Mozilla)A reference for every manifest member browsers support, with their values, an example manifest and how a page links it with link rel="manifest".
  • What does it take to be installable?web.dev (Google)Chrome's criteria for offering installation: HTTPS, a manifest with name or short_name, 192 and 512 pixel icons, start_url, an installable display mode, prefer_related_applications absent or false, plus user engagement.