12 Sitemap Errors and How to Fix Each One in 2026
The fastest way to waste an afternoon on a sitemap error is to debug the wrong layer. Every sitemap problem lives in one of four stacked layers, file loads, file parses, Search Console accepts it, URLs index, and a failure low in the stack makes everything above it noise. I've watched people spend hours investigating "why isn't this URL indexed" when the sitemap itself was returning a 404. This guide covers the 12 most common errors, but more importantly it covers the order to check them in so you find the real one fast.
Quick verdict: Diagnose top-down, not by symptom: does the file load (404/5xx/robots block), does it parse (XML syntax, encoding, lastmod), does Search Console accept it, do the URLs index. Most people debug the last layer when the failure is in the first. The common errors ("Couldn't fetch," "Submitted URL not indexed," parse errors, duplicates) each have a fix below, but the order is what saves you. Our free generator with validation prevents most upstream.
Error 1: "Couldn't fetch" in Google Search Console
What it means: Google's crawler tried to access your sitemap URL and the request failed. Until this is fixed, nothing else in your sitemap matters — the file might as well not exist.
Diagnostic steps:
- Visit the sitemap URL in an incognito browser. Does it load?
- Check HTTP status with a tool like httpstatus.io. Should be 200.
- Check robots.txt at
yoursite.com/robots.txt. Is the sitemap path Disallowed? - Verify HTTPS certificate is valid (not expired, matches the domain).
- Check server logs for the timestamp of Google's last fetch attempt.
Common fixes:
- 404 on the sitemap URL: the file isn't where you said it is. Re-upload or update the submission URL.
- 301/302 redirect: Google can sometimes follow these but prefers direct fetches. Update the submission to the final URL.
- Server 5xx: investigate the underlying server issue. Slow PHP processes, database timeouts, and rate-limiting are common causes.
- Cloudflare blocking Googlebot: Cloudflare's "Bot Fight Mode" can sometimes block legitimate crawlers. Whitelist Googlebot in Cloudflare settings.
- HTTPS cert expired: renew the certificate. Google won't fetch over invalid TLS.
Error 2: "Submitted URL not indexed"
What it means: Google fetched the sitemap and saw the URL but decided not to index it. This is a Coverage report status, not a sitemap error per se, but it directly indicates sitemap quality issues.
Common reasons:
- Canonical conflict: the page has a
<link rel="canonical">pointing to a different URL. Google indexes the canonical, not your sitemap entry. - Duplicate content: Google considers this page duplicate of another. The other version gets indexed instead.
- Soft 404: the page returns HTTP 200 but shows minimal content (e.g., "No results found"). Google treats it as a 404.
- Low quality: thin content, near-duplicate, or low-trust pages get deprioritized.
- Not yet processed: brand-new URLs can sit in this state for 2-3 weeks before Google decides.
- Noindex tag: the page has a noindex tag that overrides the sitemap inclusion.
Fix: click into the affected URL in Search Console → URL Inspection → see the exact reason Google gave. Address that specific issue (fix canonical, remove duplicates, expand thin content, etc.).
Error 3: XML Parse Error / "Sitemap could not be read"
What it means: The XML file is malformed and Google can't parse it.
Most common parse-error causes:
| Problem | What it looks like | Fix |
|---|---|---|
| Unencoded ampersand in URL | ?id=1&color=red | Encode as & |
| Unencoded angle brackets | < or > in URL | Encode as <, > |
| Missing closing tag | <url><loc>... without </url> | Add closing tag |
| BOM character at file start | Invisible UTF-8 byte-order mark | Save without BOM (use VS Code, not Notepad) |
| Wrong namespace | Missing or misspelled xmlns | Use xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" |
| Invalid date format | e.g., "May 22, 2026" in lastmod | Use ISO 8601: 2026-05-22 or full datetime |
| Non-UTF-8 encoding | File saved as Windows-1252 or Latin-1 | Re-save as UTF-8 without BOM |
Error 4: URLs Blocked by Robots.txt
What it means: URLs in your sitemap are listed as Disallowed in robots.txt. Google notices the contradiction and reports them as warnings.
Fix: decide which signal you actually want:
- If the URL should be indexed: remove the Disallow rule from robots.txt.
- If the URL should not be indexed: remove it from the sitemap.
Never have both. The mixed signal wastes crawl budget and creates confusion entries in reports.
Error 5: Redirect Chains in Sitemap URLs
What it means: URLs in the sitemap redirect to other URLs (HTTP 301 or 302). Google follows the redirect but reports a "sitemap contains URLs with redirect" warning.
Fix: update the sitemap to list the final destination URLs directly. If /blog/post-a redirects to /blog/post-a-2026, list the 2026 URL in the sitemap, not the old one.
Common cause: automatic sitemap generators that include all URLs (current + legacy/redirected) without filtering. Configure the generator to only include the canonical 200-status URL.
Error 6: HTTPS / HTTP Mismatch
What it means: Your sitemap is served over HTTPS but URLs inside it use HTTP (or vice versa), or your Search Console property is for one protocol and your sitemap URLs use the other.
Fix: ensure consistency. After migrating to HTTPS, update all sitemap URLs to use HTTPS. Verify your Search Console property matches (https://yoursite.com, not http://yoursite.com).
Error 7: Sitemap Exceeds Size Limits
What it means: Your sitemap file is over 50,000 URLs or over 50MB uncompressed. Google rejects the entire file when limits are exceeded.
Fix: split into multiple files and use a sitemap index. Most generators (including ours) auto-split when limits approach. For manual sitemaps, split logically by content type or date:
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<sitemap>
<loc>https://yoursite.com/sitemap-pages.xml</loc>
</sitemap>
<sitemap>
<loc>https://yoursite.com/sitemap-blog.xml</loc>
</sitemap>
<sitemap>
<loc>https://yoursite.com/sitemap-products-1.xml</loc>
</sitemap>
</sitemapindex>Error 8: Duplicate URLs in Sitemap
What it means: The same URL appears multiple times in the sitemap (or across multiple sitemaps in an index). Search engines flag this as a quality issue.
Common cause: CMS generates separate sitemaps for posts and pages, and the same URL is associated with both. Or a sitemap index references overlapping segments.
Fix: deduplicate before publishing. Our generator detects and removes duplicates automatically. For CMS-generated sitemaps, exclude the duplicating post type from one of the segments.
Error 9: Wrong Lastmod Format or Future Dates
What it means: Lastmod values are invalid (wrong format) or impossible (in the future).
Valid formats:
- Date only:
2026-05-22 - Date + time:
2026-05-22T14:30:00+00:00 - Date + time with timezone:
2026-05-22T14:30:00-05:00
Invalid (will fail):
05/22/2026(US format)22-05-2026(DD-MM-YYYY)May 22, 2026(human-readable)- Any date in the future
Fix: regenerate with proper ISO 8601 formatting. Most generators handle this automatically; manual sitemaps need careful date formatting.
Error 10: Cross-Domain URLs Rejected
What it means: Your sitemap includes URLs from domains other than the one the sitemap lives on. Google rejects them unless you've verified ownership of all involved domains.
Example failure: sitemap on yoursite.com includes URLs from blog.yoursite.com — Google treats these as cross-host and rejects them.
Fix:
- Each subdomain should have its own sitemap at its own root
- Or verify a Domain-level property in Search Console that covers all subdomains
- Or split URLs into separate sitemaps per host
Error 11: Sitemap Returns Content-Type text/html
What it means: Your server is serving the sitemap with the wrong MIME type. Search engines expect application/xml or text/xml; some misconfigured servers return text/html instead.
Diagnosis: use a tool like httpstatus.io and check the Content-Type response header for your sitemap URL.
Fix:
- Apache: add to .htaccess:
AddType application/xml .xml - Nginx: in your server block:
types { application/xml xml; } - WordPress: usually handled by SEO plugins; if not, deactivate/reactivate the plugin to refresh the sitemap output
- Static hosts (Netlify, Vercel): usually handled automatically based on .xml extension
Error 12: Pagination Mishandled
What it means: Paginated URLs (page 2, 3, 4 of a listing) appear in the sitemap when they shouldn't, or page 1 is missing, or the whole archive structure creates duplicate issues.
Best practice:
- Include only canonical pages — usually page 1 of any paginated set, plus individual item pages
- Exclude pages 2, 3, 4... from sitemap. They get discovered via internal pagination links.
- If pagination represents unique content (e.g., paginated product listings where each page shows different products), include them but make sure each page has a self-referencing canonical tag
- Use rel=next/prev tags on the pages themselves (no longer used by Google for indexing but still useful for accessibility and Bing)
Systematic Debugging Workflow
When something is wrong but you're not sure what, work through the layers:
- Sitemap loads? Visit URL in browser. If 404, fix upload. If 5xx, fix server. If redirect, update submission URL.
- Sitemap parses? Open the file in a browser — you should see structured XML. If you see a parse-error message, validate with an XML validator.
- Search Console status "Success"? If not, follow the specific error in the report. If yes, move on.
- URLs being indexed? Check Pages report for "Submitted but not indexed." If high count, individual URLs have quality/canonical issues.
- Indexed count matches expected? If much lower than submitted, check Coverage report for the specific reasons each URL was excluded.
- Crawl rate looks healthy? Search Console → Settings → Crawl Stats. Sudden drops correlate with sitemap or robots.txt issues.
Each layer must be working before the next layer matters. Don't try to fix indexing issues if the sitemap doesn't even load.
Preventing Errors at the Source
- Use a validated generator. Our generator catches most syntax-level errors before download.
- Test sitemap URL in a private browser after every change. Catches upload/URL issues immediately.
- Validate XML structure using a sitemap validator after major changes.
- Submit to Search Console once rather than repeatedly. Re-fetch when needed via the Re-fetch button rather than re-submitting.
- Audit quarterly using the checklist from our best practices guide.
- Add CI/CD checks that verify sitemap URL count and validity after each deploy. A sudden drop in URL count usually signals a build problem.
- Match canonical tags, robots.txt, and sitemap content — the three signals must agree. Our best-practices article covers this in depth.
When to Start Over vs Fix Incrementally
If your sitemap has more than 10 distinct errors, or you've inherited a poorly-maintained one, it's often faster to regenerate than to fix piece by piece.
Fresh-start workflow:
- Open our free generator
- Import your existing sitemap (or paste your canonical URL list)
- Apply auto-priority, validation, and segmentation
- Download the validated output
- Replace the old sitemap file
- Submit to Search Console — usually fixes most categorical issues at once
Incremental fixes make sense for issues affecting fewer than 5-10% of URLs. Wholesale rebuild makes sense when issues are widespread or you can't easily identify the root cause.
The debugging principle I carry into every sitemap incident is the same one that works for any layered system: verify from the bottom up and stop guessing. A sitemap has a dependency stack, the file has to exist before it can parse, parse before Search Console accepts it, be accepted before its URLs can index. When someone hands me a "sitemap is broken" ticket, I don't read the error message first; I open the sitemap URL in a browser. Half the time it 404s and the entire rest of the investigation was going to be wasted. The other discipline that matters: when the same error returns monthly, stop re-fixing the file and go fix whatever upstream process keeps regenerating it wrong. A recurring error isn't bad luck, it's a missing guardrail in your publish pipeline.
Frequently Asked Questions
Debug the stack bottom-up, fix the source
Every sitemap error here has a known diagnostic path. Work the layers in order, does the file load, does it parse, does Search Console accept it, do the URLs index, and you'll find the real failure instead of debugging a symptom three layers up. Most one-off errors disappear with a regenerate using our validated generator. For the errors that keep coming back, stop re-fixing the file and add a validation guardrail to your publish pipeline.