# Record a web page as video: MP4, WebM or GIF

> How to record a web page scrolling from top to bottom, and which file to make: MP4, WebM or GIF compared, with measured file sizes and where each one plays.

Comparison by Serghei Pogor, founder of CurlShot (https://curlshot.com/about/serghei-pogor). Published 24 October 2026. Page for people: https://curlshot.com/blog/website-video-mp4-webm-gif

To make a video of a website scrolling, open the page in a window of a fixed size, scroll it at a steady pace, capture one image per frame and encode the frames. Choose MP4 (H.264) by default: it plays in every browser, phone, editor and slide deck. Add WebM (VP9) as the first source on a web page for a smaller file, and use a GIF only where video does not play, such as an email or a README. In our test of 120 frames at 640 x 360, the GIF was 25 times the size of the MP4. CurlShot records all three from one request.

## Key facts

- Total frames = seconds x frames per second. An 8 second video at 24 fps is 192 frames; at 5 fps it is 40.
- A GIF frame has at most 256 colours, no sound and a frame delay counted in hundredths of a second. It stores every frame with lossless LZW compression, which is why it is large.
- Measured on 11 October 2026: the same 120 frames of a scrolling Wikipedia article at 640 x 360 were 0.25 MB as WebM (VP9), 0.34 MB as MP4 (H.264) and 8.52 MB as GIF.
- On a web page, a video tag with autoplay, muted, loop and playsinline replaces a GIF. Browsers let a video start by itself only when it is muted or has no sound track.
- GitHub takes .mp4, .mov and .webm attachments in issues and pull requests: 10 MB for a video on a free plan, 100 MB on a paid plan, 10 MB for a GIF.
- CurlShot records a page as mp4, webm or gif: 1 to 30 seconds, 5 to 30 frames per second (24 by default, 15 at most for a GIF), without sound.

## A scrolling video is a filmstrip

A video of a web page scrolling is a row of screenshots of one window, each taken a little further down the page. Two numbers decide how many there are:

```
total frames = seconds x frames per second
```

The model on the page is 1280 x 4320 pixels in a 1280 x 720 window, so it can scroll 3,600 pixels. At an even speed, the page moves 3,600 / (frames - 1) pixels between two frames.

| Length | Frames per second | Total frames | Page moves per frame | Screens per second | What it looks like |
| --- | --- | --- | --- | --- | --- |
| 8 s | 5 | 8 x 5 = 40 | 92.3 px | 0.63 | A slide show: the page jumps an eighth of a screen at a time. |
| 8 s | 15 | 8 x 15 = 120 | 30.3 px | 0.63 | The most a GIF from the API takes. Readable, slightly stepped. |
| 8 s | 24 | 8 x 24 = 192 | 18.8 px | 0.63 | The default frame rate. Smooth for a scroll. |
| 8 s | 30 | 8 x 30 = 240 | 15.1 px | 0.63 | The maximum. A quarter more frames than 24 for a small gain. |
| 4 s | 24 | 4 x 24 = 96 | 37.9 px | 1.25 | Half the length: the same step per frame as 8 s at 12 fps, and too fast to read. |
| 16 s | 24 | 16 x 24 = 384 | 9.4 px | 0.31 | Twice the length: easy to read, and twice the frames to store. |

More frames per second: smoother motion and a larger file. A longer video: a slower scroll that is easier to read, and more frames to store.

## MP4, WebM and GIF compared

|  | MP4 (H.264) | WebM (VP9 or AV1) | GIF |
| --- | --- | --- | --- |
| **What it is** | A video container. On the web it almost always holds H.264 (AVC) video. | An open video container. It holds VP8, VP9 or AV1 video. | An image format (GIF89a) that can hold several frames. |
| **Compression** | Lossy. Stores a full key frame now and then, and only the changes in between. | Lossy, with the same key frame and changes method. | Lossless LZW, but only after every frame is reduced to a small palette. |
| **Colours** | Full colour. | Full colour. | At most 256 per frame: each pixel is an 8-bit index into a colour table of 2 to 256 entries. More colours are faked with dithering. |
| **Transparency** | No. | VP9 can carry an alpha channel, but Safari does not play it. | One palette entry can be fully transparent. A pixel is see-through or it is not. |
| **Sound** | Yes, usually AAC. | Yes: Opus or Vorbis. | No. |
| **Frame timing** | Any frame rate. | Any frame rate. | Each frame waits a whole number of hundredths of a second, so 15 frames per second is stored as waits of 7, 6 and 7 hundredths. |
| **Looping** | The player decides: `loop` on the `<video>` tag. | The player decides: `loop` on the `<video>` tag. | Stored in the file by an application extension. The GIF89a specification itself defines no loop count. |
| **Browsers** | H.264 plays in all versions of Chrome, Edge, Firefox, Opera and Safari. | VP9 plays in all current browsers. Safari has full WebM support from 16.0 on macOS and 17.4 on iOS. AV1 in Safari needs a hardware decoder: an M3 Mac or later, iPhone 15 Pro, iPhone 16 or later. | Everywhere an image is shown. |
| **Plays by itself** | Only with `autoplay`, and only when the video is muted or has no sound track. Safari also needs `playsinline`. | The same rules as MP4. | Always. There is no play button, no pause and no way to seek. |
| **HTML** | `<video>` | `<video>` | `<img>` |
| **Use it for** | Almost everything: it is the one format every player, phone and editor opens. | Web pages, as the first `<source>` with an MP4 behind it. | Places that show images but not video: an email, a README. |

Two more formats animate:

- **Animated WebP**: An image format with frames, lossy (built on the VP8 video codec) or lossless, with transparency and looping. It works in current versions of all major browsers; Safari needs version 14 and macOS 11 or later.
- **APNG**: An animated PNG: lossless, full colour with an alpha channel. Supported since Chrome 59, Edge 12, Firefox 3 and Safari 8.

## File sizes: our measurement, 11 October 2026

One recording, three encodings. Each page was opened in Chromium in a 1280 x 720 window and scrolled 36 pixels per frame for 120 frames: 8 seconds at 15 frames per second. The same PNG frames were encoded with ffmpeg 8.1.2, each encode with two threads. 1 MB = 1,000,000 bytes.

| Page | Frame size | WebM (VP9) | MP4 (H.264) | GIF | GIF against MP4 |
| --- | --- | --- | --- | --- | --- |
| Wikipedia: Eiffel Tower | 1280 x 720 | 0.67 MB | 0.83 MB | 18.7 MB | 23x |
| Wikipedia: Eiffel Tower | 640 x 360 | 0.25 MB | 0.34 MB | 8.52 MB | 25x |
| Wikipedia: Web browser | 1280 x 720 | 0.65 MB | 0.90 MB | 16.2 MB | 18x |
| Wikipedia: Web browser | 640 x 360 | 0.24 MB | 0.32 MB | 8.20 MB | 26x |

Pages: https://en.wikipedia.org/wiki/Eiffel_Tower and https://en.wikipedia.org/wiki/Web_browser.

```bash
# frames: 120 PNG files, f0000.png to f0119.png, 1280 x 720
ffmpeg -framerate 15 -i f%04d.png -vf format=yuv420p \
  -c:v libx264 -preset veryfast -crf 22 -movflags +faststart -an -threads 2 out.mp4

ffmpeg -framerate 15 -i f%04d.png -vf format=yuv420p \
  -c:v libvpx-vp9 -b:v 0 -crf 33 -row-mt 1 -an -threads 2 out.webm

ffmpeg -framerate 15 -i f%04d.png -vf palettegen=stats_mode=diff \
  -frames:v 1 -update 1 -threads 2 palette.png
ffmpeg -framerate 15 -i f%04d.png -i palette.png \
  -lavfi paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle -loop 0 -threads 2 out.gif

# the 640 x 360 files: the same, with scale=640:-2:flags=lanczos first in the filter
```

This is one test of two text-heavy pages with these settings, not a law. CRF 22 for H.264 and CRF 33 for VP9 are different scales, so the two videos are close in quality but not identical: all twelve files scored between 0.986 and 0.997 on SSIM against the source frames. In all four runs the WebM was the smallest file and the GIF the largest.

### Thread count changes the size of an H.264 scroll

Same frames, same libx264 settings, only `-threads` changed, on a 10-core machine. Without `-threads`, ffmpeg chooses the number itself.

| Page | Frame size | 1 thread | 2 threads | ffmpeg default | Default against 2 threads |
| --- | --- | --- | --- | --- | --- |
| Wikipedia: Eiffel Tower | 1280 x 720 | 0.83 MB | 0.83 MB | 6.38 MB | 7.7x |
| Wikipedia: Eiffel Tower | 640 x 360 | 0.34 MB | 0.34 MB | 0.88 MB | 2.6x |
| Wikipedia: Web browser | 1280 x 720 | 0.90 MB | 0.90 MB | 7.02 MB | 7.8x |
| Wikipedia: Web browser | 640 x 360 | 0.32 MB | 0.32 MB | 0.86 MB | 2.7x |

For a scrolling page, encode H.264 with one or two threads. The WebM and GIF files were the same size, byte for byte, with `-threads 2` and with the default.

## Which format for which job

| Where it goes | MP4 | WebM | GIF | Why |
| --- | --- | --- | --- | --- |
| Landing page hero | Best | Best | Avoid | Use a muted, looping `<video>` with a WebM source first and an MP4 source second. The browser plays the first one it understands, at a fraction of the bytes of a GIF. |
| Product demo in documentation | Best | Works | Works | An MP4 with `controls` lets the reader pause and scrub. Choose MP4 when you can ship only one file: it is the format available on the widest range of devices and browsers. |
| Pull request or issue on GitHub | Best | Works | Works | GitHub accepts .mp4, .mov and .webm attachments in issues, pull requests and comments, and recommends H.264. Limits: 10 MB for a video on a free plan, 100 MB on a paid plan, 10 MB for a GIF. |
| README file | Not documented | Not documented | Best | A GIF committed to the repository is an image, and a README shows images from a relative path. GitHub documents video attachments for issues, pull requests and comments, not for README files. |
| Chat message | Not documented | Not documented | Not documented | Slack takes files up to 1 GB, but its upload article does not say which formats play inside a message. Send an MP4 with H.264, the format with the widest support elsewhere, and check it in your own workspace. |
| Email | Not documented | Not documented | Best | Outlook plays animated GIFs in the body of a message by default, and shows only the first frame when animations are turned off. Make the first frame say enough. Keep the file small: it travels with every copy. |
| Post on X | Best | Not documented | Works | X recommends H.264 High Profile video at 1280 x 720, 60 frames per second or less. An animated GIF may be 15 MB, 1280 x 1080, 350 frames and 300 million pixels in total (width x height x frames). WebM is not on its list. |
| Slide deck | Best | Works | Works | PowerPoint recommends .mp4 with H.264 video and AAC audio. WebM is on its Windows list only. A GIF inserted as a picture plays in the slide show, but not in PowerPoint for the web. |

"Not documented" means the platform's own documentation, as read on 11 October 2026, does not say.

### The video tag that replaces a GIF

```html
<video autoplay muted loop playsinline width="1280" height="720" poster="page.jpg">
  <source src="page.webm" type="video/webm" />
  <source src="page.mp4" type="video/mp4" />
</video>
```

- `autoplay`: Starts playing as soon as it can. Browsers allow it without a click only when the video is muted or has no sound track.
- `muted`: Silences the sound, which is what lets `autoplay` through.
- `loop`: Seeks back to the start when the video reaches the end.
- `playsinline`: Plays inside the element instead of full screen. Required for autoplay in Safari.
- `poster`: An image shown while the video downloads. Without it nothing is displayed until the first frame is available.

Motion that starts by itself bothers some visitors. Add `controls`, or leave out `autoplay` for visitors whose system asks for reduced motion (`prefers-reduced-motion: reduce`).

## How a scroll recording works

1. **Open the page.** In a browser window of a fixed size. The window is the frame of the video.
2. **Let it settle.** Wait for fonts and images, and scroll through once so content that loads late is there.
3. **Scroll and capture.** Move the page a set distance, capture the window, repeat: one image per frame.
4. **Encode.** Hand the frames to an encoder such as ffmpeg, which writes the MP4, WebM or GIF.

The settings that matter:

- **Window size.** Sets the layout the page shows and the pixels of every frame. 1280 x 720 is a common landscape choice; a phone-sized window gives a vertical video of the mobile layout.
- **Length.** Together with the height of the page it sets the scroll speed. Three quarters of a screen per second is easy to follow.
- **Frame rate.** Sets how far the page jumps between frames. Total frames = seconds x frames per second.
- **Easing.** A scroll that starts and stops softly looks deliberate. One even speed suits a loop.
- **Rests.** A pause on the first and the last screen gives the viewer time to see where the video starts and ends.
- **Lazy content.** Images that load only when they come into view appear late or blank unless the page is scrolled through once before recording.
- **Sticky headers.** A header that sticks to the top stays in every frame, because the page really scrolls. Hide it with CSS if it covers too much.
- **Animations.** Carousels, counters and videos on the page keep moving while it scrolls, and every moving pixel costs bytes. Stop them if the scroll is the point.

## Record it by hand: screen recording and ffmpeg

Every current system has a free screen recorder.

| System | Steps | What you get |
| --- | --- | --- |
| macOS | 1. Press Shift-Command-5. 2. Choose "Record Selected Portion" and drag the box over the page. 3. Start, scroll the page, then press Command-Control-Esc to stop. | A .mov file on the desktop. |
| Windows 11 | 1. Press Windows logo key + Shift + R. 2. Select the area of the screen to record, then select Start. 3. Scroll the page, then select Stop and save. | A video file from Snipping Tool, which can also open it in Clipchamp. |
| iPhone and iPad | 1. Swipe down from the top-right corner to open Control Center. 2. Tap the Record button and wait for the three-second countdown. 3. Scroll the page, then tap the Screen Recording button at the top of the screen and tap Stop. | A video in the Photos app. |
| Android | 1. Swipe down twice from the top of the screen. 2. Tap Screen record, choose what to record and tap Start. 3. Scroll the page, then swipe down and tap the Screen recorder notification. | A video in Photos, under Collections, On this device, Movies. |

A hand-scrolled recording has an uneven pace and shows the cursor. Record a selected area so the browser's own bars stay out.

Convert the recording to a good-quality GIF with one ffmpeg command:

```bash
ffmpeg -i recording.mov -vf "fps=15,scale=640:-1:flags=lanczos,split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle" -loop 0 page.gif
```

- `fps=15`: Keeps 15 frames per second. Halving the frame rate roughly halves the frames to store.
- `scale=640:-1:flags=lanczos`: Scales to 640 pixels wide with a sharp resampler. The height follows.
- `palettegen=stats_mode=diff`: Builds one palette of up to 256 colours for the whole video, counting only the part of each frame that differs from the one before.
- `paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle`: Applies the palette with an ordered dither, and redraws only the rectangle that changed in each frame.
- `-loop 0`: Loops for ever.

To an MP4 or a WebM for a web page:

```bash
ffmpeg -i recording.mov -c:v libx264 -crf 22 -pix_fmt yuv420p -movflags +faststart -an -threads 2 page.mp4
ffmpeg -i recording.mov -c:v libvpx-vp9 -b:v 0 -crf 33 -an page.webm
```

## Record it with one request

CurlShot opens the page in a browser, plans one scroll position per frame, captures each frame and encodes them with ffmpeg. The page is not filmed in real time, so the same request gives the same frames.

```bash
curl "https://curlshot.com/api/v1/screenshot?access_key=YOUR_ACCESS_KEY&url=https://example.com&format=mp4&video_duration=8&video_fps=24&video_scroll_easing=ease_in_out" \
  --output page.mp4
```

A page that fits in the window has nothing to scroll and is recorded standing still.

| Option | Default | Values | What it does |
| --- | --- | --- | --- |
| `format` | png | `mp4`, `webm`, `gif` for a video | MP4 is H.264, WebM is VP9, GIF gets a palette built from the whole recording. |
| `video_duration` | none | 1 to 30 seconds | Exact length of the video. Left out, the length follows the height of the page at about three quarters of a screen per second. |
| `video_max_duration` | 30 | 1 to 30 seconds | Ceiling when the length follows the page. A taller page then scrolls faster. |
| `video_fps` | 24 (gif: 15) | 5 to 30; gif at most 15 | Frames per second. |
| `video_scroll` | true | `true`, `false` | Scroll from top to bottom. With `false` the first screen is recorded without moving, for 4 seconds unless a length is set. |
| `video_scroll_back` | false | `true`, `false` | Scroll back to the top at the end, so a loop has no jump. |
| `video_scroll_easing` | ease_in_out | `ease_in_out`, `linear` | A soft start and stop with one even speed in between, or one speed throughout. |
| `viewport_width, viewport_height` | 1280 x 720 for a video | one frame holds at most 2,073,600 pixels (1920 x 1080) | The window, and so the frame. `viewport_device` sets a phone or tablet instead. |
| `image_width` | frame width (gif: 640) | up to the frame width | Scales the video down. The height follows. A video is never scaled up. |
| `image_quality` | 80 | 1 to 100 | How hard an MP4 or WebM is compressed. 80 means CRF 22 for H.264 and CRF 33 for VP9. |
| `full_page_max_height` | 20000 | 100 to 30,000 pixels | How far down the video scrolls on a very tall page. |

For an 8 second video of the model page, the recording rests 0.6 seconds on the top, scrolls, and rests 0.8 seconds on the bottom. Left to follow the page, the same page gives a video of 8.1 seconds. A GIF is recorded at 15 frames per second at most and scaled to 640 pixels wide unless `image_width` says otherwise. A video counts as one screenshot against the quota, and takes about twice as long to make as it lasts.

What it does not do:

- No sound. Every video is written without an audio track.
- No AV1, animated WebP or APNG output: the three video formats are `mp4`, `webm` and `gif`.
- No typing or clicking while it records. Clicks, scripts and custom CSS run before the recording starts; during it the page only scrolls.
- Nothing longer than 30 seconds, and a plan can set a lower maximum.
- No transparent background, element or clipped-area videos: `omit_background`, `selector`, the `clip_*` options, `image_height` and `full_page=true` are refused with a video format.

More: [record a scrolling video of a website](https://curlshot.com/tools/website-scrolling-video), [scrolling videos in the docs](https://curlshot.com/docs/video).

## Glossary

- **Container**: The file format that wraps the video and sound streams: MP4 and WebM are containers. The file extension names the container, not the codec.
- **Codec**: The method that compresses and decompresses the video itself: H.264, VP9 and AV1 are codecs. One container can hold different codecs.
- **Frame rate**: The number of images shown per second (fps). It sets how smooth motion looks, and higher frame rates give larger files.
- **Bitrate**: The amount of data per second of video. File size = bitrate x length. A constant-quality setting such as CRF lets the bitrate follow what the frames need.
- **Palette**: The table of colours a GIF frame may use, 2 to 256 entries. Every pixel stores the number of one entry.
- **Key frame**: A frame stored whole. The frames after it store only what changed, so a player must start decoding at a key frame.
- **Loop**: Playing again from the start when the end is reached. A video loops when its player says so; a GIF carries its loop count in the file.
- **Dithering**: Mixing dots of the available colours so that an area looks like a colour the palette does not have.

## Questions

### How do I make a video of a website scrolling from top to bottom?

Either record your screen while you scroll (Shift-Command-5 on a Mac, Windows logo key + Shift + R on Windows 11) and convert the recording with ffmpeg, or let a tool do the scrolling. With CurlShot you send the address of the page with format=mp4 and get the video back: the page in a 1280 by 720 window, scrolled from the top to the bottom at a steady pace.

### Should a website recording be MP4, WebM or GIF?

MP4 with H.264 video unless you have a reason not to: every browser, phone, video editor and slide deck plays it. WebM with VP9 is usually smaller and suits web pages, with an MP4 as the fallback source. A GIF is the largest of the three and has only 256 colours per frame, so keep it for places that show images but not video, such as an email or a README file.

### Why is a GIF so much bigger than an MP4?

A GIF compresses each frame on its own with lossless LZW, after reducing it to at most 256 colours. A video codec such as H.264 or VP9 stores a full key frame now and then and only the changes in between, and it is allowed to lose detail. In our measurement of 120 frames at 640 x 360, the GIF was 8.52 MB, the MP4 0.34 MB and the WebM 0.25 MB.

### How many frames per second does a scrolling video need?

A scroll looks smooth at 24 frames per second, and 15 is enough for a GIF. What the eye notices is how far the page jumps between two frames: a page that scrolls 3,600 pixels in 8 seconds moves 19 pixels per frame at 24 fps and 92 pixels per frame at 5 fps. More frames per second also means a larger file.

### How do I replace a GIF with a video on a web page?

Use a video element with the attributes autoplay, muted, loop and playsinline, and give it a WebM source followed by an MP4 source. Browsers allow autoplay when the video is muted or has no sound track, Safari requires playsinline for it, and the browser plays the first source it understands.

### Can I put a video in a GitHub README or pull request?

In an issue, a pull request or a comment, yes: GitHub accepts .mp4, .mov and .webm files there, up to 10 MB on a free plan and 100 MB on a paid plan, and recommends H.264. Its documentation does not describe video attachments for README files. A GIF committed to the repository works in a README, because it is an image.

### Does a video from CurlShot have sound, and how long can it be?

No sound: every video is written without an audio track. A video is 1 to 30 seconds long, and a plan can set a lower maximum. Without video_duration the length follows the height of the page, at about three quarters of a screen per second.

## Sources

1. MDN Web Docs, "Media container formats (file types)": https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Containers (checked 11 October 2026)
2. MDN Web Docs, "Web video codec guide": https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Formats/Video_codecs (checked 11 October 2026)
3. 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)
4. CompuServe, hosted by W3C, "Graphics Interchange Format, version 89a": https://www.w3.org/Graphics/GIF/spec-gif89a.txt (checked 11 October 2026)
5. MDN Web Docs, "Autoplay guide for media and Web Audio APIs": https://developer.mozilla.org/en-US/docs/Web/Media/Guides/Autoplay (checked 11 October 2026)
6. MDN Web Docs, "The video embed element": https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/video (checked 11 October 2026)
7. GitHub Docs, "Attaching files": https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/attaching-files (checked 11 October 2026)
8. GitHub Docs, "About the repository README file": https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-readmes (checked 11 October 2026)
9. X Developer Platform, "Media best practices": https://docs.x.com/x-api/media/quickstart/best-practices (checked 11 October 2026)
10. Microsoft Support, "Video and audio file formats supported in PowerPoint": https://support.microsoft.com/en-us/office/video-and-audio-file-formats-supported-in-powerpoint-d8b12450-26db-4c7b-a5c1-593d3418fb59 (checked 11 October 2026)
11. Microsoft Support, "Add an animated GIF to a slide": https://support.microsoft.com/en-us/office/add-an-animated-gif-to-a-slide-3a04f755-25a9-42c4-8cc1-1da4148aef01 (checked 11 October 2026)
12. Microsoft Support, "The animated graphic in my e-mail message does not work": https://support.microsoft.com/en-US/Outlook/the-animated-graphic-in-my-e-mail-message-doesn-t-work (checked 11 October 2026)
13. Slack Help Center, "Add files to Slack": https://slack.com/help/articles/201330736-Add-files-to-Slack (checked 11 October 2026)
14. Apple Support, "How to record the screen on your Mac": https://support.apple.com/en-us/102618 (checked 11 October 2026)
15. Apple Support, "Record the screen on your iPhone or iPad": https://support.apple.com/en-us/102653 (checked 11 October 2026)
16. Microsoft Support, "Use Snipping Tool to capture screenshots": https://support.microsoft.com/en-us/windows/use-snipping-tool-to-capture-screenshots-00246869-1843-655f-f220-97299b865f6b (checked 11 October 2026)
17. Google Android Help, "Take a screenshot or record your screen on your Android device": https://support.google.com/android/answer/9075928 (checked 11 October 2026)
18. FFmpeg, "FFmpeg filters documentation: palettegen and paletteuse": https://ffmpeg.org/ffmpeg-filters.html (checked 11 October 2026)
19. Can I use, "WebM video format: browser support": https://caniuse.com/webm (checked 11 October 2026)

## Go deeper

- [Record a scrolling video of a website](https://curlshot.com/tools/website-scrolling-video)
- [Scrolling videos: every option](https://curlshot.com/docs/video)
- [Record long videos in the background](https://curlshot.com/docs/async-and-webhooks)
- [Device presets for vertical videos](https://curlshot.com/docs/devices)

## Read next

- [PNG, JPEG, WebP or PDF for website screenshots](https://curlshot.com/blog/png-jpeg-webp-pdf-for-screenshots.md): A decision flow, a comparison table and our own file-size measurements for choosing PNG, JPEG, WebP or PDF when you save a screenshot of a web page.
- [Full-page screenshot on every device and browser](https://curlshot.com/blog/full-page-screenshot-every-device.md): Exact keys and menu names to screenshot a whole web page in Chrome, Firefox, Edge, Safari, iPhone, iPad and Android, checked against each vendor.
- [Social preview image sizes: the OG cheat sheet](https://curlshot.com/blog/social-preview-image-sizes.md): Open Graph image sizes for Facebook, LinkedIn, WhatsApp, iMessage, Discord, Slack and Google Discover, drawn to scale, with the tags and the fixes.