Supported Video File Types - URL to GIF, WebM & MP4 Output Formats
Choose the format to save your scrolling screenshot. You can export full-page captures in MP4, GIF, or WEBM, ensuring flexibility for documentation, sharing, and more.
Capture entire webpages with a single full page screenshot ideal for presentations, documentation, and design reviews. Our scrolling screenshot tool lets you export in multiple formats, adjust resolution and aspect ratio, and take a full page screen capture from any public or protected website with ease.
https://shot.screenshotapi.net/v3/screenshot?token={token}&url=https://linear.app/&width=1680&height=876&scrolling_screenshot=true&file_type=mp4
Reliability
ScreenshotAPI runs in live pipelines for thousands of developers from solo projects to enterprise monitoring systems. Here's what that actually looks like in practice.
100 free screenshots to start
No credit card required. Full API access from day one.
Comparison
An honest breakdown. Puppeteer is a capable tool but for most teams that need scrolling captures at scale, the operational overhead isn't worth it.
| Capability | ScreenshotAPI | Puppeteer / Playwright |
|---|---|---|
| Setup required | API call only | Node.js + Chromium + dependencies |
Puppeteer requires a local or hosted Chromium binary. On Linux servers you'll also need system libraries: libgbm, libasound2, libgtk-3-0, and more. | ||
| Full-page scrolling video output | Built-in (MP4, GIF, WebM) | Possible, but complex |
Puppeteer has no native scrolling video. You'd need to scroll manually, capture frames with canvas, and encode them using ffmpeg, dozens of lines of brittle code. | ||
| Lazy-load content rendering | Handled automatically | Manual scroll loops required |
ScreenshotAPI's scroll_back and scroll_speed parameters handle lazy-loaded content. With Puppeteer you need to write your own scroll-wait-check loop. | ||
| Infrastructure to maintain | None | Yes server, memory, process crashes |
Puppeteer in production needs memory management, crash recovery, concurrency limits, and regular Chromium version updates. | ||
| Authenticated page capture | Cookies + headers supported | Full control |
Both support authenticated pages. ScreenshotAPI handles session cookies and custom headers; Puppeteer gives you programmatic control over the full browser session. | ||
| Output formats | PNG, JPEG, PDF, MP4, GIF, WebM | PNG, JPEG, PDF only natively |
Puppeteer does not natively output video or GIF. Those formats need additional tooling. | ||
| Concurrency / scaling | Handled by the API | You manage browser pool |
Parallel Puppeteer instances are memory-heavy (~150–200MB per browser). You need a queue, pool manager, and autoscaling. ScreenshotAPI handles this for you. | ||
| Time to first capture (new project) | ~5 minutes | Hours to days for production setup |
With ScreenshotAPI, a working curl command takes 5 minutes. Getting Puppeteer production-ready with concurrency, error handling, and a server takes significantly longer. | ||
Setup required
Puppeteer requires a local or hosted Chromium binary. On Linux servers you'll also need system libraries: libgbm, libasound2, libgtk-3-0, and more.
Full-page scrolling video output
Puppeteer has no native scrolling video. You'd need to scroll manually, capture frames with canvas, and encode them using ffmpeg, dozens of lines of brittle code.
Lazy-load content rendering
ScreenshotAPI's scroll_back and scroll_speed parameters handle lazy-loaded content. With Puppeteer you need to write your own scroll-wait-check loop.
Infrastructure to maintain
Puppeteer in production needs memory management, crash recovery, concurrency limits, and regular Chromium version updates.
Authenticated page capture
Both support authenticated pages. ScreenshotAPI handles session cookies and custom headers; Puppeteer gives you programmatic control over the full browser session.
Output formats
Puppeteer does not natively output video or GIF. Those formats need additional tooling.
Concurrency / scaling
Parallel Puppeteer instances are memory-heavy (~150–200MB per browser). You need a queue, pool manager, and autoscaling. ScreenshotAPI handles this for you.
Time to first capture (new project)
With ScreenshotAPI, a working curl command takes 5 minutes. Getting Puppeteer production-ready with concurrency, error handling, and a server takes significantly longer.
This comparison applies to Playwright as well. It has the same infrastructure requirements and video output limitations as Puppeteer. If your team needs full browser scripting control, self-hosting is the right call. If you need reliable scrolling captures without the ops overhead, the API is faster.
Ensure nothing is missed during full-page captures with Scroll Back. When enabled, the API scrolls through the entire page and then scrolls back up before taking the screenshot, allowing sticky headers, dynamic elements, and lazy-loaded content to render properly. This ensures your screenshots look exactly like a real user’s view—complete, stable, and fully loaded.
Control how quickly the page scrolls while capturing with the Scroll Speed option. Choose Fast for efficiency, Normal for balanced performance, or Slow when you need extra time for animations, videos, or lazy-loading content to appear. Adjusting scroll speed gives you precise control over rendering, so your screenshots capture every detail without missing visual elements.
Duration defines how long the API will record a video of the webpage. This is useful when you want to capture user interactions, animations, or dynamic content over a specific period of time. By setting the duration, you can control how many seconds of the page activity are recorded, ensuring you capture the exact sequence you need.
Choose the format to save your scrolling screenshot. You can export full-page captures in MP4, GIF, or WEBM, ensuring flexibility for documentation, sharing, and more.
Technical Reference
Every parameter that controls scrolling behavior, output format, viewport size, and timing. All parameters are passed as query strings on the /v3/screenshot endpoint.
| Parameter | Type | Default | Description |
|---|---|---|---|
scrolling_screenshot | boolean | false | Enables scrolling capture mode. Returns a video file instead of a static image. |
file_type | string | mp4 | Output format for scrolling captures. Accepted values: mp4, gif, webm. |
scroll_speed | string | normal | Controls how quickly the browser scrolls. Values: fast, normal, slow. Use slow for pages with lazy-loaded images or CSS scroll animations. |
scroll_back | boolean | false | When true, the browser scrolls to the bottom and back to the top before capturing. Ensures sticky/fixed elements and lazy-loaded content render correctly. |
duration | integer | — | Length of the recording in seconds. Use when you want to capture a fixed time window of page activity, independent of scroll progress. |
width | integer | 1680 | Viewport width in pixels. Affects responsive layout breakpoints. Common values: 375 (mobile), 768 (tablet), 1280–1920 (desktop). |
height | integer | 876 | Initial viewport height. For scrolling captures, the total captured height extends beyond this value as the page scrolls. |
delay | integer | 0 | Wait time in milliseconds before the scroll sequence begins. Useful for pages with load animations or deferred rendering. |
token | string | — | Your API authentication token. Required on every request. Supports both public and authenticated (cookie/header) page captures. |
scrolling_screenshotbooleanEnables scrolling capture mode. Returns a video file instead of a static image.
Default: false
file_typestringOutput format for scrolling captures. Accepted values: mp4, gif, webm.
Default: mp4
scroll_speedstringControls how quickly the browser scrolls. Values: fast, normal, slow. Use slow for pages with lazy-loaded images or CSS scroll animations.
Default: normal
scroll_backbooleanWhen true, the browser scrolls to the bottom and back to the top before capturing. Ensures sticky/fixed elements and lazy-loaded content render correctly.
Default: false
durationintegerLength of the recording in seconds. Use when you want to capture a fixed time window of page activity, independent of scroll progress.
Default: —
widthintegerViewport width in pixels. Affects responsive layout breakpoints. Common values: 375 (mobile), 768 (tablet), 1280–1920 (desktop).
Default: 1680
heightintegerInitial viewport height. For scrolling captures, the total captured height extends beyond this value as the page scrolls.
Default: 876
delayintegerWait time in milliseconds before the scroll sequence begins. Useful for pages with load animations or deferred rendering.
Default: 0
tokenstringYour API authentication token. Required on every request. Supports both public and authenticated (cookie/header) page captures.
Default: —
How It Works
Four steps from API request to a complete full-page video capture. No browser setup, no Puppeteer scripts, no headless server to maintain.
Add the scrolling_screenshot parameter to your standard screenshot API call. You can combine it with any other parameter (width, height, file_type, full_page, delay) exactly as you would for a static capture.
scrolling_screenshot=true&file_type=mp4A real Chromium instance opens the target page. JavaScript runs, fonts load, network requests complete. This isn't a simple HTTP fetch, it's a full browser render, which means SPAs, iframes, and dynamic content all behave as they would for a real visitor.
url=https://yoursite.com&width=1440&height=900The API scrolls from top to bottom at your chosen speed (fast, normal, or slow). Lazy-loaded images and scroll-triggered animations fire naturally during the scroll. Enable Scroll Back to ensure sticky headers and fixed elements render correctly before the final capture.
scroll_speed=slow&scroll_back=trueThe full scroll sequence is encoded as MP4, GIF, or WebM and returned to your API call. You get a direct URL to the output file. The total time depends on page complexity and scroll speed.
file_type=mp4Code Examples
Copy a working example for your stack. Every example uses real endpoint parameters, swap in your token and URL and run it.
const fetch = require("node-fetch");
const fs = require("fs");
async function captureScrollingScreenshot(url) {
const params = new URLSearchParams({
token: process.env.SCREENSHOT_API_TOKEN,
url: url,
width: "1440",
height: "900",
scrolling_screenshot: "true",
scroll_speed: "slow", // slow | normal | fast
scroll_back: "true", // re-scroll up for sticky headers
file_type: "mp4",
});
const endpoint = `https://shot.screenshotapi.net/v3/screenshot?${params}`;
const response = await fetch(endpoint);
if (!response.ok) {
const err = await response.json();
throw new Error(`API error: ${err.message}`);
}
const buffer = await response.buffer();
fs.writeFileSync("output.mp4", buffer);
console.log("Saved scrolling screenshot to output.mp4");
}
captureScrollingScreenshot("https://example.com").catch(console.error);
Use Cases
From CI pipelines to client reports anywhere you need the full page, not just the viewport.
Capture full-length product pages, including reviews, related items, and recommendations below the fold, for competitive analysis, price monitoring, or historical records of how your own pages looked over time.
Integrate scrolling captures into your CI pipeline to detect layout regressions across full pages, not just the viewport. Catch broken components, content overflow, and z-index issues that only appear further down the page.
Archive full-page captures of terms of service, competitor websites, news articles, or public content at a specific point in time. Useful for compliance teams, legal evidence, and preserving content before it changes or disappears.
Schedule recurring scrolling captures to detect when page content, layouts, or calls-to-action change. Pair with a diffing tool to get alerted when a competitor changes pricing, a vendor updates terms, or a news story gets edited.
Generate scroll-through videos of dashboards, landing pages, or data visualizations to embed in client decks or weekly reports. Beats sending a static crop that cuts off the most important parts of a long analytics page.
Capture the full visible state of regulated web content cookie banners, disclosure text, pricing pages for audit trails. Scrolling captures prove that required elements were present and visible at a given date and time.
Frequently Asked Question
Answers to the questions we get most often from developers integrating full-page capture into their workflows.
Don't see your question here?
Browse all help articles