How to Generate an XML Sitemap from a REST API

Why generate a sitemap from an API?

A normal sitemap generator usually works by crawling a website. It starts from your homepage, follows internal links, discovers reachable pages, and exports the URLs it finds.

That can work for simple websites. But it becomes fragile when your website is powered by dynamic data.

For example, imagine an e-commerce website where product pages are rendered at URLs like:

Those pages may come from a backend API. The frontend may only display them after JavaScript loads product data, pagination, filters, collections, or search results. A crawler may miss some pages, crawl them slowly, or generate an incomplete sitemap.

Now imagine your backend already has an API endpoint:

And that endpoint returns product data. Instead of crawling the frontend and hoping every product is discoverable, you can map the API response directly into sitemap URLs.

A URL pattern like /products/[response.slug] can generate the exact URLs. This is faster, cleaner, and easier to control.

A crawler sees the website from the outside. Your API shows the source data from the inside. That difference matters.

When an API-based sitemap is better than a crawler

Generating an XML sitemap from a REST API is especially useful when your website has dynamic pages, structured backend data, or a large number of URLs. It is a strong fit for:

A crawler works best when every important page is already linked in plain HTML and easy to discover. An API-based sitemap works better when your website already knows its pages through backend data. If every product, post, category, document, or listing comes from an API, using that API as the source for your sitemap removes a lot of guesswork.

• Single Page Applications
• React websites
• Next.js websites with dynamic routes
• Vue websites
• Nuxt websites
• Headless CMS websites
• E-commerce catalogs
• Product databases
• SaaS documentation
• Real estate listings
• Job boards
• Marketplaces
• Programmatic SEO pages
• Multilingual websites
• Image-heavy websites
• Websites with private or protected API endpoints

How SitemapFlow generates XML sitemaps from API data

SitemapFlow combines static pages and dynamic API routes in the same workflow. The basic process is:

This lets you create a structured XML sitemap without writing custom sitemap code, installing a crawler, or manually copying every URL.

This is the core of API-based sitemap generation: your JSON response becomes the source for your XML sitemap URLs.

• Set your base website domain.
• Add static pages such as home, about, contact, pricing, terms, or privacy.
• Create a dynamic route.
• Connect a REST API endpoint.
• Map fields from the JSON response into URL patterns.
• Add optional image sitemap data.
• Add optional alternate language patterns.
• Set frequency and priority if needed.
• Audit the result.
• Generate and download the final XML sitemap.

How URL patterns work in SitemapFlow

SitemapFlow supports two ways to define dynamic URL patterns: relative paths and full URLs.

A relative path is useful when the generated URLs should use the main website domain or the custom domain configured for the current scope (e.g., /p/[response.id]).

A full URL is useful when a route needs a different domain, subdomain, locale structure, or language-specific path (e.g., https://en.example.com/p/[response.id]).

The same mapping system works in both formats. Any value written after response. is resolved from the API response, including nested fields.

This gives you flexibility to generate sitemap URLs for simple IDs, clean slugs, nested JSON fields, localized paths, alternate language versions, custom domains, and subdomains.

• /p/[response.id]
• /products/[response.slug]
• /users/[response.userId]
• /docs/[response.category.slug]/[response.slug]
• https://es.example.com/productos/[response.slug]

Mapping nested JSON fields into sitemap URLs

Many APIs do not return flat data. A headless CMS, custom backend, or e-commerce API may return nested objects.

With SitemapFlow, you can map nested fields using the response. pattern. For example: /[response.data.product.category.slug]/[response.data.product.slug].

This is useful because you do not need to rewrite your backend response just to generate a sitemap. The sitemap pattern adapts to the structure your API already returns. Common field examples include:

A good XML sitemap generator for API-based websites should be able to work with real API responses, not only perfect flat JSON.

• [response.id]
• [response.slug]
• [response.product.slug]
• [response.data.attributes.slug]
• [response.locale.path]
• [response.images.main.src]

Relative paths vs absolute URLs

Relative paths are usually best when all sitemap URLs belong to the same website domain.

Absolute URLs are better when the generated URL must use a specific domain. This is useful for:

Both formats are valid in SitemapFlow. The important part is choosing the pattern that matches the real URL structure of your website.

• language subdomains
• country-specific domains
• separate storefronts
• special API routes
• brand subdomains
• documentation subdomains
• multi-domain websites

Static pages and dynamic routes should work together

A complete sitemap usually contains two types of URLs: static pages and dynamic routes. Static pages are pages that always exist (/, /about, /contact). Dynamic routes are pages generated from data (/products/[slug], /blog/[slug]).

A crawler may treat all pages the same way, but your website architecture does not. SitemapFlow separates static pages from dynamic API-based routes so you can control both parts clearly. You can add your main pages manually, then use your API response to generate the large dynamic sections of your website.

That gives you a more accurate sitemap structure than relying only on discovered links.

What data should a REST API return for sitemap generation?

A sitemap API does not need to be complicated. In most cases, it only needs the fields required to build the final URLs and optional sitemap metadata. Useful fields include slug, id, category, updatedAt, locale, image, title, description, and canonicalUrl.

For SEO, it is usually better to generate sitemap entries only for public, canonical, indexable pages. That means your API should avoid returning:

A clean sitemap should not be a dump of every possible URL your backend can generate. It should represent the pages you actually want search engines to discover.

• draft posts
• unpublished products
• deleted listings
• private pages
• internal admin pages
• duplicate URLs
• staging URLs
• search result pages with no unique value

Mapping image URLs from an API response

For image sitemaps, SitemapFlow can use either a fixed image URL or a dynamic value from the API response.

If your API returns image metadata, SitemapFlow can also map optional fields such as image title ([response.image.title]) and image caption ([response.image.description]).

This helps when your API contains structured image data for products, real estate listings, articles, recipes, documentation pages, or media galleries.

The image location should point to the actual image URL you want search engines to discover.

Mapping alternate language URLs

SitemapFlow can also generate alternate language patterns for multilingual websites. Alternate language patterns can be created with relative paths or full URLs.

Because the pattern is mapped from the API response, the same product, post, listing, or document can automatically generate its localized sitemap URLs.

This is especially useful for multilingual e-commerce stores, international SaaS websites, translated documentation, and websites using locale folders or subdomains.

API-based sitemaps for headless CMS websites

Headless CMS websites are one of the clearest use cases for REST API sitemap generation.

A headless CMS may store posts, pages, authors, categories, and localized versions. The frontend may be built with React, Next.js, Vue, Nuxt, Svelte, or Astro. The page URLs may not exist as static files, but the CMS API already knows the content.

Instead of crawling your rendered frontend, SitemapFlow can work directly with the CMS response. That makes sitemap creation more predictable for headless websites.

API-based sitemaps for e-commerce websites

E-commerce websites often have thousands of dynamic pages. A store may need sitemap URLs for products, categories, collections, brands, blog posts, and localized pages.

A crawler can miss products if they are hidden behind pagination, filters, infinite scroll, JavaScript rendering, or internal search. An API-based sitemap can use the product catalog directly.

This gives you more control over which pages appear in the final XML sitemap. It also makes it easier to avoid URLs that should not be indexed, such as cart pages, checkout pages, and duplicate variants.

Handling protected API endpoints

Some APIs require headers or API keys before they return data (e.g., Authorization: Bearer YOUR_TOKEN).

SitemapFlow supports HTTP headers for API requests, which makes it possible to generate sitemaps from protected APIs when the endpoint requires authorization.

This is useful for private APIs, staging APIs, protected CMS endpoints, internal product databases, and APIs that return public website data but are not openly accessible.

The API can remain protected while SitemapFlow reads the authorized response and maps the returned fields into sitemap URLs.

Handling large API-based websites

Large websites often need more than one sitemap file. If your site has thousands of products, posts, listings, or localized pages, you should think about structure before generating the final XML.

A large e-commerce website may need separate sitemap files for products, categories, blog posts, images, and localized pages. A sitemap index can reference multiple sitemap files, keeping the structure organized and easier to submit.

Instead of creating one huge sitemap and hoping it stays manageable, you can split your website into logical sections.

Common mistakes when generating sitemaps from APIs

The most common mistake is generating URLs that should not be indexed. A sitemap should focus on canonical, public, indexable pages.

Another common mistake is using the wrong field for the URL pattern. For example, using an ID when the real website URL uses a slug. That mismatch can create sitemap URLs that lead to 404 pages or redirects.

Other common mistakes include:

A good sitemap workflow should include an audit step before export. SitemapFlow is designed to help highlight missing variables, broken API responses, and mapping issues before you submit the final XML.

• missing the domain or using the wrong custom domain
• mixing http and https
• generating duplicate URLs
• including staging URLs
• forgetting locale prefixes
• mapping the wrong nested JSON field
• ignoring API pagination
• generating URLs from drafts or unpublished records

Why SitemapFlow does not depend on traditional crawlers

Traditional crawlers are useful, but they are not always the right tool for dynamic websites.

If your website is powered by JavaScript, API responses, a headless CMS, or a backend catalog, crawling the frontend can be slower and less reliable than reading the source data directly.

SitemapFlow is built around a different idea: Do not crawl the website to guess the URLs. Read the API that already knows the data.

Instead of forcing every website into a crawler-based workflow, SitemapFlow lets you generate a structured XML sitemap from your actual data source.

A simple workflow for API-based sitemap generation

Here is a practical workflow:

• List your static pages.
• Identify your dynamic page types.
• Find the API endpoint for each dynamic route.
• Check which field creates the final page URL.
• Choose a relative path or full URL pattern.
• Map JSON fields with [response.field].
• Add optional image fields and alternate language patterns.
• Generate the sitemap and review the audit report.
• Download the final XML.

Who should use a REST API sitemap generator?

A REST API sitemap generator is useful for developers, SEO specialists, agencies, and website owners who manage dynamic websites.

If your website data already exists in an API, your sitemap can be generated from that data. That is the cleanest path.