Website thumbnail sizes: how small can a screenshot get?
Shrink this page and watch what drops out. Each kind of text turns into a grey bar at the width where it is drawn too small to read.
The page is a model with the font sizes of a typical marketing page, and "unreadable under 9 px" is a working assumption you can change. Now switch the capture to Phone: the same 320 pixel tile becomes readable, because the text is larger relative to the frame.
What is still readable at each thumbnail size?
Text in a website thumbnail shrinks by the same factor as the screenshot, so its drawn size is the original CSS size multiplied by thumbnail width over capture viewport width. Here is the same page at five widths, each at its real size, captured twice: once at 1280 pixels wide and once at 390.
320 x 200
A hover preview or a large card.
Desktop capture, 1280: headline
Phone capture, 390: all text
240 x 150
A tile in a link list or a bookmark grid.
Desktop capture, 1280: headline
Phone capture, 390: all text
160 x 100
A small preview beside a search result.
Desktop capture, 1280: layout and colour only
Phone capture, 390: headline
96 x 60
A row in an admin table.
Desktop capture, 1280: layout and colour only
Phone capture, 390: layout and colour only
32 x 20
Favicon-sized. A colour swatch of the page.
Desktop capture, 1280: layout and colour only
Phone capture, 390: layout and colour only
The narrowest thumbnail each kind of text survives
Minimum width = cut-off x capture width / CSS size, rounded up, with a 9 pixel cut-off.
| Text on the page | Desktop capture, 1280 | Tablet capture, 820 | Phone capture, 390 |
|---|---|---|---|
| Navigation labels | 823 pxset at 14 px | 528 pxset at 14 px | Not shown |
| Body text | 720 pxset at 16 px | 462 pxset at 16 px | 220 pxset at 16 px |
| Button label | 640 pxset at 18 px | 410 pxset at 18 px | 195 pxset at 18 px |
| Subheading | 480 pxset at 24 px | 336 pxset at 22 px | Not shown |
| Headline | 206 pxset at 56 px | 168 pxset at 44 px | 110 pxset at 32 px |
Why 9 pixels? An assumption, stated
The lower-case letters of most typefaces are about half the font size tall. At 9 px that leaves 4 to 5 rows of pixels to draw an "a" or an "e" on a 1x screen. Below that the shapes merge.
It is this page's working number, not a standard. WCAG gives no minimum text size: its Resize text criterion asks that text can be enlarged to 200 percent, and exempts images of text.[6] Set your own cut-off, from 6 to 14 px, in the shrink ray.
Website thumbnail size chart
A website thumbnail for a card or a grid is usually shown 240 to 400 CSS pixels wide, and its file should be twice that size. The sizes below are this page's recommendations with the reasoning shown. No standard sets them.
File size, for sharp HiDPI screens
file = display size x 2
A screen with two device pixels per CSS pixel draws a 400 pixel wide image with 800 pixels. Give it 800 and it stays crisp.
Capture scale
scale = file width / viewport width, rounded up
The capture must hold at least as many pixels as the file. From a 1280 wide capture every size here is a reduction, so scale 1 is enough.
| Job | Display size | Ratio | Capture viewport | File size (x 2) | Capture scale | Readable text |
|---|---|---|---|---|---|---|
| Admin table rowEnough to tell one site from another by its layout and colour. | Display size96 x 60 | Ratio16:10 | Capture viewport1280 x 800 | File size (x 2)192 x 12096 x 2, 60 x 2 | Capture scale1192 ≤ 1280 | Readable textLayout and colour only |
| Search-result previewSits beside two or three lines of text. 4:3 shows more of the page per pixel of width. | Display size160 x 120 | Ratio4:3 | Capture viewport1280 x 960 | File size (x 2)320 x 240160 x 2, 120 x 2 | Capture scale1320 ≤ 1280 | Readable textLayout and colour only |
| Link list or bookmark gridFour or five across on a laptop. The headline of the page is just readable. | Display size240 x 150 | Ratio16:10 | Capture viewport1280 x 800 | File size (x 2)480 x 300240 x 2, 150 x 2 | Capture scale1480 ≤ 1280 | Readable textHeadline |
| Bookmark grid with readable textSame tile, captured at phone width and cropped from the top: the text is 3.3 times larger. | Display size240 x 150 | Ratio16:10 | Capture viewport390 x 844Phone | File size (x 2)480 x 300240 x 2, 150 x 2 | Capture scale2480 > 390 | Readable textAll text |
| Hover previewAnswers "is this the page I mean?" before the click. Exactly a quarter of the capture width. | Display size320 x 200 | Ratio16:10 | Capture viewport1280 x 800 | File size (x 2)640 x 400320 x 2, 200 x 2 | Capture scale1640 ≤ 1280 | Readable textHeadline |
| Directory or marketplace cardThree across in a 1280 pixel layout. The image is the main content of the card. | Display size400 x 250 | Ratio16:10 | Capture viewport1280 x 800 | File size (x 2)800 x 500400 x 2, 250 x 2 | Capture scale1800 ≤ 1280 | Readable textHeadline |
| Chat or email previewOne preview per message, in the wide shape link previews usually have. | Display size480 x 270 | Ratio16:9 | Capture viewport1280 x 720 | File size (x 2)960 x 540480 x 2, 270 x 2 | Capture scale1960 ≤ 1280 | Readable textHeadline, subheading |
| Portfolio tileThe work is the point, so it gets the most pixels and the tallest crop. | Display size600 x 450 | Ratio4:3 | Capture viewport1280 x 960 | File size (x 2)1200 x 900600 x 2, 450 x 2 | Capture scale11200 ≤ 1280 | Readable textHeadline, subheading |
"Readable text" is computed from the model page with the 9 pixel cut-off. A real page with a larger headline keeps it longer: put your own font size into the formula.
Which aspect ratio for a website thumbnail?
The aspect ratio of a website thumbnail decides how much of the page it shows: a crop from the top of a 1280 pixel wide capture keeps 1280 x height / width pixels of page. Wider shapes show the header and the headline. Taller shapes show more page, and make everything in it smaller.
| Ratio | Page kept | Use it for |
|---|---|---|
| 16:9 | 720 px | Chat, email and video-shaped previews. Shows the header and the headline. |
| 16:10 | 800 px | The general default for cards and grids: one laptop screen of the page. |
| 3:2 | 853 px | A little more page under the fold, still clearly landscape. |
| 4:3 | 960 px | Portfolios and small previews beside text: more page per pixel of width. |
| 1:1 | 1280 px | Avatars and square grids. Shows the most page, so everything in it is smallest. |
Sharp or soft: three ways to make a screenshot small
There are three ways to turn a web page into a 320 x 200 thumbnail, and only one gives the right layout in a light file. The bar under each result is the number of pixels a visitor downloads, to scale.
- Way 1Wrong layout
Capture small
- Capture viewport
- 320 x 200
- File the visitor gets
- 320 x 200
64,000 pixels
Set the browser window to the size of the thumbnail and save what it shows.
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.
- Way 2Heavy file
Capture big, let the browser scale it
- Capture viewport
- 1280 x 800
- File the visitor gets
- 1280 x 800
1,024,000 pixels
Save the full-size capture and give the <img> a small width in HTML or CSS.
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.
- Way 3Sharp and light
Capture wide, resize on the server
- Capture viewport
- 1280 x 800
- File the visitor gets
- 640 x 400
256,000 pixels
Capture at desktop width, then scale the image down once, before it is stored, to twice the display size.
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.
The second way does not look bad. 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 left to the browser. Firefox, for one, uses bilinear resampling.[3] What the second way costs is the download: a small image would do, and the visitor pays for a large one.[2]
The HTML to show a website thumbnail
A thumbnail <img> needs six things: a source, a 2x source, its width and height, lazy loading, async decoding and a real text alternative. This one shows a 400 x 250 thumbnail and sends an 800 x 500 file to screens that can use it.
<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>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]
- src
- The 1x file, and the fallback for a browser that does not read
srcset. Withxdescriptors 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
widthandheight: 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]
How heavy is a website thumbnail?
The weight of a grid of thumbnails is the number of tiles multiplied by the bytes of each one, so the format and the width of a single tile decide whether the page loads 24 small files or 24 large ones. We measured two pages to put numbers on it.
Our measurement, 11 October 2026
- PNG
- JPEG q80
- WebP q80
Wikipedia article (text and one photo)
https://en.wikipedia.org/wiki/Eiffel_Tower
| Thumbnail | Format | Size |
|---|---|---|
| 200 x 125 | PNG | 24.5 kB |
| JPEG q80 | 4.9 kB | |
| WebP q80 | 4.4 kB | |
| 400 x 250 | PNG | 70.8 kB |
| JPEG q80 | 16.0 kB | |
| WebP q80 | 14.1 kB | |
| 800 x 500 | PNG | 194.3 kB |
| JPEG q80 | 55.6 kB | |
| WebP q80 | 44.8 kB |
The 1280 x 800 capture itself, as PNG: 256.0 kB.
MDN reference page (text and navigation)
https://developer.mozilla.org/en-US/docs/Web/HTML
| Thumbnail | Format | Size |
|---|---|---|
| 200 x 125 | PNG | 22.3 kB |
| JPEG q80 | 5.3 kB | |
| WebP q80 | 4.8 kB | |
| 400 x 250 | PNG | 67.8 kB |
| JPEG q80 | 18.7 kB | |
| WebP q80 | 16.5 kB | |
| 800 x 500 | PNG | 184.0 kB |
| JPEG q80 | 60.6 kB | |
| WebP q80 | 51.5 kB |
The 1280 x 800 capture itself, as PNG: 173.9 kB.
Do the multiplication
A grid of 24 thumbnails at 400 wide weighed 339 to 397 kB as WebP and 1,628 to 1,700 kB as PNG in this measurement. The full captures, scaled by the browser, would be 4,174 to 6,143 kB.
Pick a lossy format
On these two pages PNG was 3.6 to 5.6 times the size of WebP at quality 80, and JPEG was a little heavier than WebP at every size. When each format is the right one is in PNG, JPEG, WebP or PDF for screenshots.
Render once, serve many times
A thumbnail that is requested thousands of times should be made once. 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]
How often should a thumbnail be regenerated?
A website thumbnail needs regenerating only as often as the look of the page changes, which for most sites is rarely. There are three rules to choose from, and they combine well.
| Regenerate | How | Good for | Cost |
|---|---|---|---|
| On a schedule | HowGive every thumbnail a lifetime (a day, a week, 30 days) and render it again when the lifetime runs out. | Good forSites you do not control: directories, bookmark lists, link previews. | CostRenders pages that did not change, and shows a stale thumbnail for up to one lifetime after a redesign. |
| When the page changes | HowStore the time the page was last edited next to the thumbnail, and render again only when that time moves. | Good forPages you publish yourself: a portfolio, a CMS, a shop. | CostNeeds a change signal you can trust. It cannot see a change on someone else’s site. |
| On demand, with a cache | HowRender the first time someone asks for the thumbnail, store the result, and serve the stored copy to everyone after. | Good forLong lists where most items are never looked at. | CostThe first visitor waits for the render, so it needs a placeholder, or a warm-up pass for big imports. |
- Home page of example.com
Waiting
Loaded
Failed
A placeholder while it loads, a fallback if it fails
- Reserve the box:
widthandheighton the<img>(or a CSSaspect-ratioon its container) hold the space, so nothing moves when the file lands.[1] - Fill the box with a calm background colour on the
<img>itself. It shows through until the file is painted. - Write a real
alt. It is what a visitor reads if the thumbnail never arrives. - Swap in a fallback image on error:
onerror="this.onerror=null; this.src='/images/preview-fallback.png'". Settingonerrorto null first stops a loop if the fallback is missing too. - If the tile and the file have different shapes,
object-fit: covercrops the image to the box instead of squashing it.[4]
Website thumbnails with the CurlShot API
CurlShot resizes the screenshot on the server, which is the third way above: image_width scales the finished capture and keeps its shape, and image_width with image_height crops it to a box, keeping the top of the page. This request makes the 800 x 500 file for a 400 x 250 card and stores it for 30 days.
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.webpcurl "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.webpThe iphone_15_pro preset is 393 x 852 at device scale factor 3, so the capture is 1,179 pixels wide and a 480 pixel file is still a reduction. Text in that tile is 9.8 px tall for 16 px body text shown at 240 wide.
| Option | What it does |
|---|---|
| viewport_width, viewport_height1280, 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_width800 | 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_heightnot 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_factor1 (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_qualitywebp, 75 | File format and compression, 1 to 100 (default 80) for JPEG and WebP. |
| cache, cache_ttltrue, 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_keynot 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. |
In an <img src>, cheaply and without handing out the key
- A cache hit does not use a screenshot from the quota. The response says
x-cache: HITorMISS. - A cached answer carries
Cache-Control: public, max-age=...and anETag, so the visitor’s browser or a CDN keeps the file too, and a repeat check can be answered304 Not Modifiedwith 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=400andimage_width=800are 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 is403 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
expiresbefore signing to give a link an end date. - When a page cannot be captured the answer is a JSON error, so the
<img>needs anonerrorfallback. Failed renders are not counted.
What it does not do
srcset pair is two requests and two stored copies. Many sites serve only the 2x file. An image_width larger than the capture enlarges it and adds no detail, so keep it at or under viewport width x device scale factor.Thumbnail 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 people ask
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. Checked .
- [2]MDN Web Docs, Using responsive images in HTML. Checked .
- [3]MDN Web Docs, image-rendering. Checked .
- [4]MDN Web Docs, object-fit. Checked .
- [5]MDN Web Docs, Cache-Control header. Checked .
- [6]W3C Web Accessibility Initiative, Understanding Success Criterion 1.4.4: Resize Text. Checked .
Read next
- Cheat sheetViewport sizes cheat sheet: phones to desktopsViewport 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.
- ComparisonPNG, JPEG, WebP or PDF for website screenshotsA 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.
- Cheat sheetSocial preview image sizes: the OG cheat sheetOpen Graph image sizes for Facebook, LinkedIn, WhatsApp, iMessage, Discord, Slack and Google Discover, drawn to scale, with the tags and the fixes.