Command line and online sitemap generators solve two different problems: CLI tools usually crawl your live site to discover URLs, while online list-to-XML tools such as the XML Sitemap Generator convert a URL list you have already curated into a standards-shaped sitemap.xml file. The choice that follows from that single sentence drives almost every other decision in this comparison. A CLI crawler works when your content lives behind no login, fits inside a single host, and is small enough to traverse in one pass. An online list-to-XML builder works when you already trust the URL list — typically because you pulled it from analytics, a CMS export, or a previous crawl — and you only need a correctly formatted, downloadable XML file. Because each method targets a different starting state, the question "command line vs online" is rarely about which is universally better and almost always about which matches the data you actually have ready. Understanding that distinction prevents the most common mistake: running a crawler against a site whose URL list is already known, or trying to build an XML file from a half-remembered mental list of pages.
What "Command Line" and "Online" Actually Mean for Sitemaps
Most people searching "sitemap generator command line vs online" have already used a terminal or a web tool at least once and want a clean division of labor between the two. A command line sitemap tool is a program you install or run on a server. Examples include dedicated Go or Node CLIs, Python scripts that hit a public endpoint, and shell wrappers around existing crawler libraries. The defining behavior is that the tool requests pages itself: it fetches the homepage, follows the links it finds, normalizes what it discovers, and writes the resulting XML to a file on disk. Many CLI tools also write sitemap indexes, gzip the output, and offer flags for crawl depth, user agent, request delay, and excluded paths.
An online sitemap generator is a broader category, and it helps to split it in two. The first kind is a hosted crawler — you type a domain into a website, that website crawls the pages from its own servers, and you download the result. The second kind is a list-to-XML utility, and that is what the XML Sitemap Generator is. A list-to-XML utility takes a plain-text list of URLs pasted into the page, validates each line against the sitemap protocol, normalizes and serializes them with the browser URL parser, deduplicates by first occurrence, and emits a downloadable sitemap.xml without ever requesting any of those URLs from the network.
When a Command Line Sitemap Tool Is the Better Fit
A command line tool earns its place when discovery, not formatting, is the bottleneck. Concrete situations where a CLI fits include: a brand-new site whose internal linking has just been redesigned and the URLs have not yet been enumerated; a large catalog where discovery would otherwise be a multi-day spreadsheet project; a staging environment where requests can be throttled and redirects followed from the host itself; and integration into CI pipelines that rebuild the sitemap on every deploy. CLI tools also tend to expose flags an online tool cannot easily match: per-path include and exclude rules, lastmod pulled from HTTP Last-Modified headers, and the option to chunk output into a sitemap index when the URL count exceeds the 50,000-URL protocol maximum.
The cost of running a CLI tool is real and worth naming. Shell access is required, an environment must be set up where dependencies can be installed, and confidence is needed that the server is allowed to crawl its own pages quickly without triggering rate limits, WAF rules, or staging-only firewalls. CLI crawlers can also pick up pages that were never meant to be published: admin paths, internal search results, tag archives, paginated comment feeds, parameter-driven duplicates, and soft-404 URLs that look like real pages to a crawler. A list-to-XML utility will never accidentally include those, because it only includes the URLs typed into the editor.
When an Online List-to-XML Tool Is the Better Fit
An online list-to-XML tool like the XML Sitemap Generator fits when discovery is already done and the file is what is actually needed. The URL list might come from a CMS export, a previous crawl, an analytics filter for indexed landing pages, or a hand-curated set of canonical URLs the marketing team has approved. The tool's job in that case is narrow and specific: validate every line, serialize each accepted URL with the browser URL parser, deduplicate by first occurrence, optionally add shared lastmod, changefreq, or priority, and produce an XML file in the official http://www.sitemaps.org/schemas/sitemap/0.9 namespace. All of it runs in the current browser tab, so no URLs and no XML are uploaded to a remote server.
The list-to-XML approach also fits sensitive environments. Sites under compliance review, internal pre-production builds, and staging mirrors can be mapped without installing any software or running a crawler that leaves request logs behind. Editing the URL list, swapping a host, or changing optional metadata immediately revokes the previous download so no stale XML file survives. When a line fails — a fragment, a credential, a non-default port on a different host, a malformed percent escape, leading or trailing whitespace — the entire generation fails rather than silently dropping the line, which makes it easier to spot the exact URL that needs fixing.
How to Build sitemap.xml From a Reviewed URL List
Putting the list-to-XML approach into practice with the XML Sitemap Generator takes five concrete steps. None of them require shell access, a server, or a staging environment.
- Open the tool and paste one absolute HTTP or HTTPS page URL per line into the URL list. Use one host per file. If the site serves both schemes on the same host, both can be included; if it uses a non-default port, keep that port consistent across every URL in the file.
- Leave the optional lastmod, changefreq, and priority fields blank if only loc entries are wanted. Otherwise supply a truthful shared value that applies to every URL in the file — for example, the date the URL list was last reviewed, a single change frequency that genuinely fits the whole set, or a single priority between 0.0 and 1.0.
- Click Generate and read the on-page result. The generator validates every line, normalizes each URL with the browser URL parser, removes duplicates while keeping the first occurrence, escapes XML entities (ampersand, apostrophe, quotation mark, greater-than, less-than), and shows the complete file along with line counts.
- Review the output for redirects, duplicates, blocked pages, private pages, and missing pages. The file is only as accurate as the URLs and metadata supplied, so this review step is where protocol compliance is actually guaranteed.
- Download sitemap.xml from the temporary Object URL provided on the page. Publish it at the conventional location on the represented site, then reference it from robots.txt if that is part of the workflow.
After download, the typical follow-up is submitting the sitemap to the search engines that matter for the site. The XML Sitemap Generator does not submit on the user's behalf and does not write robots.txt rules, so those steps live outside the tool. The file itself is a complete, UTF-8, namespaced XML document ready to upload over FTP, push through a CI artifact, or paste into a static-site generator.
Limits, Validation, and Things Neither Method Will Fix
The Sitemaps XML protocol permits up to 50,000 URLs and up to 52,428,800 uncompressed bytes per file. Google's build and submit a sitemap documentation reflects the same limits. The XML Sitemap Generator uses deliberately lower whole-file budgets: 10,000 unique URLs, 5,000,000 UTF-16 input code units, and 10,485,760 UTF-8 XML bytes. The lower limits bound parsing, preview, Blob memory, and browser tab size so the tool fails explicitly rather than producing a truncated file. Every limit is all-or-nothing — the 10,000th unique URL is accepted, the next unique URL is rejected, and the exact 10,485,760-byte file is accepted while one additional byte is rejected. Duplicate lines do not consume output slots, so a noisy list does not silently shrink the file.
Validation is where the protocol rules actually live, and both methods need to honor them. Each nonblank line must be an absolute HTTP or HTTPS URL, with one serialized host per file including any non-default port. Bare domains, relative paths, FTP URLs, raw whitespace, control characters, malformed percent escapes, embedded credentials, fragments, leading or trailing whitespace on a nonblank line, and non-absolute input are rejected. A line that fails fails the whole generation; nothing is skipped, nothing is silently dropped. Optional metadata, if supplied, must be truthful: a real Gregorian YYYY-MM-DD date or a complete date-time with seconds and Z or a valid UTC offset for lastmod; one of always, hourly, daily, weekly, monthly, yearly, or never for changefreq; a decimal between 0.0 and 1.0 for priority. Invalid optional metadata fails the whole generation, not just the offending entry.
Neither a CLI crawler nor an online list-to-XML tool will verify HTTP status, inspect canonical tags, follow redirects, check indexability, or submit the result to a search engine. Those are pre-publication review tasks. Sitemap priority and changefreq are protocol hints, not crawl commands or ranking signals. The XML Sitemap Generator does not create sitemap indexes, image, video, or news extensions, hreflang markup, gzip files, robots.txt rules, or Search Console submissions. For a quick reference of every rule the tool enforces, the XML Sitemap Generator cheat sheet summarizes the validation behavior in one page.
Command Line vs Online Sitemap Generator at a Glance
The dimensions that most often decide between a CLI crawler and a list-to-XML utility can be read off a single table. None of these rows are computed from the tool; they describe the relationship between the two methods so the right choice is visible before any line is pasted or any flag is set.
| Dimension | Command Line Crawler | Online List-to-XML Tool |
|---|---|---|
| Starting input | A domain to crawl from scratch | A reviewed URL list already on hand |
| Network behavior | Requests every page from the host | No outbound requests; runs in the browser tab |
| Where data is processed | On the machine or server running the CLI | Inside the current browser tab |
| Discovery of new URLs | Yes, by following links | No, only the URLs pasted in |
| Typical use cases | New sites, large catalogs, staging audits, CI rebuilds | Existing URL lists, sensitive sites, quick republishes |
| Limits to watch | Crawl depth, request rate, host throttling | 10,000 unique URLs and 10 MiB per file |
| Failure mode | Often silent skips; results vary by tool | All-or-nothing rejection of bad lines and bad metadata |
Picking between the two comes down to one question: do you need to discover URLs, or do you already have them. If discovery is the bottleneck, install a CLI crawler and budget time for filtering the noisy output it inevitably produces. If the URL list is already trusted, the online list-to-XML path is faster, leaves no request logs behind, and fails loudly on every line that does not match the sitemap protocol. The XML Sitemap Generator sits firmly in that second category and is the right choice whenever the answer to that question is "I already have the list."