# Web capture glossary: 63 screenshot terms, A to Z

> 63 screenshot, rendering and web capture terms, each defined in one or two sentences with a source, an example and the terms it connects to.

Glossary by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 31 October 2026. Page for people: https://curlshot.com/blog/web-capture-glossary

Web capture has a small core vocabulary, and the terms depend on each other. A viewport is the visible part of a page, measured in CSS pixels; the device pixel ratio says how many device pixels draw one CSS pixel; and viewport times ratio is the size of the screenshot file, so 1280 x 1024 at ratio 2 is 2560 x 2048 pixels. This glossary defines 63 such terms in 9 groups, each in one or two sentences checked against a primary source.

## Key facts

- A viewport is measured in CSS pixels and a screenshot file in device pixels: image size = viewport x device pixel ratio.
- The load event does not wait for lazy-loaded images, and network idle, as Playwright defines it, means no network connections for at least 500 ms.
- PNG is lossless and has an alpha channel, JPEG is lossy and has none, and WebP supports lossy and lossless compression plus transparency.
- A rate limit counts requests in a given amount of time and is signalled with HTTP status 429; a quota counts screenshots in a billing period.
- In Playwright the threshold of a screenshot comparison runs from 0 (strict) to 1 (lax) and defaults to 0.2.
- Claude counts an image in visual tokens of 28 x 28 pixels, so a 1000 x 1000 screenshot costs 1,296 tokens.

## How the terms connect

16 core terms form three chains. Each line reads "the first term comes before the second".

- Headless browser -> Device emulation: A headless browser has no real screen, so the device it shows a page on is the one it emulates.
- Device emulation -> Viewport: Emulating a device sets the viewport, along with the user agent and touch support.
- Viewport -> CSS pixel: A viewport is measured in CSS pixels.
- CSS pixel -> Device pixel ratio: The device pixel ratio says how many device pixels draw one CSS pixel along one side.
- Device pixel ratio -> Image size: Image size is the captured area in CSS pixels multiplied by the device pixel ratio.
- Headless browser -> DOMContentLoaded: A headless browser loads a page as any browser does and fires the same events.
- DOMContentLoaded -> Load event: DOMContentLoaded fires when the HTML is parsed; the load event also waits for stylesheets, scripts, iframes and images.
- Load event -> Network idle: The load event does not cover requests a script starts afterwards; network idle waits for 500 ms with no connections.
- Network idle -> Lazy loading: A lazy image is not requested until someone scrolls near it, so even an idle network does not mean it has loaded.
- Lazy loading -> Full-page screenshot: A full-page screenshot has to scroll through the page first, or the lazy images further down are empty.
- Full-page screenshot -> Image size: A full-page screenshot keeps the width of the viewport and takes its height from the page.
- Image size -> Visual token: Claude counts an image in patches of 28 x 28 pixels, so more pixels are more visual tokens.
- Baseline -> Diff: A diff is always a comparison against a baseline.
- Diff -> Threshold: The threshold decides how different a pixel must be to count in the diff.
- Threshold -> Flaky test: A tolerance that is too strict can fail on rendering noise, and a test that passes on one run then fails on the next.
- Lazy loading -> Flaky test: An image that arrives late changes pixels from one run to the next.

## Terms people confuse

| Term | Is | Other term | Is | The difference |
| --- | --- | --- | --- | --- |
| Viewport | The part of the window that shows the page. The page lays itself out to it. | Screen size | The whole display, including what the browser and the system take. | Set the viewport for a screenshot. The screen resolution of a device is not the size of its page. |
| CSS pixel | A unit of layout: 1/96 of a CSS inch. Viewports are measured in it. | Device pixel | One physical dot of the display. Screenshot files are counted in it. | Device pixels = CSS pixels x device pixel ratio. |
| Full-page screenshot | One tall still image of the whole page, top to bottom. | Scrolling video | A recording of the page being scrolled, as MP4, WebM or GIF. | One is a file you read like a page, the other a file you play. Both cover the whole page. |
| Lossless | Every pixel can be reconstructed exactly. PNG, lossless WebP. | Lossy | Data is discarded for a smaller file and cannot be restored. JPEG, lossy WebP. | Lossless for text, interfaces and comparisons. Lossy for photo-heavy pages where size matters. |
| Load | An event: the page and its stylesheets, scripts, iframes and images have loaded. | Network idle | A wait condition: no network connections for at least 500 ms. | Load is a moment the browser announces. Network idle is a quiet period a tool measures. |
| Cache hit | A stored copy is returned. Fast, and the page is as it was when the copy was made. | Fresh render | The page is opened and drawn again. Slower, and current. | A hit trades freshness for speed. The time to live sets how old a copy may get. |
| Rate limit | Requests in a short time. Passing it gives HTTP 429, and it resets within the window. | Quota | Screenshots in a billing period. It resets when the period ends. | A rate limit is about speed, a quota about volume. Slowing down fixes the first, not the second. |
| Screenshot | One image made of pixels, at a size in pixels. Text is part of the image. | PDF | Pages of a paper size, cut where each page ends. Text can be selected and searched. | A screenshot shows how a page looked on a screen. A PDF is the page laid out for paper. |
| Baseline | The approved screenshot. An input of the comparison. | Diff | The pixels that differ from the baseline. The output of the comparison. | You approve a baseline. You read a diff. |

## Where to go deeper

63 terms in 9 groups. Each group has a guide and a docs page.

| Group | Terms | Guides | Docs |
| --- | --- | --- | --- |
| Layout and pixels | CSS pixel, CSS selector, Device pixel, Device pixel ratio, Element screenshot, Full-page screenshot, Iframe, Image size, Media query, Screen size, Shadow DOM, Sticky positioning, Viewport | [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet), [Full-page screenshots on every device](https://curlshot.com/blog/full-page-screenshot-every-device), [CSS selectors for element screenshots](https://curlshot.com/blog/css-selectors-for-element-screenshots), [Website thumbnail sizes](https://curlshot.com/blog/website-thumbnail-sizes) | [Devices](https://curlshot.com/docs/devices), [Full-page screenshots](https://curlshot.com/docs/full-page), [One element](https://curlshot.com/docs/element) |
| Loading and timing | DOMContentLoaded, Lazy loading, Load event, Network idle, Timeout | [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong) | [Waiting for the page](https://curlshot.com/docs/waiting) |
| Formats | Alpha channel, Codec, Container format, Frame rate, GIF, JPEG, Lossless compression, Lossy compression, PNG, WebP | [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots), [Website video as MP4, WebM or GIF](https://curlshot.com/blog/website-video-mp4-webm-gif) | [Options reference](https://curlshot.com/docs/options), [Video](https://curlshot.com/docs/video) |
| Automation | Cookie, Dark mode, Device emulation, Headless browser, User agent | [Screenshot API or your own headless browser](https://curlshot.com/blog/screenshot-api-vs-headless-browser), [Screenshot code examples](https://curlshot.com/blog/screenshot-code-examples), [Dark mode screenshots](https://curlshot.com/blog/dark-mode-screenshots), [Screenshots of pages behind a login](https://curlshot.com/blog/screenshot-pages-behind-login) | [Dark mode and emulation](https://curlshot.com/docs/dark-mode-and-emulation), [Behind a login](https://curlshot.com/docs/guides/screenshot-behind-login) |
| Sharing and previews | Link unfurl, Open Graph image, Signed URL, Webhook | [Social preview image sizes](https://curlshot.com/blog/social-preview-image-sizes), [HTML to image templates](https://curlshot.com/blog/html-to-image-templates), [Bulk screenshots from a list of URLs](https://curlshot.com/blog/bulk-screenshots-list-of-urls) | [Signed links](https://curlshot.com/docs/signed-links), [Async and webhooks](https://curlshot.com/docs/async-and-webhooks) |
| Security and limits | Cache hit, Cookie banner, Cookie consent, Hash, Quota, Rate limit, SSRF, Time to live, Unix timestamp | [How cookie banners work](https://curlshot.com/blog/how-cookie-banners-work), [A web page as evidence](https://curlshot.com/blog/web-page-as-evidence) | [Usage and limits](https://curlshot.com/docs/usage-and-limits), [Caching](https://curlshot.com/docs/caching), [Blocking](https://curlshot.com/docs/blocking) |
| Testing | Anti-aliasing, Baseline, Diff, Flaky test, Threshold, Visual regression test | [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide), [Website change monitoring with screenshots](https://curlshot.com/blog/website-change-monitoring-with-screenshots) | [Custom CSS and hiding elements](https://curlshot.com/docs/customize) |
| AI and agents | Accessibility tree, MCP, Token, Tool call, Vision model, Visual token | [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents) | [Using the API from AI agents](https://curlshot.com/docs/guides/ai-agents) |
| Printing and PDF | Page box, Page break, Page-margin box, PDF, Print media | [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes) | [PDF](https://curlshot.com/docs/pdf) |

## All 63 terms, A to Z

Each definition stands on its own. Where a term matches an option of the CurlShot API, the exact option name is given.

### Accessibility tree

An accessibility tree is a structure the browser builds from a page that holds accessibility-related information for most HTML elements: the name, description, role and state of each one.

Why it matters for a screenshot: An agent can read the accessibility tree as text to find a button by its name and role, and keep the screenshot for what text cannot say: layout, colour and what is visually broken.

- Example: `role: button, name: "Read more"`
- Also called: a11y tree, accessibility snapshot
- Category: AI and agents
- Related: Vision model, Tool call, CSS selector
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [MDN Web Docs, Accessibility tree (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Accessibility_tree)
- Link: https://curlshot.com/blog/web-capture-glossary#accessibility-tree

### Alpha channel

An alpha channel is the fourth channel of a colour, next to red, green and blue, and it specifies opacity, so the background can be seen through a pixel to some extent.

Why it matters for a screenshot: A screenshot with a transparent background needs a format that has an alpha channel: PNG and WebP have one, JPEG does not.

- API option: `omit_background`
- Also called: transparency, opacity, transparent background
- Category: Formats
- Related: PNG, WebP, JPEG
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Alpha (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Alpha); [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#alpha-channel

### Anti-aliasing

Anti-aliasing is the smoothing a renderer applies to the edges of text and shapes, on the level of the pixel or of the subpixel.

Why it matters for a screenshot: Browser rendering varies with the operating system, its settings and the hardware, so comparison libraries such as pixelmatch detect anti-aliased pixels and leave them out of the count by default.

- Also called: antialiasing, font smoothing, subpixel rendering
- Category: Testing
- Related: Diff, Threshold, Flaky test
- Guide: [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide)
- Source: [MDN Web Docs, font-smooth](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/font-smooth); [Mapbox on GitHub, pixelmatch: README](https://github.com/mapbox/pixelmatch); [Playwright, Visual comparisons](https://playwright.dev/docs/test-snapshots)
- Link: https://curlshot.com/blog/web-capture-glossary#anti-aliasing

### Baseline

A baseline is the approved reference screenshot that later screenshots of the same page are compared against. Playwright generates it on the first run of a test and stores it next to the test file.

Why it matters for a screenshot: A comparison is only as good as its baseline: take the baseline in the same environment that takes the new screenshots, because rendering varies between machines.

- Example: `npx playwright test --update-snapshots`
- Also called: reference screenshot, snapshot, expected image
- Category: Testing
- Related: Diff, Threshold, Visual regression test
- Guide: [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide)
- Source: [Playwright, Visual comparisons](https://playwright.dev/docs/test-snapshots)
- Link: https://curlshot.com/blog/web-capture-glossary#baseline

### Cache hit

A cache hit is a request answered with a stored copy of an earlier result. A cache miss is the opposite: no stored copy exists, so the result is produced fresh and can then be stored.

Why it matters for a screenshot: A cache hit returns a screenshot without opening the page again, so it is faster and shows the page as it was when the copy was made. In CurlShot the `X-Cache` header says `HIT` or `MISS`, and a hit does not use a screenshot from the quota.

- Example: `X-Cache: HIT`
- API option: `cache`, `cache_key`
- Also called: cache miss, HIT, MISS, cached screenshot, fresh render
- Category: Security and limits
- Related: Time to live, Quota, Signed URL
- Guide: [Website thumbnail sizes](https://curlshot.com/blog/website-thumbnail-sizes)
- Source: [MDN Web Docs, HTTP caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Caching); [Cloudflare docs, Cloudflare cache responses](https://developers.cloudflare.com/cache/concepts/cache-responses/)
- Link: https://curlshot.com/blog/web-capture-glossary#cache-hit

### Codec

A codec is a program, algorithm or device that encodes or decodes a data stream, and each codec handles one specific encoding or compression technology.

Why it matters for a screenshot: A recording of a scrolling page is compressed by a video codec, and a player must support that codec to show it. CurlShot encodes MP4 with H.264 and WebM with VP9.

- Example: `H.264, VP9, AV1`
- Also called: H.264, VP9, AV1, encoder
- Category: Formats
- Related: Container format, Frame rate, Lossy compression
- Guide: [Website video as MP4, WebM or GIF](https://curlshot.com/blog/website-video-mp4-webm-gif)
- Source: [MDN Web Docs, Codec (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Codec); [MDN Web Docs, Media container formats](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Containers)
- Link: https://curlshot.com/blog/web-capture-glossary#codec

### Container format

A container format is a file format that encapsulates one or more media streams, such as video and audio, along with metadata, so they can be stored and played back together.

Why it matters for a screenshot: The file extension of a page recording names the container, not the codec: an MP4 file can hold H.264, AV1 or VP9 video, and a WebM file holds VP8, VP9 or AV1.

- Example: `format=mp4`
- API option: `format`
- Also called: container, media container, MP4, WebM, file type
- Category: Formats
- Related: Codec, Frame rate, GIF
- Guide: [Website video as MP4, WebM or GIF](https://curlshot.com/blog/website-video-mp4-webm-gif)
- Source: [MDN Web Docs, Media container formats](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Containers)
- Link: https://curlshot.com/blog/web-capture-glossary#container-format

### Cookie

A cookie is a small piece of data a server sends to a web browser, which the browser may store and send back to the same server with later requests.

Why it matters for a screenshot: Cookies carry sign-in state and preferences, so sending the right cookie with a capture is how a screenshot shows a signed-in page, a chosen language or an already answered consent banner.

- Example: `session=abc123`
- API option: `cookies`
- Also called: HTTP cookie, session cookie, browser cookie
- Category: Automation
- Related: Cookie banner, Cookie consent, User agent
- Guide: [Screenshots of pages behind a login](https://curlshot.com/blog/screenshot-pages-behind-login)
- Source: [MDN Web Docs, Using HTTP cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Cookies)
- Link: https://curlshot.com/blog/web-capture-glossary#cookie

### Cookie banner

A cookie banner is the banner, pop-up or message box a website shows to ask a visitor for consent before it uses cookies that need consent.

Why it matters for a screenshot: A browser that opens a page for the first time has given no consent, so the banner is in the screenshot unless the capture blocks it, hides it or answers it.

- API option: `block_cookie_banners`
- Also called: consent banner, consent pop-up, cookie notice, cookie wall
- Category: Security and limits
- Related: Cookie consent, Cookie, Sticky positioning
- Guide: [How cookie banners work](https://curlshot.com/blog/how-cookie-banners-work)
- Source: [Information Commissioner’s Office (UK), How do we manage consent in practice?](https://ico.org.uk/for-organisations/direct-marketing-and-privacy-and-electronic-communications/guidance-on-the-use-of-storage-and-access-technologies/how-do-we-manage-consent-in-practice/); [European Union, Your Europe, Online privacy: cookies](https://europa.eu/youreurope/business/dealing-with-customers/data-protection/online-privacy/index_en.htm)
- Link: https://curlshot.com/blog/web-capture-glossary#cookie-banner

### Cookie consent

Cookie consent is the permission a website needs from a visitor before it uses cookies that are not strictly necessary for a service the visitor asked for. Under European Union rules such cookies cannot be set when the page is first opened, and in the United Kingdom silence or inactivity does not count as consent.

Why it matters for a screenshot: Closing a banner in an automated capture makes a consent choice on the page being captured, so when a screenshot must reflect one specific choice, set that choice yourself. The rules differ by country, and nothing in this glossary is legal advice.

- Also called: consent, opt-in
- Category: Security and limits
- Related: Cookie banner, Cookie, CSS selector
- Guide: [How cookie banners work](https://curlshot.com/blog/how-cookie-banners-work)
- Source: [European Union, Your Europe, Online privacy: cookies](https://europa.eu/youreurope/business/dealing-with-customers/data-protection/online-privacy/index_en.htm); [Information Commissioner’s Office (UK), How do we manage consent in practice?](https://ico.org.uk/for-organisations/direct-marketing-and-privacy-and-electronic-communications/guidance-on-the-use-of-storage-and-access-technologies/how-do-we-manage-consent-in-practice/)
- Link: https://curlshot.com/blog/web-capture-glossary#cookie-consent

### CSS pixel

A CSS pixel is the CSS unit of absolute length `px`, defined as exactly 1/96 of a CSS inch. A CSS pixel is a unit of layout, not one dot of a screen.

Why it matters for a screenshot: Viewport sizes and element positions are given in CSS pixels, while a screenshot file is counted in device pixels, so the two numbers differ whenever the device pixel ratio is not 1.

- Example: `390 CSS px wide at ratio 3 = 1170 px in the file`
- Also called: px, logical pixel, reference pixel, point
- Category: Layout and pixels
- Related: Device pixel, Device pixel ratio, Viewport
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, CSS pixel (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/CSS_pixel); [MDN Web Docs, Window: devicePixelRatio property](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio)
- Link: https://curlshot.com/blog/web-capture-glossary#css-pixel

### CSS selector

A CSS selector is the part of a CSS rule that describes which elements in a document the rule matches.

Why it matters for a screenshot: Capture tools reuse selectors to point at one element: to screenshot only that element, to hide it, to click it, or to wait until it exists.

- Example: `#pricing, .cookie-bar, div.warning`
- API option: `selector`, `hide_selectors`, `wait_for_selector`, `click`
- Also called: selector, query selector
- Category: Layout and pixels
- Related: Element screenshot, Shadow DOM, Iframe
- Guide: [CSS selectors for element screenshots](https://curlshot.com/blog/css-selectors-for-element-screenshots)
- Source: [MDN Web Docs, CSS selector (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/CSS_Selector)
- Link: https://curlshot.com/blog/web-capture-glossary#css-selector

### Dark mode

Dark mode is a dark colour scheme that a page offers through the `prefers-color-scheme` media feature, which detects whether the user prefers a light or a dark colour scheme.

Why it matters for a screenshot: A capture browser can emulate the dark preference, so the same address gives a light and a dark screenshot. A page that has no dark styles looks the same in both.

- Example: `@media (prefers-color-scheme: dark) { ... }`
- API option: `dark_mode`
- Also called: prefers-color-scheme, colour scheme, color scheme, dark theme
- Category: Automation
- Related: Media query, Device emulation, Print media
- Guide: [Dark mode screenshots](https://curlshot.com/blog/dark-mode-screenshots)
- Source: [MDN Web Docs, @media: media types and media features](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@media); [Playwright, Emulation](https://playwright.dev/docs/emulation)
- Link: https://curlshot.com/blog/web-capture-glossary#dark-mode

### Device emulation

Device emulation is making a browser simulate a particular phone, tablet or desktop by setting its user agent, screen size, viewport and touch support, without having the device.

Why it matters for a screenshot: Emulation is how one server takes a phone, a tablet and a desktop screenshot of the same address. It simulates the browser of the device, not its hardware.

- Example: `viewport_device=iphone_15_pro`
- API option: `viewport_device`, `viewport_mobile`
- Also called: emulation, device preset, device descriptor, mobile emulation
- Category: Automation
- Related: Viewport, Device pixel ratio, User agent
- Guide: [Full-page screenshots on every device](https://curlshot.com/blog/full-page-screenshot-every-device)
- Source: [Playwright, Emulation](https://playwright.dev/docs/emulation)
- Link: https://curlshot.com/blog/web-capture-glossary#device-emulation

### Device pixel

A device pixel is one physical pixel of a display, and the unit a screenshot file is counted in.

Why it matters for a screenshot: The width and height of a screenshot are device pixels: a 1280 CSS pixel wide viewport at a device pixel ratio of 2 gives a file 2560 pixels wide.

- Also called: physical pixel, hardware pixel, screen pixel
- Category: Layout and pixels
- Related: CSS pixel, Device pixel ratio, Image size
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, Window: devicePixelRatio property](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#device-pixel

### Device pixel ratio

A device pixel ratio is the ratio of the resolution of a display in physical pixels to its resolution in CSS pixels: the number of device pixels used to draw one CSS pixel along one side. A value of 1 is a classic 96 DPI display and 2 is expected for HiDPI or Retina displays.

Why it matters for a screenshot: Device pixel ratio multiplies the pixel size of a screenshot and makes text sharper without changing the layout of the page.

- Example: `1 (classic), 2 (HiDPI), often above 2 on phones`
- API option: `device_scale_factor`
- Also called: DPR, device scale factor, Retina, HiDPI, 2x, pixel density
- Category: Layout and pixels
- Related: CSS pixel, Device pixel, Image size
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, Window: devicePixelRatio property](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio)
- Link: https://curlshot.com/blog/web-capture-glossary#device-pixel-ratio

### Diff

A diff is the comparison of a new screenshot with a baseline, pixel by pixel, that reports which pixels are different and how many there are.

Why it matters for a screenshot: A diff turns the question of whether a page still looks right into a number a script can check, and it is where a moved button or a missing image shows up.

- Example: `maxDiffPixels: 100`
- Also called: image diff, pixel diff, visual diff, comparison
- Category: Testing
- Related: Baseline, Threshold, Anti-aliasing
- Guide: [Website change monitoring with screenshots](https://curlshot.com/blog/website-change-monitoring-with-screenshots)
- Source: [Mapbox on GitHub, pixelmatch: README](https://github.com/mapbox/pixelmatch); [Playwright, Visual comparisons](https://playwright.dev/docs/test-snapshots); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#diff

### DOMContentLoaded

DOMContentLoaded is the browser event that fires when the HTML document has been completely parsed and all deferred scripts have downloaded and executed. DOMContentLoaded does not wait for images, subframes or async scripts.

Why it matters for a screenshot: A screenshot taken at DOMContentLoaded can show the text and the layout with empty image boxes, so it suits captures where speed matters more than images.

- Example: `wait_until=domcontentloaded`
- API option: `wait_until`
- Also called: DOM ready, document ready, DOM content loaded
- Category: Loading and timing
- Related: Load event, Network idle, Lazy loading
- Guide: [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong)
- Source: [MDN Web Docs, Document: DOMContentLoaded event](https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event); [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#domcontentloaded

### Element screenshot

An element screenshot is a screenshot of a single element of a page, chosen with a selector, in place of the whole viewport.

Why it matters for a screenshot: Capturing one chart, card or table gives a smaller file with nothing left to crop.

- Example: `selector=#pricing`
- API option: `selector`
- Also called: element capture, component screenshot, selector screenshot
- Category: Layout and pixels
- Related: CSS selector, Full-page screenshot, Shadow DOM
- Guide: [CSS selectors for element screenshots](https://curlshot.com/blog/css-selectors-for-element-screenshots)
- Source: [Playwright, Screenshots](https://playwright.dev/docs/screenshots)
- Link: https://curlshot.com/blog/web-capture-glossary#element-screenshot

### Flaky test

A flaky test is a test that fails on the first run and passes when it is retried, with no change to the code. Playwright reports such a test as flaky.

Why it matters for a screenshot: Screenshot tests turn flaky when a page is captured before it has settled, which is why Playwright disables animations and waits until two consecutive screenshots are the same before it compares.

- Also called: flaky, flake, unstable test
- Category: Testing
- Related: Baseline, Threshold, Lazy loading
- Guide: [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide)
- Source: [Playwright, Retries](https://playwright.dev/docs/test-retries); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#flaky-test

### Frame rate

A frame rate is the number of frames shown each second, written fps. Films typically run at 24 fps, and browsers aim to repaint a page at 60 fps.

Why it matters for a screenshot: In a recording of a scrolling page, a higher frame rate is smoother and stores more frames. CurlShot records at 24 fps by default and accepts 5 to 30.

- Example: `video_fps=24`
- API option: `video_fps`
- Also called: fps, frames per second
- Category: Formats
- Related: Codec, Container format, GIF
- Guide: [Website video as MP4, WebM or GIF](https://curlshot.com/blog/website-video-mp4-webm-gif)
- Source: [MDN Web Docs, Frame rate (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/FPS)
- Link: https://curlshot.com/blog/web-capture-glossary#frame-rate

### Full-page screenshot

A full-page screenshot is a screenshot of the full scrollable page, from the top to the bottom, as if the screen were very tall, in place of only the part visible in the viewport.

Why it matters for a screenshot: The width of a full-page screenshot still comes from the viewport and only the height grows, so lazy-loaded images, sticky headers and very tall pages each need handling before the capture.

- Example: `full_page=true`
- API option: `full_page`, `full_page_scroll`, `full_page_max_height`
- Also called: full-page capture, full page, whole-page screenshot, scrolling screenshot, long screenshot
- Category: Layout and pixels
- Related: Viewport, Lazy loading, Sticky positioning
- Guide: [Full-page screenshots on every device](https://curlshot.com/blog/full-page-screenshot-every-device)
- Source: [Playwright, Screenshots](https://playwright.dev/docs/screenshots); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#full-page-screenshot

### GIF

GIF is an image format that losslessly compresses 8-bit indexed colour, so a palette holds at most 256 colours, and that supports simple animation.

Why it matters for a screenshot: A GIF of a scrolling page plays wherever an image does, with no video player, but converting a full-colour page to a 256-colour palette can dither it. CurlShot caps a GIF at 15 frames per second.

- Example: `format=gif`
- API option: `format`
- Also called: animated GIF, Graphics Interchange Format
- Category: Formats
- Related: Frame rate, Container format, Lossless compression
- Guide: [Website video as MP4, WebM or GIF](https://curlshot.com/blog/website-video-mp4-webm-gif)
- Source: [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#gif

### Hash

A hash is the fixed-length output, also called a digest, that a hash function produces from an input of any length. With a cryptographic hash function such as SHA-256, any change to the input leads to a different output.

Why it matters for a screenshot: Storing the hash of a screenshot file when it is taken lets anyone check later that the file has not been altered: hash the file again and compare.

- Example: `SHA-256: 256 bits, written as 64 hexadecimal characters (256 / 4)`
- Also called: digest, checksum, SHA-256, hash function, fingerprint
- Category: Security and limits
- Related: Unix timestamp, Signed URL, Webhook
- Guide: [A web page as evidence](https://curlshot.com/blog/web-page-as-evidence)
- Source: [MDN Web Docs, Hash function (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Hash_function)
- Link: https://curlshot.com/blog/web-capture-glossary#hash

### Headless browser

A headless browser is a web browser that runs without any visible window, in an unattended environment such as a server. Chrome starts in headless mode with the `--headless` flag.

Why it matters for a screenshot: Server-side screenshots are taken by a headless browser: it loads and draws the page as a desktop browser does and saves the result as a file.

- Example: `google-chrome --headless`
- Also called: headless Chrome, headless mode, headless Chromium
- Category: Automation
- Related: Device emulation, Viewport, User agent
- Guide: [Screenshot API or your own headless browser](https://curlshot.com/blog/screenshot-api-vs-headless-browser)
- Source: [Chrome for Developers, Chrome Headless mode](https://developer.chrome.com/docs/chromium/headless)
- Link: https://curlshot.com/blog/web-capture-glossary#headless-browser

### Iframe

An iframe is an HTML element that embeds another document into the current page as a nested browsing context with a document of its own.

Why it matters for a screenshot: The document inside an iframe, such as an embedded video, map or payment form, loads separately: DOMContentLoaded does not wait for it, and a selector written for the outer page does not match elements inside it.

- Example: `<iframe src="https://example.com/map"></iframe>`
- Also called: inline frame, embedded frame, embed, subframe
- Category: Layout and pixels
- Related: CSS selector, Shadow DOM, Load event
- Guide: [CSS selectors for element screenshots](https://curlshot.com/blog/css-selectors-for-element-screenshots)
- Source: [MDN Web Docs, <iframe>: the inline frame element](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe); [MDN Web Docs, Document: DOMContentLoaded event](https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event)
- Link: https://curlshot.com/blog/web-capture-glossary#iframe

### Image size

An image size is the width and height of a screenshot file in pixels, which equals the captured area in CSS pixels multiplied by the device pixel ratio.

Why it matters for a screenshot: Image size drives the weight of the file, the sharpness of the text and what a vision model charges to read it, and it comes from two inputs you control: the viewport and the device pixel ratio.

- Example: `1280 x 1024 at ratio 2 = 2560 x 2048 px`
- API option: `image_width`, `image_height`
- Also called: pixel dimensions, screenshot size, output size, resolution
- Category: Layout and pixels
- Related: Viewport, Device pixel ratio, Visual token
- Guide: [Website thumbnail sizes](https://curlshot.com/blog/website-thumbnail-sizes)
- Source: [MDN Web Docs, Window: devicePixelRatio property](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#image-size

### JPEG

JPEG is a lossy image format for still images that stores 8 bits each of red, green and blue for every pixel and has no alpha channel.

Why it matters for a screenshot: JPEG suits photographs, but lossy compression blurs text and sharp edges, which screenshots are full of, and a JPEG cannot hold a transparent background.

- Example: `format=jpeg&image_quality=80`
- API option: `format`, `image_quality`
- Also called: JPG, .jpg
- Category: Formats
- Related: Lossy compression, PNG, WebP
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#jpeg

### Lazy loading

Lazy loading is a strategy that loads a resource only when it is needed. With `loading="lazy"` on an image or an iframe, the browser defers loading until the user scrolls near it.

Why it matters for a screenshot: Nobody scrolls in an automated capture, so lazy images further down a tall page stay empty unless the capture tool scrolls through the page first. The load event does not wait for them either.

- Example: `<img loading="lazy" src="photo.jpg" alt="">`
- API option: `full_page_scroll`
- Also called: lazy load, loading="lazy", lazy images, deferred images
- Category: Loading and timing
- Related: Full-page screenshot, Load event, Network idle
- Guide: [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong)
- Source: [MDN Web Docs, Lazy loading](https://developer.mozilla.org/en-US/docs/Web/Performance/Guides/Lazy_loading); [MDN Web Docs, Window: load event](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event)
- Link: https://curlshot.com/blog/web-capture-glossary#lazy-loading

### Link unfurl

A link unfurl is the preview a messaging app attaches to a link posted in a conversation. Slack, which uses the term, crawls the link and builds the preview from the Open Graph and X Card metadata of the page.

Why it matters for a screenshot: The image in an unfurl is whatever the page names in `og:image`, so a generated screenshot or card placed there is what people see before they click.

- Also called: unfurl, unfurling, link preview, rich preview, link card
- Category: Sharing and previews
- Related: Open Graph image, Image size, Cache hit
- Guide: [Social preview image sizes](https://curlshot.com/blog/social-preview-image-sizes)
- Source: [Slack developer docs, Unfurling links in messages](https://docs.slack.dev/messaging/unfurling-links-in-messages/); [ogp.me, The Open Graph protocol](https://ogp.me/)
- Link: https://curlshot.com/blog/web-capture-glossary#link-unfurl

### Load event

A load event is the browser event that fires when the whole page has loaded, including all dependent resources such as stylesheets, scripts, iframes and images, except those that are loaded lazily.

Why it matters for a screenshot: Load is the usual moment to take a screenshot and the default wait condition in Playwright and in CurlShot. Lazy images, and anything a script requests after load, are not covered by it.

- Example: `wait_until=load`
- API option: `wait_until`
- Also called: load, window.onload, page load, onload
- Category: Loading and timing
- Related: DOMContentLoaded, Network idle, Lazy loading
- Guide: [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong)
- Source: [MDN Web Docs, Window: load event](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event); [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#load-event

### Lossless compression

Lossless compression is a class of data compression that allows the original data to be perfectly reconstructed from the compressed data. PNG and lossless WebP are examples.

Why it matters for a screenshot: A lossless screenshot keeps every pixel exactly as the browser drew it, which matters for small text and for comparing two screenshots pixel by pixel.

- Also called: lossless, reversible compression
- Category: Formats
- Related: Lossy compression, PNG, Diff
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Lossless compression (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Lossless_compression); [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#lossless-compression

### Lossy compression

Lossy compression is a data compression method that discards part of the data to make a file smaller, and the discarded data cannot be restored.

Why it matters for a screenshot: Lossy formats such as JPEG make smaller files of photo-heavy pages, but every save loses detail, and heavy compression can make the text in a screenshot hard to read, for people and for vision models.

- Example: `image_quality=80`
- API option: `image_quality`
- Also called: lossy, irreversible compression, image quality, compression artefacts
- Category: Formats
- Related: Lossless compression, JPEG, WebP
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Lossy compression (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Lossy_compression); [Anthropic, Claude docs, Vision: image limits, formats and token cost](https://platform.claude.com/docs/en/build-with-claude/vision)
- Link: https://curlshot.com/blog/web-capture-glossary#lossy-compression

### MCP

MCP, the Model Context Protocol, is an open standard for connecting AI applications to external systems such as data sources and tools.

Why it matters for a screenshot: A screenshot service that runs an MCP server can be called by an AI assistant directly. CurlShot offers a `take_screenshot` tool at its MCP endpoint, so an agent can look at a web page with no custom code in between.

- Example: `"method": "tools/call"`
- Also called: Model Context Protocol, MCP server, MCP tool
- Category: AI and agents
- Related: Tool call, Vision model, Visual token
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [Model Context Protocol, What is the Model Context Protocol (MCP)?](https://modelcontextprotocol.io/docs/getting-started/intro); [Anthropic, Claude docs, Glossary: tokens, context window, MCP](https://platform.claude.com/docs/en/about-claude/glossary)
- Link: https://curlshot.com/blog/web-capture-glossary#mcp

### Media query

A media query is a logical expression that lets CSS and other web languages check aspects of the device or user agent a document is shown in, such as its width or its media type, and apply code only when the check passes.

Why it matters for a screenshot: Media queries are why one address has many looks: the viewport width picks the phone or the desktop layout, the media type picks screen or print styles, and the colour scheme picks light or dark.

- Example: `@media (max-width: 600px) { ... }`
- Also called: @media, breakpoint, responsive breakpoint, media feature
- Category: Layout and pixels
- Related: Viewport, Print media, Dark mode
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, Media query (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Media_query); [MDN Web Docs, @media: media types and media features](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@media)
- Link: https://curlshot.com/blog/web-capture-glossary#media-query

### Network idle

Network idle is a wait condition that treats a page as ready when there have been no network connections for at least 500 ms. That is how Playwright defines its `networkidle` option.

Why it matters for a screenshot: Network idle catches content that scripts fetch after the load event, but a page that keeps polling or streaming may never go idle, and the capture then runs into its timeout. Playwright discourages relying on it in tests.

- Example: `wait_until=networkidle`
- API option: `wait_until`
- Also called: networkidle, network quiet, idle network
- Category: Loading and timing
- Related: Load event, Timeout, Lazy loading
- Guide: [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong)
- Source: [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#network-idle

### Open Graph image

An Open Graph image is the image a page names in its `og:image` meta tag: an image URL that represents the page when it is shared. `og:image` is one of the four required Open Graph properties, with `og:title`, `og:type` and `og:url`.

Why it matters for a screenshot: Social networks and messaging apps show the Open Graph image in link previews, and a common way to make one is to render an HTML template to an image.

- Example: `<meta property="og:image" content="https://example.com/card.png">`
- Also called: og:image, OG image, social preview image, share image, social card
- Category: Sharing and previews
- Related: Link unfurl, Image size, Signed URL
- Guide: [HTML to image templates](https://curlshot.com/blog/html-to-image-templates)
- Source: [ogp.me, The Open Graph protocol](https://ogp.me/); [Slack developer docs, Unfurling links in messages](https://docs.slack.dev/messaging/unfurling-links-in-messages/)
- Link: https://curlshot.com/blog/web-capture-glossary#open-graph-image

### Page box

A page box is the rectangular area with a finite width and height that CSS maps to one printed page. The content area of a page box, where the document flows, is called the page area.

Why it matters for a screenshot: A PDF made from a web page is a series of page boxes: the paper size sets the box, the margins shrink the page area, and what does not fit moves to the next page. In CSS, A4 is 210 mm by 297 mm and letter is 8.5 in by 11 in.

- Example: `@page { size: A4; margin: 20mm; }`
- API option: `pdf_paper_format`, `pdf_margin`, `pdf_landscape`
- Also called: page area, @page, paper size, A4, Letter
- Category: Printing and PDF
- Related: Page-margin box, Page break, PDF
- Guide: [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes)
- Source: [W3C, CSS Paged Media Module Level 3](https://www.w3.org/TR/css-page-3/)
- Link: https://curlshot.com/blog/web-capture-glossary#page-box

### Page break

A page break is the point where content moves on to the next printed page. The CSS property `break-before` with the value `page` forces a page break right before an element.

Why it matters for a screenshot: A screenshot is one continuous image and has no page breaks, while a PDF on a paper size cuts content wherever a page ends unless the CSS of the page says where to break.

- Example: `h2 { break-before: page; }`
- API option: `pdf_fit_one_page`
- Also called: break-before, page-break-before, break-after, pagination
- Category: Printing and PDF
- Related: Page box, PDF, Print media
- Guide: [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes)
- Source: [MDN Web Docs, break-before](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/break-before)
- Link: https://curlshot.com/blog/web-capture-glossary#page-break

### Page-margin box

A page-margin box is one of the 16 boxes that CSS defines in the margin area of a page box, such as `@top-center` or `@bottom-right-corner`, typically used for running headers and footers.

Why it matters for a screenshot: Page numbers and running headers belong to page-margin boxes, so they exist only in paged output such as a PDF and never in a screenshot.

- Example: `@page { @bottom-center { content: counter(page); } }`
- Also called: margin box, running header, running footer, @top-center
- Category: Printing and PDF
- Related: Page box, Print media, PDF
- Guide: [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes)
- Source: [W3C, CSS Paged Media Module Level 3](https://www.w3.org/TR/css-page-3/)
- Link: https://curlshot.com/blog/web-capture-glossary#page-margin-box

### PDF

PDF, the Portable Document Format, is a file format that presents a document the same way regardless of the software, hardware or operating system used to view it. PDF is an open standard maintained by ISO.

Why it matters for a screenshot: Saving a web page as a PDF gives pages of a paper size with text that can be selected and searched, where a screenshot gives one image made of pixels.

- Example: `format=pdf`
- API option: `format`, `pdf_paper_format`
- Also called: Portable Document Format, web page to PDF, print to PDF
- Category: Printing and PDF
- Related: Page box, Print media, PNG
- Guide: [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes)
- Source: [Adobe, What is a PDF?](https://www.adobe.com/acrobat/about-adobe-pdf.html); [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#pdf

### PNG

PNG is an image format that uses lossless compression and supports full alpha transparency.

Why it matters for a screenshot: PNG is the safe default for screenshots, because lossless encoding keeps text and sharp edges exact: MDN recommends lossless encoding for screenshots, diagrams and line art. PNG is the default format of CurlShot.

- Example: `format=png`
- API option: `format`
- Also called: Portable Network Graphics, .png
- Category: Formats
- Related: Lossless compression, Alpha channel, WebP
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#png

### Print media

Print media is the CSS media type `print`, intended for paged material and for documents viewed in print preview. Its counterpart `screen` is intended primarily for screens.

Why it matters for a screenshot: Playwright makes a PDF with the print styles of a page by default, and a site may write those to look quite unlike its screen styles. CurlShot goes the other way: a PDF is drawn with screen styles unless `media_type=print` is set.

- Example: `@media print { nav { display: none; } }`
- API option: `media_type`
- Also called: print stylesheet, @media print, media type, screen media, print styles
- Category: Printing and PDF
- Related: Media query, PDF, Page box
- Guide: [Web page to PDF: paper sizes](https://curlshot.com/blog/web-page-to-pdf-paper-sizes)
- Source: [MDN Web Docs, @media: media types and media features](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@media); [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#print-media

### Quota

A quota is the number of screenshots a plan allows in one billing period. A quota counts work done over a period of weeks, where a rate limit counts requests in a period of seconds or minutes.

Why it matters for a screenshot: In CurlShot only successful renders count against the quota and a cache hit does not. A request beyond the quota is answered with status `402` and the error code `quota_exceeded`.

- Example: `X-Quota-Remaining: 4997`
- Also called: monthly quota, usage limit, allowance, plan limit
- Category: Security and limits
- Related: Rate limit, Cache hit, Time to live
- Guide: [Bulk screenshots from a list of URLs](https://curlshot.com/blog/bulk-screenshots-list-of-urls)
- Source: the CurlShot documentation
- Link: https://curlshot.com/blog/web-capture-glossary#quota

### Rate limit

A rate limit is a cap on how many requests a client may send in a given amount of time. A server that enforces one answers the extra requests with HTTP status 429 Too Many Requests and may add a `Retry-After` header that says how long to wait.

Why it matters for a screenshot: Capturing a long list of addresses in a loop is the usual way to reach a rate limit, so a batch job should pace its requests and retry a 429 after a pause.

- Example: `HTTP/1.1 429 Too Many Requests`
- Also called: rate limiting, 429, Too Many Requests, throttling, Retry-After
- Category: Security and limits
- Related: Quota, Timeout, Webhook
- Guide: [Bulk screenshots from a list of URLs](https://curlshot.com/blog/bulk-screenshots-list-of-urls)
- Source: [IETF, RFC 6585: Additional HTTP Status Codes, section 4 (429 Too Many Requests)](https://www.rfc-editor.org/rfc/rfc6585.html)
- Link: https://curlshot.com/blog/web-capture-glossary#rate-limit

### Screen size

A screen size is the width and height of the whole display of a device, which browsers report in CSS pixels as `screen.width` and `screen.height`. A screen size is a different number from the viewport, which is only the part of the window that shows the page.

Why it matters for a screenshot: A page lays itself out to the viewport, not to the screen, so the size to set for a screenshot is the viewport. The resolution a monitor is sold with, in physical pixels, is a third number again.

- Also called: screen resolution, display resolution, screen.width, monitor resolution
- Category: Layout and pixels
- Related: Viewport, CSS pixel, Device pixel
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, Screen: width property](https://developer.mozilla.org/en-US/docs/Web/API/Screen/width); [Playwright, Emulation](https://playwright.dev/docs/emulation); [MDN Web Docs, Viewport (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Viewport)
- Link: https://curlshot.com/blog/web-capture-glossary#screen-size

### Shadow DOM

A shadow DOM is a DOM tree attached to an element and hidden from the JavaScript and CSS running in the page. The element it is attached to is the shadow host, and the tree starts at a shadow root.

Why it matters for a screenshot: `document.querySelectorAll` does not find elements inside a shadow tree and page CSS does not affect them, so a plain selector or an injected style can miss the inside of a web component.

- Example: `host.attachShadow({ mode: "open" })`
- Also called: shadow root, shadow tree, web component, shadow host
- Category: Layout and pixels
- Related: CSS selector, Iframe, Element screenshot
- Guide: [CSS selectors for element screenshots](https://curlshot.com/blog/css-selectors-for-element-screenshots)
- Source: [MDN Web Docs, Using shadow DOM](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_shadow_DOM)
- Link: https://curlshot.com/blog/web-capture-glossary#shadow-dom

### Signed URL

A signed URL is a URL that carries a signature in its query string and gives whoever holds the link limited permission, and usually limited time, to make one specific request without other credentials.

Why it matters for a screenshot: A signed screenshot link can sit in a public `img` tag: the signature is computed from the exact parameters and a secret key, so changing the address inside the link breaks it. In CurlShot the parameters are `signature` and, for a lifetime, `expires`.

- Example: `...&expires=1791083483&signature=b565e2...`
- API option: `signature`, `expires`
- Also called: signed link, signature, expiring link
- Category: Sharing and previews
- Related: Unix timestamp, Hash, Cache hit
- Guide: [Website thumbnail sizes](https://curlshot.com/blog/website-thumbnail-sizes)
- Source: [Google Cloud Storage docs, Signed URLs](https://docs.cloud.google.com/storage/docs/access-control/signed-urls)
- Link: https://curlshot.com/blog/web-capture-glossary#signed-url

### SSRF

SSRF, server-side request forgery, is an attack in which an attacker abuses a feature of a server that fetches URLs to make it read or update internal resources, such as a cloud metadata service at 169.254.169.254 or an internal REST interface.

Why it matters for a screenshot: A screenshot service opens whatever address it is given, which makes it a natural target for SSRF, so it has to refuse addresses that lead to private or internal networks. CurlShot refuses them.

- Example: `http://169.254.169.254/`
- Also called: server-side request forgery, private address, internal address
- Category: Security and limits
- Related: Rate limit, Webhook, Headless browser
- Guide: [Screenshot API or your own headless browser](https://curlshot.com/blog/screenshot-api-vs-headless-browser)
- Source: [OWASP, Server Side Request Forgery](https://community.owasp.org/attacks/Server_Side_Request_Forgery)
- Link: https://curlshot.com/blog/web-capture-glossary#ssrf

### Sticky positioning

Sticky positioning is the CSS value `position: sticky`, which lays an element out in the normal flow and then offsets it relative to its nearest scrolling ancestor, so it stays in view while that ancestor scrolls. `position: fixed` takes an element out of the flow and positions it relative to the viewport.

Why it matters for a screenshot: Sticky and fixed headers, cookie bars and chat buttons follow the viewport, so in a full-page screenshot they can land in the middle of the image or cover content. Hiding them by selector is the usual fix.

- Example: `hide_selectors=.site-header`
- API option: `hide_selectors`
- Also called: position: sticky, sticky header, fixed header, position: fixed, fixed positioning
- Category: Layout and pixels
- Related: Full-page screenshot, CSS selector, Cookie banner
- Guide: [Why website screenshots look wrong](https://curlshot.com/blog/why-website-screenshots-look-wrong)
- Source: [MDN Web Docs, position: sticky and fixed](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/position)
- Link: https://curlshot.com/blog/web-capture-glossary#sticky-positioning

### Threshold

A threshold is the tolerance of a screenshot comparison. In Playwright the threshold is the acceptable perceived colour difference between the same pixel in two images, from 0 (strict) to 1 (lax) with a default of 0.2, and `maxDiffPixels` separately caps how many pixels may differ.

Why it matters for a screenshot: A threshold of zero fails on rendering noise nobody can see and a loose one hides real changes, so the value decides whether a visual test is useful. The pixelmatch library defaults to 0.1.

- Example: `threshold: 0.2`
- Also called: tolerance, maxDiffPixels, maxDiffPixelRatio, diff threshold
- Category: Testing
- Related: Diff, Baseline, Anti-aliasing
- Guide: [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide)
- Source: [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions); [Mapbox on GitHub, pixelmatch: README](https://github.com/mapbox/pixelmatch)
- Link: https://curlshot.com/blog/web-capture-glossary#threshold

### Time to live

A time to live, or TTL, is the amount of time, in seconds, during which a cached result may be reused before it expires and has to be produced again.

Why it matters for a screenshot: TTL trades freshness for cost: a long one serves the same screenshot many times, a short one renders the page again sooner. In CurlShot `cache_ttl` defaults to 14,400 seconds (4 hours) and runs from 60 seconds to 2,592,000 (30 days).

- Example: `cache_ttl=86400 (one day: 24 x 3,600)`
- API option: `cache_ttl`
- Also called: TTL, cache lifetime, max-age, expiry
- Category: Security and limits
- Related: Cache hit, Quota, Signed URL
- Guide: [Website change monitoring with screenshots](https://curlshot.com/blog/website-change-monitoring-with-screenshots)
- Source: [MDN Web Docs, TTL (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/TTL); [MDN Web Docs, HTTP caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Caching)
- Link: https://curlshot.com/blog/web-capture-glossary#time-to-live

### Timeout

A timeout is the maximum time an operation may take before it is stopped and reported as failed.

Why it matters for a screenshot: A capture waits for the page, and without a timeout a slow or never-idle page would hold a browser for good. In CurlShot the timeout is 30 seconds by default and can be set from 1 to 90.

- Example: `timeout=30`
- API option: `timeout`
- Also called: navigation timeout, render timeout, time limit
- Category: Loading and timing
- Related: Network idle, Load event, Rate limit
- Guide: [Screenshot code examples](https://curlshot.com/blog/screenshot-code-examples)
- Source: [Playwright, Page: goto (waitUntil, timeout), pdf and emulateMedia](https://playwright.dev/docs/api/class-page)
- Link: https://curlshot.com/blog/web-capture-glossary#timeout

### Token

A token is the smallest unit of text a language model reads and writes. A token can correspond to a word, a part of a word, a character or a byte.

Why it matters for a screenshot: Models are limited and priced by tokens, and an image is counted in tokens too, so the size of a screenshot sent to a model is a cost decision.

- Also called: tokens, input tokens, tokenizer
- Category: AI and agents
- Related: Visual token, Vision model, MCP
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [Anthropic, Claude docs, Glossary: tokens, context window, MCP](https://platform.claude.com/docs/en/about-claude/glossary); [Anthropic, Claude docs, Vision: image limits, formats and token cost](https://platform.claude.com/docs/en/build-with-claude/vision)
- Link: https://curlshot.com/blog/web-capture-glossary#token

### Tool call

A tool call is a structured request from a language model to run a named function with arguments. The application or a server runs the function and returns the result to the model. In MCP the request is the `tools/call` method.

Why it matters for a screenshot: Taking a screenshot is a typical tool: the model asks for an address, the tool answers with an image block that holds base64 data and a MIME type, and the model then looks at the page.

- Example: `{ "name": "take_screenshot", "arguments": { "url": "https://example.com" } }`
- Also called: tool use, function calling, function call, tools/call
- Category: AI and agents
- Related: MCP, Vision model, Accessibility tree
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [Anthropic, Claude docs, Tool use with Claude](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview); [Model Context Protocol, Specification 2025-06-18: Tools](https://modelcontextprotocol.io/specification/2025-06-18/server/tools)
- Link: https://curlshot.com/blog/web-capture-glossary#tool-call

### Unix timestamp

A Unix timestamp is a point in time written as the number of seconds since the epoch, the midnight at the beginning of 1 January 1970 UTC. JavaScript counts the same span in milliseconds.

Why it matters for a screenshot: Timestamps say when a screenshot was taken and when a signed link stops working. In CurlShot the `expires` parameter of a signed link and the `x-timestamp` header of a webhook are Unix seconds.

- Example: `86400 = 1970-01-02T00:00:00Z (24 x 3,600 seconds after the epoch)`
- API option: `expires`
- Also called: timestamp, epoch time, Unix time, epoch seconds
- Category: Security and limits
- Related: Signed URL, Hash, Webhook
- Guide: [A web page as evidence](https://curlshot.com/blog/web-page-as-evidence)
- Source: [MDN Web Docs, Date: the epoch and timestamps](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)
- Link: https://curlshot.com/blog/web-capture-glossary#unix-timestamp

### User agent

A user agent is a program that acts for a person on the web, such as a browser. With each request a browser sends a `User-Agent` header, a string that often identifies the browser, its version and its operating system.

Why it matters for a screenshot: A server can read the user agent string and answer with a different page, so the string a capture browser sends can change what is in the screenshot.

- Example: `User-Agent: Mozilla/5.0 ...`
- API option: `user_agent`
- Also called: UA, User-Agent header, user agent string, UA string
- Category: Automation
- Related: Device emulation, Headless browser, Cookie
- Guide: [Screenshot code examples](https://curlshot.com/blog/screenshot-code-examples)
- Source: [MDN Web Docs, User agent (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/User_agent)
- Link: https://curlshot.com/blog/web-capture-glossary#user-agent

### Viewport

A viewport is the part of a document that is visible in the browser window. Its width and height are measured in CSS pixels.

Why it matters for a screenshot: The viewport width decides which layout a responsive page shows, and the viewport is exactly the area a screenshot contains unless a full page or one element is asked for. CurlShot uses 1280 x 1024 unless told otherwise.

- Example: `viewport_width=1280&viewport_height=1024`
- API option: `viewport_width`, `viewport_height`
- Also called: browser window size, window size, visual viewport, layout viewport
- Category: Layout and pixels
- Related: CSS pixel, Screen size, Full-page screenshot
- Guide: [Viewport sizes cheat sheet](https://curlshot.com/blog/viewport-sizes-cheat-sheet)
- Source: [MDN Web Docs, Viewport (glossary)](https://developer.mozilla.org/en-US/docs/Glossary/Viewport)
- Link: https://curlshot.com/blog/web-capture-glossary#viewport

### Vision model

A vision model is a language model that accepts images as input and can describe and analyse them. Claude, for example, accepts JPEG, PNG, GIF and WebP images of up to 8000 x 8000 pixels.

Why it matters for a screenshot: A vision model reads a screenshot much as a person does, but an image above the limit of the model is scaled down first, on Claude to a long edge of 1568 or 2576 pixels depending on the model, and that can make small text unreadable.

- Also called: multimodal model, image understanding, VLM, vision language model
- Category: AI and agents
- Related: Visual token, Token, Tool call
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [Anthropic, Claude docs, Vision: image limits, formats and token cost](https://platform.claude.com/docs/en/build-with-claude/vision)
- Link: https://curlshot.com/blog/web-capture-glossary#vision-model

### Visual regression test

A visual regression test is an automated test that takes a screenshot of a page and compares it with an approved reference screenshot, and fails when the two differ by more than a set tolerance.

Why it matters for a screenshot: A visual regression test catches what a functional test does not look at: a layout that broke, an image that went missing or a colour that changed on a page whose buttons still work.

- Example: `await expect(page).toHaveScreenshot('home.png')`
- Also called: visual test, screenshot test, visual comparison, snapshot test
- Category: Testing
- Related: Baseline, Diff, Flaky test
- Guide: [Visual regression testing guide](https://curlshot.com/blog/visual-regression-testing-guide)
- Source: [Playwright, Visual comparisons](https://playwright.dev/docs/test-snapshots); [Playwright, PageAssertions: toHaveScreenshot options](https://playwright.dev/docs/api/class-pageassertions)
- Link: https://curlshot.com/blog/web-capture-glossary#visual-regression-test

### Visual token

A visual token is the unit in which the Claude models of Anthropic count an image: one patch of 28 x 28 pixels, so an image costs ceil(width / 28) x ceil(height / 28) visual tokens.

Why it matters for a screenshot: Token cost follows pixel count: a 1000 x 1000 screenshot is 36 x 36 = 1,296 visual tokens, so a device pixel ratio of 1 and a capture of only the part that is needed keep the bill down. Other vendors count images in their own ways.

- Example: `1920 x 1080 = 69 x 39 = 2,691 visual tokens before any downscaling`
- Also called: image token, image tokens, image cost, patch
- Category: AI and agents
- Related: Vision model, Token, Image size
- Guide: [Screenshots for AI agents](https://curlshot.com/blog/screenshots-for-ai-agents)
- Source: [Anthropic, Claude docs, Vision: image limits, formats and token cost](https://platform.claude.com/docs/en/build-with-claude/vision)
- Link: https://curlshot.com/blog/web-capture-glossary#visual-token

### Webhook

A webhook is an HTTP request that a service sends to a URL you specify when an event happens, so you receive the data as it happens and do not have to poll an API for it.

Why it matters for a screenshot: A slow render can run in the background and announce itself: CurlShot calls the `webhook_url` when the job ends and signs the body with HMAC-SHA256, so the receiver can check who sent it.

- Example: `async=true&webhook_url=https://example.com/hooks/screenshot`
- API option: `webhook_url`, `async`, `webhook_sign`
- Also called: callback, callback URL, HTTP callback, async result
- Category: Sharing and previews
- Related: Rate limit, Hash, Unix timestamp
- Guide: [Bulk screenshots from a list of URLs](https://curlshot.com/blog/bulk-screenshots-list-of-urls)
- Source: [GitHub Docs, About webhooks](https://docs.github.com/en/webhooks/about-webhooks)
- Link: https://curlshot.com/blog/web-capture-glossary#webhook

### WebP

WebP is an image format that supports both lossy and lossless compression, as well as transparency and animation.

Why it matters for a screenshot: MDN describes WebP as offering much better compression than PNG or JPEG, so a WebP screenshot is usually the lighter file, and it can keep a transparent background.

- Example: `format=webp`
- API option: `format`
- Also called: .webp, lossless WebP, lossy WebP
- Category: Formats
- Related: PNG, JPEG, Alpha channel
- Guide: [PNG, JPEG, WebP or PDF for screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots)
- Source: [MDN Web Docs, Image file type and format guide](https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types)
- Link: https://curlshot.com/blog/web-capture-glossary#webp

## Questions

### What is the difference between a viewport and a screen resolution?

A viewport is the part of the browser window that shows the page, and a page lays itself out to it. A screen resolution describes the whole display. For a screenshot the number to set is the viewport, in CSS pixels.

### What does device pixel ratio mean for a screenshot?

Device pixel ratio is the number of device pixels that draw one CSS pixel along one side. It multiplies the pixel size of a screenshot without changing the layout: a 1280 x 1024 viewport at ratio 2 gives a 2560 x 2048 pixel file with sharper text.

### What is the difference between the load event and network idle?

The load event is fired by the browser when the page and its stylesheets, scripts, iframes and images have loaded, except lazy ones. Network idle is a wait condition a tool measures: in Playwright, no network connections for at least 500 ms. Network idle also covers requests that scripts start after load.

### What is a full-page screenshot?

A full-page screenshot is a screenshot of the full scrollable page, from top to bottom, as if the screen were very tall. Its width still comes from the viewport. Lazy-loaded images need the page to be scrolled before the capture, or they are empty.

### What is the difference between a rate limit and a quota?

A rate limit caps how many requests a client may send in a short time, and a server signals it with HTTP status 429. A quota caps how many screenshots a plan allows in a billing period. In CurlShot a request beyond the quota gets status 402 and a cache hit does not count against it.

### Can I link to a single definition in the glossary?

Yes. Every term has an address of its own: the address of the glossary followed by # and the id of the term, for example #device-pixel-ratio. Each entry has a copy link control that puts that address on the clipboard.

## Sources

1. MDN Web Docs, "Viewport (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Viewport (checked 11 October 2026)
2. MDN Web Docs, "CSS pixel (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/CSS_pixel (checked 11 October 2026)
3. MDN Web Docs, "Window: devicePixelRatio property": https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio (checked 11 October 2026)
4. MDN Web Docs, "Screen: width property": https://developer.mozilla.org/en-US/docs/Web/API/Screen/width (checked 11 October 2026)
5. MDN Web Docs, "Media query (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Media_query (checked 11 October 2026)
6. MDN Web Docs, "@media: media types and media features": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@media (checked 11 October 2026)
7. MDN Web Docs, "position: sticky and fixed": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/position (checked 11 October 2026)
8. MDN Web Docs, "CSS selector (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/CSS_Selector (checked 11 October 2026)
9. MDN Web Docs, "Using shadow DOM": https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_shadow_DOM (checked 11 October 2026)
10. MDN Web Docs, "<iframe>: the inline frame element": https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/iframe (checked 11 October 2026)
11. MDN Web Docs, "Document: DOMContentLoaded event": https://developer.mozilla.org/en-US/docs/Web/API/Document/DOMContentLoaded_event (checked 11 October 2026)
12. MDN Web Docs, "Window: load event": https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event (checked 11 October 2026)
13. MDN Web Docs, "Lazy loading": https://developer.mozilla.org/en-US/docs/Web/Performance/Guides/Lazy_loading (checked 11 October 2026)
14. Playwright, "Page: goto (waitUntil, timeout), pdf and emulateMedia": https://playwright.dev/docs/api/class-page (checked 11 October 2026)
15. Playwright, "Screenshots": https://playwright.dev/docs/screenshots (checked 11 October 2026)
16. Playwright, "PageAssertions: toHaveScreenshot options": https://playwright.dev/docs/api/class-pageassertions (checked 11 October 2026)
17. Playwright, "Visual comparisons": https://playwright.dev/docs/test-snapshots (checked 11 October 2026)
18. Mapbox on GitHub, "pixelmatch: README": https://github.com/mapbox/pixelmatch (checked 11 October 2026)
19. Playwright, "Retries": https://playwright.dev/docs/test-retries (checked 11 October 2026)
20. Playwright, "Emulation": https://playwright.dev/docs/emulation (checked 11 October 2026)
21. Chrome for Developers, "Chrome Headless mode": https://developer.chrome.com/docs/chromium/headless (checked 11 October 2026)
22. MDN Web Docs, "User agent (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/User_agent (checked 11 October 2026)
23. MDN Web Docs, "Using HTTP cookies": https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Cookies (checked 11 October 2026)
24. MDN Web Docs, "Image file type and format guide": https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Image_types (checked 11 October 2026)
25. MDN Web Docs, "Lossless compression (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Lossless_compression (checked 11 October 2026)
26. MDN Web Docs, "Lossy compression (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Lossy_compression (checked 11 October 2026)
27. MDN Web Docs, "Alpha (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Alpha (checked 11 October 2026)
28. MDN Web Docs, "Codec (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Codec (checked 11 October 2026)
29. MDN Web Docs, "Media container formats": https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Containers (checked 11 October 2026)
30. MDN Web Docs, "Frame rate (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/FPS (checked 11 October 2026)
31. ogp.me, "The Open Graph protocol": https://ogp.me/ (checked 11 October 2026)
32. Slack developer docs, "Unfurling links in messages": https://docs.slack.dev/messaging/unfurling-links-in-messages/ (checked 11 October 2026)
33. OWASP, "Server Side Request Forgery": https://community.owasp.org/attacks/Server_Side_Request_Forgery (checked 11 October 2026)
34. IETF, "RFC 6585: Additional HTTP Status Codes, section 4 (429 Too Many Requests)": https://www.rfc-editor.org/rfc/rfc6585.html (checked 11 October 2026)
35. MDN Web Docs, "HTTP caching": https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Caching (checked 11 October 2026)
36. Cloudflare docs, "Cloudflare cache responses": https://developers.cloudflare.com/cache/concepts/cache-responses/ (checked 11 October 2026)
37. MDN Web Docs, "TTL (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/TTL (checked 11 October 2026)
38. Google Cloud Storage docs, "Signed URLs": https://docs.cloud.google.com/storage/docs/access-control/signed-urls (checked 11 October 2026)
39. GitHub Docs, "About webhooks": https://docs.github.com/en/webhooks/about-webhooks (checked 11 October 2026)
40. MDN Web Docs, "Hash function (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Hash_function (checked 11 October 2026)
41. MDN Web Docs, "Date: the epoch and timestamps": https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date (checked 11 October 2026)
42. European Union, Your Europe, "Online privacy: cookies": https://europa.eu/youreurope/business/dealing-with-customers/data-protection/online-privacy/index_en.htm (checked 11 October 2026)
43. Information Commissioner’s Office (UK), "How do we manage consent in practice?": https://ico.org.uk/for-organisations/direct-marketing-and-privacy-and-electronic-communications/guidance-on-the-use-of-storage-and-access-technologies/how-do-we-manage-consent-in-practice/ (checked 11 October 2026)
44. Model Context Protocol, "What is the Model Context Protocol (MCP)?": https://modelcontextprotocol.io/docs/getting-started/intro (checked 11 October 2026)
45. Model Context Protocol, "Specification 2025-06-18: Tools": https://modelcontextprotocol.io/specification/2025-06-18/server/tools (checked 11 October 2026)
46. Anthropic, Claude docs, "Glossary: tokens, context window, MCP": https://platform.claude.com/docs/en/about-claude/glossary (checked 11 October 2026)
47. Anthropic, Claude docs, "Vision: image limits, formats and token cost": https://platform.claude.com/docs/en/build-with-claude/vision (checked 11 October 2026)
48. Anthropic, Claude docs, "Tool use with Claude": https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview (checked 11 October 2026)
49. MDN Web Docs, "Accessibility tree (glossary)": https://developer.mozilla.org/en-US/docs/Glossary/Accessibility_tree (checked 11 October 2026)
50. W3C, "CSS Paged Media Module Level 3": https://www.w3.org/TR/css-page-3/ (checked 11 October 2026)
51. MDN Web Docs, "break-before": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/break-before (checked 11 October 2026)
52. Adobe, "What is a PDF?": https://www.adobe.com/acrobat/about-adobe-pdf.html (checked 11 October 2026)
53. MDN Web Docs, "font-smooth": https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/Properties/font-smooth (checked 11 October 2026)

## Go deeper

- [Options reference: every API option](https://curlshot.com/docs/options)
- [Waiting for the page to be ready](https://curlshot.com/docs/waiting)
- [Full-page screenshot tool](https://curlshot.com/tools/full-page-screenshot)
- [The screenshot API](https://curlshot.com/tools/screenshot-api)
- [Using the API from AI agents](https://curlshot.com/docs/guides/ai-agents)

## 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.
- [Why website screenshots look wrong, and the fixes](https://curlshot.com/blog/why-website-screenshots-look-wrong.md): A field guide to 11 ways a website screenshot goes wrong, from blank lazy images to cookie banners and cut-off pages, with the cause and the fix for each.
- [Screenshots for AI agents: let a model see a page](https://curlshot.com/blog/screenshots-for-ai-agents.md): When to give an AI agent a screenshot, HTML, markdown or the accessibility tree, what a screenshot costs in tokens on each vendor, and how to wire it up.
