# One screenshot per template, not per page

> Check a site before launch with a few pictures, not thousands. Five real sitemaps grouped by page template, a sampler to paste yours into, and an audit sheet.

Pre-launch audit by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 8 November 2026. Page for people: https://curlshot.com/blog/screenshot-one-page-per-template

To check every kind of page on a site, take one screenshot per page template, not one per page. Group the addresses from the sitemap by their first path segment and the number of segments, then capture one or two samples of each group at 390 and 1280 px wide. In five public sitemaps read on 8 November 2026, 29,613 addresses fell into 22 groups and 106 into 20. With CurlShot, two widths of every group of any of the five sites fit in the 100 screenshots of the Free plan.

## Key facts

- A site with 29,613 listed addresses had 22 groups by path shape. The number of templates grows far slower than the number of pages.
- From 1 to 5 groups held 80 percent of the addresses of each of the five sites in the run of 8 November 2026.
- Group by the first path segment and the depth, then take the middle address of each group and a page of its own for every group of one. Two or three samples are safer for a big group.
- Six things are worth a look in each picture: sideways scroll at 390 px, empty blocks, banners over content, an error inside a 200, a fallback font and a sticky bar.
- CurlShot counts one successful render as one screenshot, so 40 pictures for its own 106 addresses use 40 of the 100 on the Free plan.

## The number

29,613 addresses are listed in the sitemap of postgresql.org on 8 November 2026. They fall into 22 groups by the shape of the path, and one group of 28,312 addresses is the documentation. A pre-launch check needs a picture of each kind of page, not of each page.

## What five real sitemaps showed

Each sitemap was downloaded once, with one request per file. Sitemap indexes were followed one level down; for kubernetes.io only the English sitemap was read. Every address was grouped by its first path segment and the number of path segments, with the same function that runs in the sampler on this page.

| Site | Addresses | Groups | Groups with one address | Groups that hold 80% | Largest group |
| --- | --- | --- | --- | --- | --- |
| curlshot.com | 106 | 20 | 15 | 4 | blog / depth 2 (28) |
| nodejs.org | 1,670 | 6 | 1 | 2 | en / depth 4 (1,072) |
| kubernetes.io (English) | 1,889 | 23 | 13 | 4 | blog / depth 5 (570) |
| laravel.com | 944 | 30 | 13 | 5 | blog / depth 2 (443) |
| postgresql.org | 29,613 | 22 | 9 | 1 | docs / depth 3 (28,312) |

What the numbers say:

- The number of groups stays between 6 and 30, while the number of addresses runs from 106 to 29,613.
- From 1 to 5 groups hold 80 percent of the addresses of each site.
- The rule is blunt. The one large group of postgresql.org holds the manual of every version, and one sample does not see the difference between them. Take two or three samples from a big group.
- A group of one address is a page of its own, such as the home page or the pricing page. Always take it.

## The sampler

Paste a sitemap or a list of addresses on the page and it shows the groups, the samples and the number of pictures. Two widths (390 and 1280 px) and one sample per group give 40 pictures for CurlShot's own 106 addresses. The Free plan has 100 screenshots a month.

## The audit sheet

Look at each picture for these six things.

| Check | What to look for | Why it shows up | What to do |
| --- | --- | --- | --- |
| Sideways scroll at 390 | In the 390 px picture, content runs past the right edge, or the page is wider than the picture and text is cut. | One wide element, often a table, a code block or a fixed-width image, is enough to push a whole template. | Find the element with a width in pixels and give it max-width: 100%, or let its container scroll. |
| Empty or half-drawn blocks | Grey placeholders, spinners or white gaps where content should be. | The picture was taken before the data arrived. It can be the template, or only the capture. | Retake with wait_until=networkidle or wait_for_selector on the block. If the gap stays, it is a real bug. |
| Banner over the content | A cookie notice, chat bubble or promo bar covers text or a button. | Overlays are added site-wide, so they show on every template at once. | Ask for the capture without the cookie banner for review pictures, and check the real page at 390 for the rest. |
| An error inside a 200 | A picture that says "not found" or shows an empty list, for an address the sitemap lists. | A page can answer 200 and still show an error, so a status check alone passes it. | Open that address by hand. Remove it from the sitemap or fix the page. |
| Fallback font or missing image | Headings in a plain system font, or an image shown as an empty frame. | A font or image address that works on the developer machine can be blocked or wrong for the public. | Open the address of the font or image in a private window and fix the path or the headers. |
| Sticky bar in the middle of a full-page picture | A header or footer bar repeated or sitting across the middle of a tall picture. | Fixed elements are drawn once at the position the capture happened to use. | Treat it as a capture artefact first. Compare with the first-screen picture before you change the page. |

## The script

```javascript
// node audit.mjs https://example.com/sitemap.xml --dry   (list the plan, send nothing)
// node audit.mjs https://example.com/sitemap.xml         (take the pictures)
import { mkdir, writeFile } from 'node:fs/promises'

const [sitemap, flag] = process.argv.slice(2)
const WIDTHS = [390, 1280]
const PAUSE_MS = 7000 // 10 requests a minute on the Free plan

const decode = (s) => s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
async function locs(url) {
  const response = await fetch(url)
  if (!response.ok) throw new Error(`${url}: HTTP ${response.status}`)
  const xml = await response.text()
  const found = [...xml.matchAll(/<loc>\s*([^<\s]+)\s*<\/loc>/g)].map((m) => decode(m[1]))
  if (!/<sitemapindex[\s>]/.test(xml)) return found
  const all = [] // an index lists other sitemaps: read each one in turn
  for (const child of found) all.push(...(await locs(child)))
  return all
}

// One group per first path segment and path depth: blog / depth 2, docs / depth 3, ...
const groups = new Map()
for (const address of new Set(await locs(sitemap))) {
  const parts = new URL(address).pathname.split('/').filter(Boolean)
  const key = `${parts[0] ?? 'home'}-depth-${parts.length}`
  groups.set(key, [...(groups.get(key) ?? []), address])
}

const jobs = []
for (const [key, list] of groups) {
  const sample = list[Math.floor((list.length - 1) / 2)] // the middle one, not the first
  for (const width of WIDTHS) jobs.push({ key, sample, width, size: list.length })
}
console.log(`${[...groups.values()].flat().length} addresses, ${groups.size} groups, ${jobs.length} pictures`)
for (const job of jobs) console.log(`${job.key} (${job.size}) ${job.width}px ${job.sample}`)
if (flag === '--dry') process.exit(0)

await mkdir('audit', { recursive: true })
for (const job of jobs) {
  const response = await fetch('https://curlshot.com/api/v1/screenshot', {
    method: 'POST',
    headers: { 'X-Access-Key': process.env.ACCESS_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({ url: job.sample, viewport_width: job.width, full_page: true, format: 'png' }),
  })
  if (response.ok) await writeFile(`audit/${job.key}-${job.width}.png`, Buffer.from(await response.arrayBuffer()))
  else console.error(job.key, job.width, (await response.json()).error_message)
  await new Promise((resolve) => setTimeout(resolve, PAUSE_MS))
}
```

On 8 November 2026 the dry run on the sitemap of CurlShot printed "106 addresses, 20 groups, 40 pictures". The calls to the API follow the documentation and were not sent in this run.

## How it was tested

Each sitemap was downloaded once, with one request per file. Sitemap indexes were followed one level down; for kubernetes.io only the English sitemap was read. Every address was grouped by its first path segment and the number of path segments, with the same function that runs in the sampler on this page. The grouping is a rule of thumb for finding templates, not a proof that two pages share one. Start on the Free plan, which needs no card: see [pricing](https://curlshot.com/pricing).

## Questions

### How do I screenshot every page of a website?

You usually do not need every page. Read the sitemap, group the addresses by their first path segment and depth, and capture one or two of each group at a phone width and a desktop width. If you do need all of them, read the sitemap and send the list in bulk: see the article on bulk screenshots.

### How many templates does a site have?

In five public sitemaps read on 8 November 2026, the count of groups by path shape ran from 6 to 30 for sites of 106 to 29,613 addresses. It is a rule of thumb, not a count of real templates.

### Which widths should I check before launch?

At least a phone and a desktop: 390 and 1280 px are used here. Add a tablet width if tablets are a real share of your visitors.

### Does a status code check replace looking at the pictures?

No. A page can answer 200 and still show an error, an empty list or a half-drawn block, and a status check passes it. A picture shows what a visitor sees.

### How much does this cost with a screenshot API?

CurlShot counts one successful render as one screenshot, and the Free plan has 100 a month without a card (read from the pricing page on 2026-11-08). Cache hits and failed renders are not counted.

## Sources

1. sitemaps.org, "sitemaps.org - Protocol": https://www.sitemaps.org/protocol.html (checked 8 November 2026)

## Go deeper

- [Bulk screenshots](https://curlshot.com/tools/bulk-screenshots)
- [Mobile screenshot](https://curlshot.com/tools/mobile-screenshot)
- [Getting started](https://curlshot.com/docs/getting-started)
- [Pricing](https://curlshot.com/pricing)

## Read next

- [How to screenshot a list of URLs in bulk](https://curlshot.com/blog/bulk-screenshots-list-of-urls.md): Screenshot hundreds or thousands of URLs: a queue simulator that says how long it takes, a short Node.js script, and what fails at scale.
- [Viewport sizes cheat sheet: phones to desktops](https://curlshot.com/blog/viewport-sizes-cheat-sheet.md): Viewport sizes in CSS pixels, screenshot sizes and device pixel ratios of iPhone, Pixel, Galaxy, iPad and laptop screens, drawn to scale, and the sizes to test.
- [Website change monitoring with screenshots](https://curlshot.com/blog/website-change-monitoring-with-screenshots.md): How to get told when a web page changes: the capture and compare loop, three ways to detect a change, a noise checklist, a cron and Node.js setup, and tools.
