How to Submit a Sitemap to Google Search Console

A sitemap does exactly one job: it tells Google which URLs exist and are worth its attention. It is a discovery aid, not a ranking factor and not an indexing guarantee. Google will still make its own call on every URL you list — but it cannot index a page it never found, and on large or poorly linked sites a sitemap is often the only way a page gets found at all.

What a valid sitemap looks like

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://example.com/</loc>
    <lastmod>2026-07-13</lastmod>
  </url>
  <url>
    <loc>https://example.com/guides/</loc>
    <lastmod>2026-06-02</lastmod>
  </url>
</urlset>

That is the whole format. Two tags matter and two do not:

Hard limits

• 50,000 URLs per sitemap file.
• 50 MB uncompressed per file. Gzip is allowed and encouraged.
• Exceed either limit and you need a sitemap index — a sitemap that lists other sitemaps. The index itself is capped at 50,000 entries.

Submitting it

1. 1

   Confirm it loads

   Open the sitemap URL in a browser first. If it 404s, redirects, or renders as HTML instead of XML, fix that before going near Search Console.

2. 2

   Reference it in robots.txt

   Add a Sitemap: line with the absolute URL. Every crawler reads robots.txt, so this exposes your sitemap to Bing and others too, not just Google.

3. 3

   Submit in Search Console

   Open the Sitemaps report, enter the path (sitemap.xml), and submit. You only ever need to do this once per sitemap.

4. 4

   Check back in a day or two

   Status should read Success with a discovered-URL count. 'Couldn't fetch' means Google could not read it — see below.

# robots.txt
User-agent: *
Allow: /

Sitemap: https://example.com/sitemap.xml

Generating one in Next.js

The App Router generates and serves the XML for you from a single file — no build step, no third-party package:

// src/app/sitemap.ts
import type { MetadataRoute } from "next";

export default function sitemap(): MetadataRoute.Sitemap {
  return [
    { url: "https://example.com", lastModified: new Date("2026-07-13") },
    { url: "https://example.com/guides", lastModified: new Date("2026-06-02") },
  ];
}

Derive the list from the same source your routes come from — a content directory, a CMS query, a database. A hand-maintained array is a sitemap that is wrong within a month, because the one thing nobody remembers to update when shipping a new page is the sitemap.

Rules that keep a sitemap trustworthy

• Only list URLs that return 200. No redirects, no 404s, no soft 404s.
• Only list canonical URLs. If a page canonicalizes elsewhere, it does not belong here — listing it contradicts your own canonical tag.
• Never list noindexed URLs. You are simultaneously asking Google to crawl it and refusing to let it index it.
• Use one consistent hostname. If the site serves from the apex, every <loc> uses the apex. A sitemap full of URLs that redirect to the other hostname is how a whole site ends up filed under 'Page with redirect'.
• Match your canonical tags exactly — same protocol, same host, same trailing-slash convention.

'Couldn't fetch' — what it really means

This error is badly named. It rarely means Google failed to reach the file; more often it reached it and could not accept it.

Once the sitemap reads Success, the story moves to the Page indexing report — that is where you find out what Google decided to *do* with the URLs you handed it.