How to Create a Sitemap

You need a sitemap. Maybe you just launched a site and want Google to find it. Maybe you inherited a project and realized there's no sitemap in place. Maybe you have one but it's outdated and full of broken URLs. Whatever the reason, creating a sitemap is straightforward -- there are just a few different ways to do it, and the right approach depends on your setup.

Here are four methods, from easiest to most hands-on.

Method 1: Use a CMS Plugin

If your site runs on a CMS like WordPress, Shopify, or Drupal, this is the fastest path. Install a plugin, configure a few settings, and your sitemap generates automatically.

WordPress

WordPress 5.5+ also includes a basic built-in sitemap at /wp-sitemap.xml, but the plugins offer far more control over what's included and how it's structured.

Shopify

Shopify generates a sitemap automatically. There's nothing to install. Your sitemap lives at yourstore.com/sitemap.xml and includes products, collections, blog posts, and pages. It updates whenever you add or remove content.

The catch: you can't customize what's included or excluded. If you need to remove specific pages from the sitemap, you'll need to use a third-party app or handle it through robots.txt.

Other Platforms

• Squarespace: Automatic at /sitemap.xml. No configuration needed.
• Wix: Automatic at /sitemap.xml. Limited customization.
• Webflow: Automatic. You can toggle sitemap inclusion per page in the page settings.
• Drupal: Install the Simple XML Sitemap module for full control.
• Ghost: Automatic at /sitemap.xml.

Method 2: Use an Online Generator Tool

If you don't use a CMS or want a sitemap for a static site, online generators work well for sites under a few thousand pages.

Method 3: Write XML by Hand

For small sites that rarely change, writing a sitemap manually is completely reasonable. It's just an XML file with a specific structure.

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">

</urlset>

<url>
  <loc>https://yoursite.com/</loc>
  <lastmod>2026-02-19</lastmod>
</url>
<url>
  <loc>https://yoursite.com/about</loc>
  <lastmod>2026-01-15</lastmod>
</url>
<url>
  <loc>https://yoursite.com/contact</loc>
  <lastmod>2026-01-15</lastmod>
</url>

Hand-coding works for 5-20 pages. Beyond that, you're introducing unnecessary human error and maintenance burden. Use a generator or programmatic approach instead.

Method 4: Generate Programmatically

If you're building a custom site with a framework like Next.js, Gatsby, Django, Rails, or Laravel, you can generate your sitemap as part of your build or on each request.

Next.js Example

Next.js 13+ has built-in sitemap support. Create a file at app/sitemap.ts:

import { MetadataRoute } from 'next'

export default function sitemap(): MetadataRoute.Sitemap {
  return [
    {
      url: 'https://yoursite.com',
      lastModified: new Date(),
      changeFrequency: 'weekly',
      priority: 1,
    },
    {
      url: 'https://yoursite.com/about',
      lastModified: new Date('2026-01-15'),
      changeFrequency: 'monthly',
      priority: 0.8,
    },
  ]
}

For dynamic routes, fetch URLs from your database:

import { MetadataRoute } from 'next'
import { getAllPosts } from '@/lib/posts'

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const posts = await getAllPosts()

  const postUrls = posts.map((post) => ({
    url: `https://yoursite.com/blog/${post.slug}`,
    lastModified: post.updatedAt,
  }))

  return [
    { url: 'https://yoursite.com', lastModified: new Date() },
    { url: 'https://yoursite.com/about', lastModified: new Date('2026-01-15') },
    ...postUrls,
  ]
}

Node.js with the sitemap Package

npm install sitemap

const { SitemapStream, streamToPromise } = require('sitemap')
const { createWriteStream } = require('fs')

const sitemap = new SitemapStream({ hostname: 'https://yoursite.com' })
const writeStream = createWriteStream('./public/sitemap.xml')

sitemap.pipe(writeStream)
sitemap.write({ url: '/', lastmod: '2026-02-19', changefreq: 'weekly' })
sitemap.write({ url: '/about', lastmod: '2026-01-15', changefreq: 'monthly' })
sitemap.write({ url: '/blog', lastmod: '2026-02-18', changefreq: 'daily' })
sitemap.end()

Django

Django has built-in sitemap support:

# sitemaps.py
from django.contrib.sitemaps import Sitemap
from .models import BlogPost

class BlogSitemap(Sitemap):
    changefreq = "weekly"
    priority = 0.8

    def items(self):
        return BlogPost.objects.filter(status='published')

    def lastmod(self, obj):
        return obj.updated_at

    def location(self, obj):
        return f'/blog/{obj.slug}'

After Creating Your Sitemap: Submit It

Creating the sitemap is half the job. You also need to tell search engines where to find it.

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

Which Method Should You Use?

If you're using a CMS, start with Method 1. If you're building a custom app, jump to Method 4. Methods 2 and 3 are for specific situations where the other options don't apply.

The most important thing is that your sitemap exists, is accurate, and stays current. How you get there matters less than the fact that you get there.

The best sitemap is one that exists. The second best is one that's accurate. Start with any method and improve from there.