Skip to content
Cheat sheetBy 11 min read

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.

320 x 200 px

32 pxMarks: where each text drops out1280 px

Captured at

Unreadable under

9 px

16 px body text captured at 1280 wide, shown at 320 wide, is 4 px tall. 1 of 5 kinds of text still read.

  • Navigation labelsReads down to 823 px wide14 → 3.5 pxGone
  • Body textReads down to 720 px wide16 → 4 pxGone
  • Button labelReads down to 640 px wide18 → 4.5 pxGone
  • SubheadingReads down to 480 px wide24 → 6 pxGone
  • HeadlineReads down to 206 px wide56 → 14 pxReadable

This 320 x 200 tile shows the top 800 CSS pixels of the page. Drawn size = CSS size x 320 / 1280.

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.

  1. 320 x 200

    A hover preview or a large card.

    Desktop capture, 1280: headline

    Phone capture, 390: all text

  2. 240 x 150

    A tile in a link list or a bookmark grid.

    Desktop capture, 1280: headline

    Phone capture, 390: all text

  3. 160 x 100

    A small preview beside a search result.

    Desktop capture, 1280: layout and colour only

    Phone capture, 390: headline

  4. 96 x 60

    A row in an admin table.

    Desktop capture, 1280: layout and colour only

    Phone capture, 390: layout and colour only

  5. 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 thumbnail ladder. Every tile is drawn at its real size. Text that would be under 9 pixels tall is shown as a grey bar. The phone-width capture keeps its text for two more rungs, and shows 244 CSS pixels of page height where the desktop capture shows 800.

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.

Font size of each kind of text on the model page at three capture widths, and the narrowest thumbnail at which it is still readable
Text on the pageDesktop capture, 1280Tablet capture, 820Phone capture, 390
Navigation labels823 pxset at 14 px528 pxset at 14 pxNot shown
Body text720 pxset at 16 px462 pxset at 16 px220 pxset at 16 px
Button label640 pxset at 18 px410 pxset at 18 px195 pxset at 18 px
Subheading480 pxset at 24 px336 pxset at 22 pxNot shown
Headline206 pxset at 56 px168 pxset at 44 px110 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.

Recommended website thumbnail sizes by job, with aspect ratio, capture viewport, file size and capture scale
JobDisplay sizeRatioCapture viewportFile size (x 2)Capture scaleReadable text
Admin table rowEnough to tell one site from another by its layout and colour.Display size96 x 60Ratio16:10Capture viewport1280 x 800File size (x 2)192 x 12096 x 2, 60 x 2Capture scale1192 ≤ 1280Readable 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 120Ratio4:3Capture viewport1280 x 960File size (x 2)320 x 240160 x 2, 120 x 2Capture scale1320 ≤ 1280Readable 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 150Ratio16:10Capture viewport1280 x 800File size (x 2)480 x 300240 x 2, 150 x 2Capture scale1480 ≤ 1280Readable 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 150Ratio16:10Capture viewport390 x 844PhoneFile size (x 2)480 x 300240 x 2, 150 x 2Capture scale2480 > 390Readable textAll text
Hover previewAnswers "is this the page I mean?" before the click. Exactly a quarter of the capture width.Display size320 x 200Ratio16:10Capture viewport1280 x 800File size (x 2)640 x 400320 x 2, 200 x 2Capture scale1640 ≤ 1280Readable textHeadline
Directory or marketplace cardThree across in a 1280 pixel layout. The image is the main content of the card.Display size400 x 250Ratio16:10Capture viewport1280 x 800File size (x 2)800 x 500400 x 2, 250 x 2Capture scale1800 ≤ 1280Readable textHeadline
Chat or email previewOne preview per message, in the wide shape link previews usually have.Display size480 x 270Ratio16:9Capture viewport1280 x 720File size (x 2)960 x 540480 x 2, 270 x 2Capture scale1960 ≤ 1280Readable textHeadline, subheading
Portfolio tileThe work is the point, so it gets the most pixels and the tallest crop.Display size600 x 450Ratio4:3Capture viewport1280 x 960File size (x 2)1200 x 900600 x 2, 450 x 2Capture scale11200 ≤ 1280Readable 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.

Aspect ratios for website thumbnails, the page height each keeps from a 1280 pixel wide capture, and what each is good for
RatioPage keptUse it for
16:9720 pxChat, email and video-shaped previews. Shows the header and the headline.
16:10800 pxThe general default for cards and grids: one laptop screen of the page.
3:2853 pxA little more page under the fold, still clearly landscape.
4:3960 pxPortfolios and small previews beside text: more page per pixel of width.
1:11280 pxAvatars and square grids. Shows the most page, so everything in it is smallest.
One web page, 1280 pixels wide, with five crops outlined from the top: 16:9 keeps 720 pixels of height, 16:10 keeps 800 pixels of height, 3:2 keeps 853 pixels of height, 4:3 keeps 960 pixels of height, 1:1 keeps 1280 pixels of height.16:9 · 720 px16:10 · 800 px3:2 · 853 px4:3 · 960 px1:1 · 1280 px
Five crops of one page, to scale, all cut from the top of a 1280 pixel wide capture. The label on each outline is the height of page it keeps.

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.

  1. 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.

  2. 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.

  3. 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.

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>

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. 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]

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

File size of a thumbnail of Wikipedia article (text and one photo) at three widths, as PNG, JPEG quality 80 and WebP quality 80, in kilobytes
ThumbnailFormatSize
200 x 125PNG24.5 kB
JPEG q804.9 kB
WebP q804.4 kB
400 x 250PNG70.8 kB
JPEG q8016.0 kB
WebP q8014.1 kB
800 x 500PNG194.3 kB
JPEG q8055.6 kB
WebP q8044.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

File size of a thumbnail of MDN reference page (text and navigation) at three widths, as PNG, JPEG quality 80 and WebP quality 80, in kilobytes
ThumbnailFormatSize
200 x 125PNG22.3 kB
JPEG q805.3 kB
WebP q804.8 kB
400 x 250PNG67.8 kB
JPEG q8018.7 kB
WebP q8016.5 kB
800 x 500PNG184.0 kB
JPEG q8060.6 kB
WebP q8051.5 kB

The 1280 x 800 capture itself, as PNG: 173.9 kB.

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. Two pages are an illustration, not a benchmark: a page full of photos weighs more in every format.

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.

Three rules for regenerating a website thumbnail: how each works, what it suits and what it costs
RegenerateHowGood forCost
On a scheduleHowGive 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 changesHowStore 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 cacheHowRender 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

The three states a thumbnail tile should be designed for: waiting, loaded and failed. The box is the same size in all three.

A placeholder while it loads, a fallback 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.[1]
  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.[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.

A desktop capture, resized to 800 wide
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
A phone capture, cropped to a 480 x 300 tile
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

The 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.

The options of the thumbnail request, the value used and what each does
OptionWhat it does
viewport_width, viewport_height1280, 800The 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_width800Resizes 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 setWith 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, 75File format and compression, 1 to 100 (default 80) for JPEG and WebP.
cache, cache_ttltrue, 2592000Stores 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 setA 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: 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.

What it does not do

There is one output size per request, so no single call returns a 1x and a 2x file: a 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. [1]MDN Web Docs, <img>: The Image Embed element. Checked .
  2. [2]MDN Web Docs, Using responsive images in HTML. Checked .
  3. [3]MDN Web Docs, image-rendering. Checked .
  4. [4]MDN Web Docs, object-fit. Checked .
  5. [5]MDN Web Docs, Cache-Control header. Checked .
  6. [6]W3C Web Accessibility Initiative, Understanding Success Criterion 1.4.4: Resize Text. Checked .

Screenshot any page in one step

Paste an address into CurlShot and download the screenshot. A free account gives you 100 screenshots every month. No card needed.