# Website thumbnail sizes: how small can it get

> Thumbnail sizes for link lists, cards and previews, the viewport to capture from, 2x files for sharp screens, and the width where text stops being readable.

Cheat sheet by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 30 October 2026. Page for people: https://curlshot.com/blog/website-thumbnail-sizes

A website thumbnail is usually shown 240 to 400 CSS pixels wide at 16:10, captured from a 1280 pixel wide desktop viewport and saved at twice the display size (a 400 x 250 card needs an 800 x 500 file) so it stays sharp on HiDPI screens. Text shrinks with the image: rendered size = CSS size x thumbnail width / viewport width, so 16 px body text from a 1280 capture is 4 px tall in a 320 pixel thumbnail and unreadable. Captured at phone width (390), the same text is 13.1 px tall and reads fine.

## Key facts

- Rendered text size = original CSS size x (thumbnail width / capture viewport width). With a 9 px legibility cut-off, 16 px body text from a 1280 wide capture is readable down to a 720 px wide thumbnail, and from a 390 wide capture down to 220 px.
- Save the file at twice the display size: a 240 x 150 tile needs 480 x 300 pixels, a 400 x 250 card needs 800 x 500.
- Do not shrink the viewport to get a small image. A 320 pixel wide window gets the phone layout of a responsive site. Capture at 1280 and resize the image afterwards.
- A 16:10 crop from the top of a 1280 wide capture keeps 800 CSS pixels of page height, 16:9 keeps 720, 4:3 keeps 960 and 1:1 keeps 1280.
- In our measurement of two pages on 11 October 2026, a 400 x 250 thumbnail was 14.1 to 16.5 kB as WebP quality 80 and 67.8 to 70.8 kB as PNG.
- Give every thumbnail <img> a width, a height, loading="lazy", decoding="async", a 1x and 2x srcset and a real alt text.

## How small can a website thumbnail get before the text is unreadable?

Text in a thumbnail shrinks by the same factor as the screenshot:

```
rendered size = original CSS size x (thumbnail width / capture viewport width)
```

16 px body text captured at 1280 wide and shown at 320 wide is 4 px tall. The same text captured at 390 wide and shown at 320 wide is 13.1 px tall.

This page treats text drawn smaller than 9 pixels as unreadable. That cut-off is a working assumption, not a standard: the lower-case letters of most typefaces are about half the font size tall, so 9 px text has 4 to 5 rows of pixels to draw the shape of an "a" or an "e" on a 1x screen, and below that the shapes merge. WCAG does not give a minimum text size: its Resize text criterion asks that text can be enlarged to 200 percent and exempts images of text. [6] The interactive version of the page lets the reader set the cut-off anywhere from 6 to 14 px.

The model page uses font sizes typical of a marketing page (an assumption; use your own sizes in the formula). Narrowest thumbnail at which each kind of text is still 9 px tall:

| Text on the page | Size at 1280 wide | Readable down to (desktop capture) | Size at 820 wide | Readable down to (tablet capture) | Size at 390 wide | Readable down to (phone capture) |
| --- | --- | --- | --- | --- | --- | --- |
| Navigation labels | 14 px | 823 px wide | 14 px | 528 px wide | not shown | not shown |
| Body text | 16 px | 720 px wide | 16 px | 462 px wide | 16 px | 220 px wide |
| Button label | 18 px | 640 px wide | 18 px | 410 px wide | 18 px | 195 px wide |
| Subheading | 24 px | 480 px wide | 22 px | 336 px wide | not shown | not shown |
| Headline | 56 px | 206 px wide | 44 px | 168 px wide | 32 px | 110 px wide |

The ladder: what is still readable at five thumbnail widths, 16:10 tiles.

| Thumbnail | Typical job | Readable from a 1280 px desktop capture | Readable from a 820 px tablet capture | Readable from a 390 px phone capture |
| --- | --- | --- | --- | --- |
| 320 x 200 | A hover preview or a large card. | Headline | Headline | All text |
| 240 x 150 | A tile in a link list or a bookmark grid. | Headline | Headline | All text |
| 160 x 100 | A small preview beside a search result. | Layout and colour only | Layout and colour only | Headline |
| 96 x 60 | A row in an admin table. | Layout and colour only | Layout and colour only | Layout and colour only |
| 32 x 20 | Favicon-sized. A colour swatch of the page. | Layout and colour only | Layout and colour only | Layout and colour only |

The trade-off of a phone-width capture: a 16:10 tile cut from the top of a 1280 px capture shows 800 CSS pixels of page height; cut from a 390 px capture it shows 244.

## Website thumbnail size chart

Recommendations of this page, with the reasoning shown. They are not a standard. File size = display size x 2, so the thumbnail stays sharp on screens with two device pixels per CSS pixel. Capture scale = file width / viewport width, rounded up: the capture must hold at least as many pixels as the file.

| Job | Display size (CSS px) | Aspect ratio | Capture viewport | File size (px) | Capture scale | Readable text | Why |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Admin table row | 96 x 60 | 16:10 | 1280 x 800 | 96 x 2 = 192, 60 x 2 = 120 | 192 <= 1280, so 1 | Layout and colour only | Enough to tell one site from another by its layout and colour. |
| Search-result preview | 160 x 120 | 4:3 | 1280 x 960 | 160 x 2 = 320, 120 x 2 = 240 | 320 <= 1280, so 1 | Layout and colour only | Sits beside two or three lines of text. 4:3 shows more of the page per pixel of width. |
| Link list or bookmark grid | 240 x 150 | 16:10 | 1280 x 800 | 240 x 2 = 480, 150 x 2 = 300 | 480 <= 1280, so 1 | Headline | Four or five across on a laptop. The headline of the page is just readable. |
| Bookmark grid with readable text | 240 x 150 | 16:10 | 390 x 844 | 240 x 2 = 480, 150 x 2 = 300 | 480 > 390, so 2 | All text | Same tile, captured at phone width and cropped from the top: the text is 3.3 times larger. |
| Hover preview | 320 x 200 | 16:10 | 1280 x 800 | 320 x 2 = 640, 200 x 2 = 400 | 640 <= 1280, so 1 | Headline | Answers "is this the page I mean?" before the click. Exactly a quarter of the capture width. |
| Directory or marketplace card | 400 x 250 | 16:10 | 1280 x 800 | 400 x 2 = 800, 250 x 2 = 500 | 800 <= 1280, so 1 | Headline | Three across in a 1280 pixel layout. The image is the main content of the card. |
| Chat or email preview | 480 x 270 | 16:9 | 1280 x 720 | 480 x 2 = 960, 270 x 2 = 540 | 960 <= 1280, so 1 | Headline, subheading | One preview per message, in the wide shape link previews usually have. |
| Portfolio tile | 600 x 450 | 4:3 | 1280 x 960 | 600 x 2 = 1200, 450 x 2 = 900 | 1200 <= 1280, so 1 | Headline, subheading | The work is the point, so it gets the most pixels and the tallest crop. |

## Thumbnail aspect ratios compared

Each crop is cut from the top of a 1280 pixel wide capture. Page height kept = 1280 x height / width.

| Aspect ratio | Page height kept (CSS px) | Use it for |
| --- | --- | --- |
| 16:9 | 720 | Chat, email and video-shaped previews. Shows the header and the headline. |
| 16:10 | 800 | The general default for cards and grids: one laptop screen of the page. |
| 3:2 | 853 | A little more page under the fold, still clearly landscape. |
| 4:3 | 960 | Portfolios and small previews beside text: more page per pixel of width. |
| 1:1 | 1280 | Avatars and square grids. Shows the most page, so everything in it is smallest. |

## Sharp or soft: three ways to make a screenshot small

For a thumbnail shown at 320 x 200 CSS pixels:

| Way | Capture viewport | File | Result | Trade-off |
| --- | --- | --- | --- | --- |
| Capture small | 320 x 200 | 320 x 200 | Wrong layout | The file is small, but a responsive site answers a 320 pixel window with its phone layout, and the window shows only the top 200 pixels of it. The thumbnail is a screenshot of a page your visitors on a computer never see. |
| Capture big, let the browser scale it | 1280 x 800 | 1280 x 800 | Heavy file | The layout is right and the browser scales the image down itself, but every visitor downloads 1,024,000 pixels to see 64,000: 16 times more than a 1x screen shows, and 4 times more than a 2x screen can use. |
| Capture wide, resize on the server | 1280 x 800 | 640 x 400 | Sharp and light | The layout is right, the file holds exactly the pixels a 2x screen can show, and the resizing is done once instead of in every browser. It needs an image step after the capture, or a screenshot service that has one. |

A browser scales an image whenever it is shown at a size other than its natural size, and the default algorithm (`image-rendering: auto`) is up to the browser; Firefox uses bilinear resampling. [3] The scaling is fine. The cost of the second way is the download.

## The HTML to show a thumbnail

```html
<a href="https://example.com">
  <img
    src="/thumbs/example-400.webp"
    srcset="/thumbs/example-400.webp 1x,
            /thumbs/example-800.webp 2x"
    width="400"
    height="250"
    loading="lazy"
    decoding="async"
    alt="Home page of example.com"
  >
</a>
```

| Attribute | What it does |
| --- | --- |
| `src` | The 1x file, and the fallback for a browser that does not read `srcset`. With `x` descriptors the browser also counts it as a 1x candidate. [1] |
| `srcset` | The same thumbnail at two densities. A screen with one device pixel per CSS pixel loads the 1x file; a screen with two or more loads the 2x file. [2] |
| `width, height` | The size of the image in pixels, without a unit. The browser works out the aspect ratio from them and reserves the box before the file arrives, so the grid does not jump. [1] |
| `loading="lazy"` | Puts off the download until the image is near the visible part of the page. A lazy image needs `width` and `height`: without them it is 0 by 0 until it loads. [1] |
| `decoding="async"` | Lets the browser paint the rest of the page without waiting for this image to be decoded. [1] |
| `alt` | The text that stands in for the image: read out by screen readers and shown when the file fails. Say what the page is, not "thumbnail". [1] |

Checked in Chromium: at device scale factor 1 the browser loaded the 400 file, at 2 it loaded the 800 file, and the image was laid out at 400 x 250 both times. Do not mix `x` and `w` descriptors in one `srcset`. [1]

## How heavy is a website thumbnail?

Budget for a grid = number of tiles x bytes per tile.

Our measurement, 11 October 2026. Chromium via Playwright, viewport 1280 x 800, device scale factor 1, top of the page. Resized with sharp (Lanczos) and encoded as PNG (default settings), JPEG quality 80 (mozjpeg) and WebP quality 80. 1 kB = 1,000 bytes.

Wikipedia article (text and one photo), https://en.wikipedia.org/wiki/Eiffel_Tower. The 1280 x 800 capture as PNG: 256.0 kB.

| Thumbnail | PNG | JPEG q80 | WebP q80 |
| --- | --- | --- | --- |
| 200 x 125 | 24.5 kB | 4.9 kB | 4.4 kB |
| 400 x 250 | 70.8 kB | 16.0 kB | 14.1 kB |
| 800 x 500 | 194.3 kB | 55.6 kB | 44.8 kB |

MDN reference page (text and navigation), https://developer.mozilla.org/en-US/docs/Web/HTML. The 1280 x 800 capture as PNG: 173.9 kB.

| Thumbnail | PNG | JPEG q80 | WebP q80 |
| --- | --- | --- | --- |
| 200 x 125 | 22.3 kB | 5.3 kB | 4.8 kB |
| 400 x 250 | 67.8 kB | 18.7 kB | 16.5 kB |
| 800 x 500 | 184.0 kB | 60.6 kB | 51.5 kB |

- A grid of 24 thumbnails at 400 wide weighs 339 to 397 kB as WebP and 1,628 to 1,700 kB as PNG.
- On these two pages PNG was 3.6 to 5.6 times the size of WebP, and JPEG was a little heavier than WebP at every size. Two pages are an illustration, not a benchmark.
- Format choice is covered in [PNG, JPEG, WebP or PDF: which format for a website screenshot](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots).
- `Cache-Control: max-age=N` tells a browser the file stays fresh for N seconds, and `public` lets a shared cache such as a CDN store it. [5] A thumbnail that is requested thousands of times should be rendered once.

## Keeping thumbnails fresh

| Regenerate | How | Good for | Cost |
| --- | --- | --- | --- |
| On a schedule | Give every thumbnail a lifetime (a day, a week, 30 days) and render it again when the lifetime runs out. | Sites you do not control: directories, bookmark lists, link previews. | Renders pages that did not change, and shows a stale thumbnail for up to one lifetime after a redesign. |
| When the page changes | Store the time the page was last edited next to the thumbnail, and render again only when that time moves. | Pages you publish yourself: a portfolio, a CMS, a shop. | Needs a change signal you can trust. It cannot see a change on someone else’s site. |
| On demand, with a cache | Render the first time someone asks for the thumbnail, store the result, and serve the stored copy to everyone after. | Long lists where most items are never looked at. | The first visitor waits for the render, so it needs a placeholder, or a warm-up pass for big imports. |

While a thumbnail loads, or if it fails:

1. Reserve the box: `width` and `height` on the `<img>` (or a CSS `aspect-ratio` on its container) hold the space, so nothing moves when the file lands.
2. Fill the box with a calm background colour on the `<img>` itself. It shows through until the file is painted.
3. Write a real `alt`. It is what a visitor reads if the thumbnail never arrives.
4. Swap in a fallback image on error: `onerror="this.onerror=null; this.src='/images/preview-fallback.png'"`. Setting `onerror` to null first stops a loop if the fallback is missing too.
5. If the tile and the file have different shapes, `object-fit: cover` crops the image to the box instead of squashing it.

`object-fit: cover` keeps the aspect ratio of the image while filling the box, and clips what does not fit. [4]

## Website thumbnails with CurlShot

CurlShot can resize the output image on the server: `image_width` scales the finished capture, and `image_width` with `image_height` crops it to a box, keeping the top of the page. One request for an 800 x 500 WebP thumbnail of a desktop capture, stored for 30 days:

```bash
curl "https://curlshot.com/api/v1/screenshot?access_key=YOUR_ACCESS_KEY\
&url=https://example.com\
&viewport_width=1280\
&viewport_height=800\
&image_width=800\
&format=webp\
&image_quality=75\
&block_cookie_banners=true\
&cache=true\
&cache_ttl=2592000" \
  --output thumb.webp
```

| Option | In this request | What it does |
| --- | --- | --- |
| `viewport_width, viewport_height` | 1280, 800 | The browser window the page is drawn in. It decides the layout and, with no crop, the shape of the thumbnail. Defaults: 1280 and 1024. |
| `image_width` | 800 | Resizes the finished capture to this width, 1 to 8000 pixels. The height follows, so the shape is kept. No default: leave it out and the image is not resized. |
| `image_height` | not set | With `image_width`, crops the result to that box and keeps the top of the page. Use it when the tile and the viewport have different shapes. |
| `device_scale_factor` | 1 (default) | Pixel density of the capture, 1 to 3. Raise it only when `image_width` is larger than the viewport width, as with a phone-width capture. |
| `format, image_quality` | webp, 75 | File format and compression, 1 to 100 (default 80) for JPEG and WebP. |
| `cache, cache_ttl` | true, 2592000 | Stores the result and serves the stored copy to every later request with the same options. Off by default. The lifetime is 60 seconds to 30 days (2592000); the default is 4 hours. |
| `cache_key` | not set | A label of your choice that is part of the match. Change it, for example to the date the page was edited, and the next request renders again. |

The same tile from a phone-width capture, cropped from the top (the `iphone_15_pro` preset is 393 x 852 at device scale factor 3, so the capture is 1179 pixels wide and 480 fits inside it):

```bash
curl "https://curlshot.com/api/v1/screenshot?access_key=YOUR_ACCESS_KEY\
&url=https://example.com\
&viewport_device=iphone_15_pro\
&image_width=480\
&image_height=300\
&format=webp\
&cache=true" \
  --output thumb-phone.webp
```

- A cache hit does not use a screenshot from the quota. The response says `x-cache: HIT` or `MISS`.
- A cached answer carries `Cache-Control: public, max-age=...` and an `ETag`, so the visitor’s browser or a CDN keeps the file too, and a repeat check can be answered `304 Not Modified` with no body.
- Caching is off unless the request says `cache=true`. Without it every page view renders the thumbnail again and counts.
- Stored copies belong to one account and are matched on every option that changes the image. `image_width=400` and `image_width=800` are two different screenshots, so a 1x and 2x pair is two renders the first time.
- A signed link carries a `signature`: an HMAC-SHA256 of the sorted, encoded parameters, made with the secret key on your server. It can sit in an `<img src>`; change one character and the answer is `403 signature_invalid`.
- Turn on "Require signature" for the key in the dashboard, so the access key in the link is useless on its own. Add `expires` before signing to give a link an end date.
- When a page cannot be captured the answer is a JSON error, so the `<img>` needs an `onerror` fallback. Failed renders are not counted.

Limits to know: there is one output size per request, so there is no single call that returns a 1x and a 2x file. Many sites serve only the 2x file. An `image_width` larger than the capture enlarges it and adds no detail.

More: [make a website thumbnail](https://curlshot.com/tools/website-thumbnail), [the website previews guide](https://curlshot.com/docs/guides/website-previews), [caching](https://curlshot.com/docs/caching), [signed links](https://curlshot.com/docs/signed-links).

## Glossary

- **Thumbnail:** A small image that stands for a larger thing. A website thumbnail is a screenshot of a web page, scaled down to sit in a list, a card or a preview.
- **Viewport:** The browser window a page is drawn in, measured in CSS pixels. Its width decides which layout a responsive site shows.
- **Aspect ratio:** Width divided by height, written as two numbers: 16:9, 4:3, 1:1. It is the shape of the thumbnail, whatever its size.
- **Device scale factor:** How many device pixels draw one CSS pixel along one side, also called device pixel ratio. 2 means a 400 pixel wide image needs an 800 pixel wide file to look sharp.
- **Downscaling:** Making an image smaller by computing each new pixel from several old ones. Where it happens (in the browser or on the server) decides who pays for the extra bytes.
- **srcset:** An attribute of the HTML `<img>` element that lists several files for one image, each with a density (`2x`) or a width (`800w`), so the browser can pick one.
- **Cache:** A stored copy of a result that is handed out again instead of doing the work twice. For thumbnails there are usually two: one where the image is made and one in the visitor’s browser.

## Questions

### What is the best size for a website thumbnail?

For a card in a directory or a grid, show it at about 400 x 250 CSS pixels and save the file at 800 x 500 so it is sharp on HiDPI screens. For a dense link list use 240 x 150 (file 480 x 300), and for a row in a table 96 x 60 (file 192 x 120). Capture from a 1280 pixel wide viewport in every case. These are practical recommendations, not a standard.

### What viewport should I capture a thumbnail from?

Capture from a normal desktop viewport, 1280 pixels wide, so the page has the layout people recognise, and resize the image afterwards. Use a phone-width viewport (around 390 pixels) only when the text in a small thumbnail has to be readable: the text is then 3.3 times larger relative to the frame, but the tile shows much less of the page.

### Why is the text in my website thumbnail unreadable?

Because text shrinks by the same factor as the image. Body text of 16 pixels captured at 1280 wide and shown at 320 wide is drawn 4 pixels tall, far below what an eye can read. Either accept that a small thumbnail shows layout and colour only, show it larger (about 720 pixels wide for 16 pixel text), or capture at phone width.

### What aspect ratio should a website thumbnail have?

16:10 is a good default: it is one laptop screen of the page, 800 CSS pixels of height from a 1280 wide capture. Use 16:9 for chat and email previews, 4:3 for portfolios and small previews beside text, and 1:1 only when the layout demands a square, because a square shows the most page and makes everything in it smallest.

### How do I keep thumbnails sharp on retina screens?

Save the file at twice the size it is displayed at, and list it in the srcset of the image with a 2x descriptor. A thumbnail shown at 400 x 250 CSS pixels needs an 800 x 500 pixel file. From a 1280 wide capture that is still a reduction, so the capture itself does not need a higher device scale factor.

### Can CurlShot resize a screenshot to thumbnail size?

Yes. The image_width option of the CurlShot API scales the finished capture to a width of 1 to 8000 pixels and keeps its shape, and image_width with image_height crops it to a box, keeping the top of the page. With cache=true the stored thumbnail is served again for up to 30 days, and a cache hit does not use a screenshot from the quota.

### How often should a website thumbnail be regenerated?

As often as the look of the page changes, which for most sites is rarely. A lifetime of a week to 30 days suits directories and bookmark lists. For pages you publish yourself, regenerate when the page is edited instead of on a timer, by tying the stored thumbnail to the time of the last edit.

## Sources

1. MDN Web Docs, "<img>: The Image Embed element": https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/img (checked 11 October 2026)
2. MDN Web Docs, "Using responsive images in HTML": https://developer.mozilla.org/en-US/docs/Web/HTML/Guides/Responsive_images (checked 11 October 2026)
3. MDN Web Docs, "image-rendering": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/image-rendering (checked 11 October 2026)
4. MDN Web Docs, "object-fit": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/object-fit (checked 11 October 2026)
5. MDN Web Docs, "Cache-Control header": https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control (checked 11 October 2026)
6. W3C Web Accessibility Initiative, "Understanding Success Criterion 1.4.4: Resize Text": https://www.w3.org/WAI/WCAG22/Understanding/resize-text.html (checked 11 October 2026)

## Go deeper

- [Make a website thumbnail](https://curlshot.com/tools/website-thumbnail)
- [Guide: website previews in your app](https://curlshot.com/docs/guides/website-previews)
- [Caching](https://curlshot.com/docs/caching)
- [Signed links](https://curlshot.com/docs/signed-links)

## Read next

- [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.
- [PNG, JPEG, WebP or PDF for website screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots.md): A decision flow, a comparison table and our own file-size measurements for choosing PNG, JPEG, WebP or PDF when you save a screenshot of a web page.
- [Social preview image sizes: the OG cheat sheet](https://curlshot.com/blog/social-preview-image-sizes.md): Open Graph image sizes for Facebook, LinkedIn, WhatsApp, iMessage, Discord, Slack and Google Discover, drawn to scale, with the tags and the fixes.
