How to submit your sitemap to Google Search Console

You submit a sitemap from the Sitemaps page in Google Search Console, after your site has been added and verified there. A sitemap is a file, usually at an address like yourdomain.com/sitemap.xml, that lists the pages on your site you want search engines to find. Submitting it tells Google where that list lives, so it can discover new pages sooner than it would by following links alone.

The steps by hand look like this:

1. Find your sitemap. Most website builders create one for you. Shopify, Wix, and Squarespace publish it at /sitemap.xml, Webflow generates one when you turn it on in your site's SEO settings, and WordPress has a built-in sitemap at /wp-sitemap.xml unless an SEO plugin such as Yoast replaces it with its own. Open the address in your browser to confirm it loads.
2. Add your site to Search Console and verify it. A Domain property covers every version of your site, including www and every subdomain, and you verify it by adding a TXT record at your domain provider. A URL-prefix property covers one exact address, and you can verify it with an HTML file, a meta tag, Google Analytics, or Google Tag Manager.
3. Submit the sitemap. In the property, open Sitemaps under Indexing, enter the sitemap's address, and select Submit.
4. Check the result. The Sitemaps page shows whether Google read the file successfully, couldn't fetch it, or found errors, along with how many pages it discovered. The Page indexing report then shows which of those pages made it into Google and why the rest didn't.

You can also point Google to your sitemap with a line in your robots.txt file that gives its full address. Google retired its old sitemap "ping" address in 2023, so the Search Console submission and the robots.txt line are the two routes left.

What makes this job worth doing well is everything around the Submit button. A sitemap is a suggestion, not an order. Google decides what to index, and a sitemap full of redirected pages, pages marked noindex, or duplicate addresses teaches it to trust the file less. A good result is a sitemap that lists every live page you want found and nothing else, a property you control, a submission Google read without errors, and a check a few days later that your important pages are actually indexed.

Kite does that whole job. On sites it hosts, the sitemap and the submission are part of publishing. On sites hosted elsewhere, it works through your connected Search Console account.

Start by asking Kite in Slack to get your site into Google:

"We just launched our new site. Make sure Google can find all the pages."

Kite is an AI marketer in your Slack. It researches your business, builds a growth strategy, and ships the work that brings you new customers. It already knows which site is yours and where it runs, so it can tell you which of the two routes below applies before it starts.

If Kite built and hosts your site, there's usually nothing to set up. Sitemap submission runs on its own when your site uses your own domain and your team is on a paid plan. If you bought the domain through Kite, Kite also handles the domain verification. If your domain is registered somewhere else, the publish window asks you to finish one short step that updates your domain settings, and Kite takes it from there.

If your site runs somewhere else, connect your Google account through OAuth so Kite can work in Search Console. Kite works with the properties that account can see, at the permission level Google gives it. Submitting a sitemap needs owner or full-user permission on the property.

Kite checks the sitemap before it submits anything, because a clean file is what makes the submission worth doing. Every indexable live page should appear in it exactly once, at its final address. Pages that redirect, pages marked noindex, pages that return errors, and duplicate addresses shouldn't be in it at all.

On a site Kite hosts, the sitemap is part of the site's code and Kite keeps it current as it works. When it publishes a new page, the page joins the sitemap. When it deletes a page, the entry comes out. When it changes a page's address, it updates the sitemap entry and adds a redirect from the old address in the same change. The site's robots.txt names the sitemap's full address, so any search engine that reads robots.txt finds it too.

On a site hosted elsewhere, Kite reads the sitemap file and your robots.txt directly. It checks that the file loads, that it's valid XML, and that the pages it lists are live and meant to be indexed. When a sitemap is too big for one file, which Google sets at 50,000 addresses or 50 MB, Kite looks for a sitemap index that points to the smaller files. If something's wrong, Kite tells you what to change and where, such as a setting in your SEO plugin or a page that needs removing from the list.

Kite confirms that the site is a verified property before it submits, because Google only accepts sitemaps for properties you've proved you own.

On a site Kite hosts, Kite verifies the domain with its own Google account. It asks Google for a verification code, adds it to your domain as a TXT record, and keeps checking with Google for about half an hour while the record spreads across the internet. Once Google confirms ownership, Kite registers the domain as a Domain property, so the one property covers your whole site, including www and any subdomains.

Through your connected account, Kite lists the properties you already have in Search Console and reads each one's permission level. It matches your site's address to the right property exactly, because Google treats https://www.example.com/ and example.com as different properties. If the site isn't there yet, Kite can add it as a new property, and you finish the ownership step in Search Console.

Kite submits the sitemap's full address to the verified property, which is the same thing that happens when you select Submit on the Sitemaps page.

On a site Kite hosts, this happens after every publish. Kite submits yourdomain.com/sitemap.xml so Google hears about new and changed pages as soon as they go live. If the domain is still waiting on verification when you publish, Kite holds the submission and sends it the moment verification finishes. If verification can't finish, Kite tries again the next time you publish. The publish window shows where things stand, from preparing your site, to waiting for Google to confirm your domain, to ready to be discovered by Google.

On a site hosted elsewhere, Kite submits the sitemap through your connected account. That works for a standard sitemap, a sitemap index, or an RSS or Atom feed. Once Google has the sitemap, you don't need to resubmit it every time a page changes, because Google comes back to it on its own. Kite resubmits when the sitemap's address changes or after a big batch of new pages.

Kite reads Google's report on the sitemap after submitting, so you know whether the submission actually worked. Through your connected account, it reads when the sitemap was last submitted, when Google last downloaded it, whether it's still pending, how many addresses Google found in it, and any errors or warnings.

Each kind of problem points to a different fix. When Google couldn't fetch the file, the address is usually wrong, the file is blocked by robots.txt, or the server returned an error. When the file has errors, an entry is usually malformed or points outside the property. Kite names the problem, makes the fix on a site it manages, and tells you the exact change on one it doesn't.

Kite inspects your most important pages one at a time, because a sitemap Google read successfully still doesn't guarantee the pages made it into Google. For each page, it reads whether Google has indexed it, when Google last crawled it, which address Google chose as the main version, and any issue blocking it.

Kite chooses which pages to inspect first: your homepage, your main product and pricing pages, and anything you just published. Google limits how many inspections an account can run, so Kite spends them on the pages that matter most. Google's reports also lag the live site by a few days, so Kite waits before it reads a result again.

Google doesn't let outside tools request indexing for ordinary pages. When an important page still isn't indexed, Kite gives you its address so you can paste it into the URL Inspection tool in Search Console and select Request Indexing.

When the work is done, Kite posts a summary in the Slack thread where you asked. It says which property it used, which sitemap it submitted and when, what Google reported back, and which important pages are indexed and which aren't yet, with the reason for each. If you ask, Kite checks again on a schedule, such as every Monday, and posts only what changed.

When Kite finishes, Google has a clean, current list of your pages, and you know which of them have made it into search.