Verifying your domain on Google Search Console (Vercel + Namecheap), plus the sitemap step everyone skips

So I shipped this site, felt great about it, and then googled it. Nothing. Not on page 5, not with site:. Google straight up didn't know it existed.

That's normal, by the way. Deploying a site doesn't tell Google anything. You have to (1) prove to Google that you own the domain, and (2) tell it what pages you have. Most tutorials cover step 1 and then wave vaguely at step 2. This one covers both, because verification without a sitemap is like getting a library card and never telling the library you wrote a book.

My setup: domain bought on Namecheap, site hosted on Vercel, Next.js App Router. If that's you, this is copy-paste territory.

First, figure out who actually controls your DNS

This is where most people burn 20 minutes. If you connected your domain to Vercel the recommended way, you pointed Namecheap's nameservers at Vercel (ns1.vercel-dns.com / ns2.vercel-dns.com). That means Namecheap no longer answers DNS queries for your domain. Vercel does.

So when Google asks you to add a TXT record and you dutifully add it in Namecheap's Advanced DNS panel... nothing happens. Ever. The record lives in a panel nobody's reading.

Run this quick check:

dig NS yourdomain.com +short

If you see vercel-dns.com in there, your DNS lives in Vercel. Add records there. If you see Namecheap's nameservers instead (you set an A record manually), then Namecheap's Advanced DNS is the right place. Everything below assumes Vercel.

Add the property in Google Search Console

Go to Google Search Console and add a property. You get two options:

• Domain. Covers everything (http, https, www, subdomains) and requires DNS verification.
• URL prefix. Covers exactly one URL variant, but offers easier verification methods (HTML file, meta tag).

Pick Domain. You're already doing DNS verification anyway since your setup makes it easy, and you never have to think about the www vs non-www split again.

Google will hand you a TXT record that looks like this:

google-site-verification=aBcD3FgH1jKlMn0pQrStUvWxYz...

Copy it. Don't close the tab.

Add the TXT record in Vercel

In the Vercel dashboard, open the Domains tab for your team, click your domain, and go to DNS Records. Or go straight to vercel.com/<team>/~/domains.

Add a record:

Save it. That's the entire Vercel side.

Wait less than the tutorials say

Every guide says "propagation can take up to 48 hours." Real talk: with Vercel DNS it's usually live in a couple of minutes. Check it yourself instead of anxiously refreshing:

dig TXT yourdomain.com +short

When your google-site-verification=... string shows up in the output, go back to the Search Console tab and hit Verify. If dig sees it and Google still says no, wait a few minutes, because Google caches DNS on their end too. dnschecker.org is handy if you want to see propagation across regions.

Green checkmark. You own the domain. Now the part everyone skips.

Actually submit a sitemap

Verification just proves ownership. Google still doesn't know what pages you have. It'll find them eventually by crawling, but "eventually" for a brand new domain with zero backlinks can be weeks. A sitemap is you handing Google the list directly.

If you're on Next.js App Router, you don't need a package. Drop a sitemap.ts in src/app/ and Next serves /sitemap.xml for free:

import type { MetadataRoute } from "next";
import { SITE_URL } from "@/lib/constants";
import { getAllPosts } from "@/lib/posts";

export default function sitemap(): MetadataRoute.Sitemap {
  const staticRoutes: MetadataRoute.Sitemap = [
    { url: `${SITE_URL}/`, changeFrequency: "weekly", priority: 1 },
    { url: `${SITE_URL}/blog`, changeFrequency: "weekly", priority: 0.9 },
    { url: `${SITE_URL}/about`, changeFrequency: "monthly", priority: 0.8 },
  ];

  const postRoutes: MetadataRoute.Sitemap = getAllPosts().map((post) => ({
    url: `${SITE_URL}/blog/${post.slug}`,
    lastModified: new Date(post.date),
    changeFrequency: "yearly",
    priority: 0.7,
  }));

  return [...staticRoutes, ...postRoutes];
}

Mine reads the blog posts from disk at build time, so every new post lands in the sitemap automatically. There's no manual list to forget about.

Before submitting anything, open https://yourdomain.com/sitemap.xml in a browser and actually read the URLs. This is where I got burned. My SITE_URL env var had a trailing slash, so every entry came out with a double slash, like https://yourdomain.com//blog/whatever. It looks harmless, but those aren't the canonical URLs of my pages, so Google would've treated every single entry as a different (and broken-ish) URL. The fix was stripping the trailing slash where the constant is defined:

export const SITE_URL = (
  process.env.NEXT_PUBLIC_SITE_URL ?? "http://localhost:3000"
).replace(/\/$/, "");

A dumb bug with a five-second fix, and it would've quietly sabotaged the whole indexing effort.

While you're at it, make sure your robots.txt points at the sitemap too (App Router: src/app/robots.ts):

import type { MetadataRoute } from "next";
import { SITE_URL } from "@/lib/constants";

export default function robots(): MetadataRoute.Robots {
  return {
    rules: { userAgent: "*", allow: "/" },
    sitemap: `${SITE_URL}/sitemap.xml`,
  };
}

Then go to Sitemaps in the Search Console sidebar, enter sitemap.xml, and hit Submit. If everything's right you'll see status "Success" with a discovered-pages count.

If you get "Couldn't fetch" instead, don't panic. It's often just Google being slow on a fresh property, so check again the next day before debugging. If it persists, curl the sitemap URL yourself and make sure it returns 200 with actual XML. The usual suspects are a redirect to www, an auth wall on a preview deployment, or a plain 404.

Now what

Honestly? You wait. Submitting a sitemap doesn't mean instant indexing. It means Google knows your pages exist and will get to them on its own schedule. For a new domain that took a few days to a couple of weeks in my experience, and some pages get picked up way before others.

Two things worth doing in the meantime:

• Paste your most important URLs into URL Inspection (the top search bar in Search Console) and hit Request Indexing. It nudges Google to prioritize them. No guarantees, but it's free.
• Come back in a week and check Pages under Indexing. That's where you'll see what got indexed and, more usefully, why something didn't.

That's the whole loop: TXT record in Vercel (not Namecheap!), verify, check your sitemap URLs with your own eyes, submit, request indexing on the pages you care about, then go build something while Google does its thing.