A list-to-XML sitemap generator turns up to 10,000 absolute page URLs that you already have into a standards-based sitemap.xml file entirely in the browser, with no crawling, no server upload, and three hard whole-file budgets that fail rather than truncate: 10,000 unique URLs, 5,000,000 UTF-16 input code units, and a 10 MiB UTF-8 byte ceiling. All three caps are all-or-nothing, so each one can independently fail a bulk run; if your reviewed URL list, after URL normalization and XML escaping, fits inside 10,485,760 UTF-8 bytes, the generator produces a complete file, and one byte more fails the run. The keyword "bulk" therefore describes the size of the input you supply, not the scope of any crawl the tool performs. The XML Sitemap Generator accepts one absolute HTTP or HTTPS URL per line, deduplicates entries in first-seen order, applies optional lastmod, changefreq, or priority values you choose, and prepares a local download. All parsing and file creation happen in the current tab; URLs and generated XML never leave your browser. Understanding the inputs, the validation behavior, and the limits in advance turns a bulk run into a one-pass operation rather than a debugging session.
What "Bulk" Means for an XML Sitemap Generator
The bulk workflow here is fundamentally a list-to-XML operation. The XML Sitemap Generator does not crawl your site, does not follow links, does not inspect canonical tags, does not read modification dates, does not discover redirects, does not verify HTTP status, and does not determine indexability. It accepts what you paste, normalizes each accepted line through the WHATWG URL parser, deduplicates, escapes, and emits the official sitemaps.org/schemas/sitemap/0.9 urlset. So "bulk" describes the size of the input you supply, not the size of a discovered output. For most websites this means a reviewed list of canonical, indexable, public URLs that you have already vetted for redirects, private paths, blocked pages, and duplicates. For sites with templated URL patterns (category pages, paginated archives, locale variants, blog indexes), the bulk input can be assembled from a structured list rather than scraped from a live crawl. The XML Sitemap Generator is the right shape for this task precisely because it stays out of the network and treats the list you supply as the single source of truth.
Prepare a Reviewed URL List Before You Paste
A bulk run succeeds or fails on the quality of the URL list you supply. Three habits make the input easy to validate:
- Confirm every line is absolute. Bare domains like example.com/about, relative paths like /about, FTP URLs, and any non-HTTP scheme are rejected outright.
- Strip leading and trailing whitespace on each nonblank line. The generator rejects rather than trims, so a copy-paste from a spreadsheet often needs a quick cleanup pass.
- Decide up front whether you want loc-only XML or shared metadata. If any one URL needs a different lastmod or priority, the tool does not support per-URL overrides; it applies one shared value to the whole file or none at all.
If you need to assemble a large list from a templated pattern such as /blog/page-{n}, a structured walkthrough of the bulk URL generator workflow shows how to step a counter through the range, zero-pad, and produce a clean input file. That precursor step turns a manual editorial exercise into a deterministic, one-click operation.
Apply Optional Metadata Honestly or Leave It Out
The three optional tags are simple in syntax but strict in validation. If you supply them, the same value applies to every URL in the file; if you leave them blank, the resulting XML is loc-only. Per the sitemaps protocol, all three are hints, not commands, and search engines may ignore them.
| Optional tag | Accepted values | Validation behavior |
|---|---|---|
| lastmod | YYYY-MM-DD or full date-time with seconds and Z or a valid UTC offset | Real Gregorian calendar dates, leap years, clock fields, and timezone limits are checked; leading or trailing whitespace is rejected |
| changefreq | always, hourly, daily, weekly, monthly, yearly, never | Any other string fails the whole generation |
| priority | Decimal from 0.0 through 1.0 | Out-of-range values fail the whole generation |
Use lastmod only when a single shared value is truthful for every entry, for example the date of a site redesign or a major content audit. When the truth varies per URL, leave the optional fields blank; loc-only XML is the most honest representation.
Generate, Review, and Download sitemap.xml
- Open the XML Sitemap Generator in your browser and confirm the editor is empty.
- Paste your reviewed list into the URL box, one absolute HTTP or HTTPS URL per line. Use one host, including any non-default port, per file.
- Leave the optional lastmod, changefreq, and priority fields blank for loc-only XML, or fill them with a single shared value that is truthful for every entry.
- Click Generate. Read any line-level error the tool reports and return to your list rather than the metadata fields.
- Review the rendered XML, the URL count, and the duplicate count in the preview. Confirm every URL you expected is present in the order you supplied it.
- Click Download to save sitemap.xml, then reference it from robots.txt and host it on the represented site.
Editing any field revokes the current download and clears the old XML, so regenerate after every change. The previous Object URL is released before the new validation runs, so no stale file lingers in your downloads.
Limits and Failure Modes in a Bulk Run
The sitemaps.org protocol permits up to 50,000 URLs and 52,428,800 uncompressed bytes per file. This browser tool uses lower whole-file budgets to keep parsing, preview, Blob, and browser memory predictable, including a 5,000,000 UTF-16 input code units cap on the pasted URL list itself that can fail a run before output size is even measured.
| Constraint | Protocol maximum | XML Sitemap Generator |
|---|---|---|
| Unique URLs per file | 50,000 | 10,000 |
| Uncompressed file size | 52,428,800 bytes | 10,485,760 bytes (10 MiB) |
| Characters per loc | fewer than 2,048 | fewer than 2,048 |
Each limit is all-or-nothing. The 10,000th unique URL is accepted and the next unique URL fails the whole generation. Duplicate lines do not consume output slots, so they never push a valid URL past the cap. The exact 10,485,760-byte boundary is accepted; one additional byte is rejected. No shortened XML, ellipsis, capped preview, or partial download is returned. If your real URL list exceeds 10,000 entries, split it into multiple files and reference them from a sitemap index, or trim entries that are not worth indexing.
Validation Behavior in a Bulk Paste
Validation is line-by-line and never silent. The generator rejects bare domains, relative paths, FTP URLs, raw whitespace, control characters, malformed percent escapes, embedded credentials, and fragments. HTTP and HTTPS URLs for the same host are accepted in the same file because the scheme is not part of the host comparison; different non-default ports are not accepted together. An uppercase host and its lowercase form identify the same URL, as do an explicit default port and its normalized form. As a behavioral example, the URL https://Example.COM:443/Blog/Post-1 normalizes to https://example.com/Blog/Post-1: the host is lowercased, the default port is removed, and the root slash is preserved.
Whitespace-only lines are ignored, but leading or trailing whitespace on a nonblank line is an error rather than being silently trimmed. Credentials are rejected so a username or password cannot be copied into a public sitemap. Fragments are rejected because they are not sent to the server as part of the HTTP request and should not create multiple sitemap entries for one fetched resource.
What This Bulk Generator Does Not Do
Knowing what the tool deliberately does not do is part of using it correctly. The XML Sitemap Generator does not crawl your site, does not submit the sitemap, does not create sitemap indexes, and does not emit image, video, news, or hreflang extensions. It does not gzip the result, does not edit robots.txt, and does not call Search Console. Per Google's build and submit a sitemap documentation, those steps remain your responsibility. The URL parser follows the WHATWG URL Standard: it lowercases host names, removes default ports, adds the root slash when required, and percent-encodes non-ASCII components. That normalization is what makes deduplication trustworthy across mixed HTTP and HTTPS, trailing slashes, and case differences.
Practical Tips for a One-Pass Bulk Run
A few habits turn the bulk workflow into a one-pass operation:
- Smoke test with five URLs first. Paste a short list, generate, download, and inspect the XML in a text editor to confirm formatting before pasting the full bulk list.
- Pre-sort or pre-dedupe in your spreadsheet. The XML Sitemap Generator dedupes in first-seen order, so the first occurrence determines output position. Knowing the duplicate count in advance prevents surprises.
- Audit mixed HTTP and HTTPS entries. The generator accepts both schemes for the same host, but you usually want to canonicalize to one scheme before publication.
- Generate templated lists before pasting. For /blog/page-{n} patterns or locale variants, build the URL list with a structured tool first; manually typing 500 category URLs is the most common source of typos in a bulk run.
- Skip parameter-driven variants. Do not include query parameters that change page content (session IDs, sort orders) unless you want every variant indexed; the dedupe operates on normalized URLs, not on visible page output.
Because all processing happens in the current browser tab, the only constraint on a bulk run is the device you are using. A modern desktop browser will preview a 10 MiB XML without trouble; older phones may render the preview slowly even though the file is computed correctly. Plan the input, choose the optional metadata once, and run the generator in a single pass.
Related reading: Extract URLs From a Sitemap Without an API.