A broken sitemap rarely 404s. It keeps serving, just wrong: a malformed entry, a flood of duplicates, a section that points at dead pages. Crawlers lose the thread of your new pages without anything ever looking down. Hoppla finds the sitemap the way a crawler would, parses it (nested index files and all), checks the structure, then samples the URLs and actually fetches them to see if they resolve. It's advisory. A warning when something drifts, never a 3am page.
sitemap example.com → /sitemap.xml · 1,240 urls · 2 sitemaps · 1 dup · 25% unreachable · WARNING
Fictional values. Not a live measurement.
Hoppla finds your sitemap, follows nested sitemap-index files, and parses up to 5,000 URLs, flagging malformed entries and noting duplicates as it goes. Then it samples a subset (20 by default, up to 50) and actually fetches those URLs to see if they resolve. Three things turn it amber: more than a fifth of the sample is unreachable, the sitemap won't parse, or there's no sitemap to find at all. It never opens a downtime incident. This is an indexability signal, not an uptime alarm.
Hoppla resolves the sitemap in the order a search engine would: an explicit sitemap_url if you've set one, then a Sitemap: directive in robots.txt, then a fallback to /sitemap.xml. If none of those turns one up, that's a warning on its own, because as far as a crawler is concerned, you don't have a sitemap.
Hoppla reads the XML, follows nested sitemap-index files down into their child sitemaps, and collects URLs up to a 5,000 cap. A sitemap that won't parse (broken XML, a malformed entry) warns straight away. A crawler hitting the same file gives up at the same spot, so you should hear about it.
Hoppla looks for the mistakes that quietly degrade crawling: duplicate URLs, entries with no <loc>, URLs pointing at another domain, a sitemap with no entries. Most of these don't break the file outright. They just muddy the signal you're sending Google about what to index, and nothing tells you it's happening.
From everything it found, Hoppla samples a configurable subset (20 by default, up to 50) and requests each one to confirm it resolves. Cross 20% unreachable (with at least five URLs checked) and the check warns. You get back the URL count, the sitemap count, the errors found, and the unreachable percent, enough to know which section went dead.
A degraded sitemap is a slow indexing problem, not an outage. So it never opens a downtime incident and never pages your on-call. It shows up as a warning on the same monitor as your uptime and SSL checks, the place you already look, without piling onto the alerts that mean drop everything.
Hoppla doesn't just trust the XML. It fetches a sample and counts what doesn't resolve. Once more than a fifth of the sample is unreachable, it warns, so you find the section that started returning errors before a search engine rediscovers it the slow way, weeks later, in your traffic graph.
Real sites split sitemaps into index files with children. Hoppla follows them and parses up to 5,000 URLs, so a fault buried in a child sitemap gets caught, not skipped because the top-level file happened to look fine.
You ship a pricing page and a fresh batch of docs, your framework regenerates the sitemap automatically, and the build hiccups: half the new routes land in it with a trailing slash that now 404s. Nothing errors. The pages are live, but the sitemap points crawlers at dead URLs, and you'd find out weeks later from a flat traffic line. Hoppla samples the sitemap's URLs and, once more than a fifth of the sample fails, warns you while the build is still fresh enough to fix.
Launch day for a client rebuild: new CMS, new URL structure, sitemap freshly generated. Next week the client asks "why aren't we in Google yet?", and you want the answer ready before the question. Add a sitemap check at handover and you've got it: the sitemap parses, the sampled URLs resolve, no leftover duplicates pointing at the old structure. One green check at launch beats a defensive email a fortnight later.
Across hundreds of content sites, sitemaps drift. A migration drops a section. An editor's plugin starts emitting malformed entries. A redirect rule leaves a quarter of the URLs dead. Nobody is opening sitemap.xml by hand on 300 sites. Run the check on a schedule across the portfolio and the warnings cluster on the sites that need attention, with unreachable percent and error counts per site, so the SEO team triages from a list instead of stumbling on it in a quarterly review.
Indexability is an SEO add-on your customers will pay for, and the sitemap check is a clean way to package it under your own brand and domain. Bundle sitemap validation and URL reachability into an SEO-health tier. The warnings, the URL and error counts, the unreachable percent: all of it carries your name, not Hoppla's. A recurring line item built on a check you didn't have to build.
Import the monitors you already run in another tool. What comes across depends on the provider. Run both side by side for 24 hours or 7 days before you switch.
The importer opens in your workspace once you have access.
Get early accessBecause it isn't downtime. A degraded sitemap hurts how you get crawled and indexed, not whether your site is serving, so it's deliberately advisory. It warns on the same monitor as your uptime and SSL, in the place you already look, without firing the page-the-on-call alerts you keep for actual outages. You see it. It just doesn't wake you.
No, it samples. It parses up to 5,000 URLs to validate the structure, then fetches a configurable subset (20 by default, up to 50) to test reachability. Sampling keeps the check fast and easy on your server while still catching widespread breakage: once more than 20% of the sample doesn't resolve, that's a pattern, not a coincidence, and it warns.
You can open sitemap.xml in a browser once. You won't do it every week on every site, and eyeballing the XML doesn't tell you which URLs actually resolve. Hoppla runs the discovery, parsing, validation, and a live reachability sample on a schedule and warns you when it drifts, so a regenerated sitemap that quietly broke gets caught without anyone remembering to look.
That's a warning in its own right. Hoppla looks where a crawler would (your sitemap_url setting, then robots.txt, then /sitemap.xml), and if none of them yields a sitemap, crawlers looking in the same places won't find one either. The warning tells you to publish one, or point the discovery at the right URL.
Checks, alerts and status pages in one workspace. Now in early access: join the list for an invite.