How to convert video to GIF

Converting a video to a GIF sounds like a trivial one-click job. Most tools that do it produce garbage — muddy colors, enormous file sizes, or frame rates that feel like flipbooks made by a distracted teenager. The tools that produce good GIFs are all doing the same thing under the hood: trimming first, building a smart palette, and running the encoder with the right flags. This guide covers what’s happening when a video becomes a GIF, why FFmpeg is the engine behind almost every web converter, the two-pass palette trick that transforms output quality, dithering tradeoffs, the file-size targets that matter, and when you should reach for APNG or animated WebP instead of GIF entirely.

What’s actually happening

Video codecs (H.264, H.265, VP9, AV1) store frames as differences from previous frames — keyframes plus deltas. GIF stores every frame as an independent image. To convert, the decoder rebuilds each video frame in full color, then the GIF encoder picks a 256-color palette and reduces every pixel to the nearest palette color.

This has three big consequences: file size explodes (GIF has no inter-frame compression for most frames), quality drops (256 colors can’t represent smooth gradients), and encoding is slow (each frame is processed independently). Every decision in the conversion pipeline balances those three.

FFmpeg under the hood

FFmpeg is the open-source engine behind almost every video-to-GIF converter on the web. The naive one-liner produces bad output:

# Naive: single pass, generic palette, ugly result
ffmpeg -i input.mp4 -r 12 -s 640x360 output.gif

The problem is the palette. FFmpeg picks a generic 256-color palette, which doesn’t match the actual colors in your clip, so reds turn orange and skies turn purple. The fix is a two-pass palette generation.

The two-pass palette trick

# Pass 1: scan the video, build an optimal palette
ffmpeg -i input.mp4 -vf "fps=12,scale=640:-1:flags=lanczos,palettegen" palette.png

# Pass 2: encode the GIF using that custom palette
ffmpeg -i input.mp4 -i palette.png \
  -filter_complex "fps=12,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse" \
  output.gif

The first pass analyzes every frame in the video and picks the 256 colors that best represent the content. The second pass uses that palette for encoding. Result: dramatically better color fidelity with no file-size penalty. Every quality-focused GIF converter on the web does some version of this.

Trim before encoding

Always trim the source video to the exact segment you want before converting. A 10-second clip becomes a 3MB GIF; a 30-second clip becomes a 12MB GIF. Don’t encode extra footage and crop it later — the encode dominates the total time.

# Trim first, then convert
ffmpeg -ss 00:00:15 -to 00:00:23 -i input.mp4 -c copy trimmed.mp4
# Then run the two-pass palette on trimmed.mp4

Dithering: on or off

Dithering scatters color errors across neighboring pixels to simulate intermediate colors the palette doesn’t contain. FFmpeg’s default is Sierra3 dither, which looks like a fine-grained noise pattern.

Turn dithering on for photographic content, skin tones, skies, sunsets — anywhere smooth color gradation matters. Banding goes away, trades for a slight texture.

Turn dithering off (dither=none) for UI screencasts, flat logos, animations with large solid-color regions. Dithering adds visible noise to those and hurts compression. Use bayer dither for a retro, deliberately pixel-art look.

Frame rate tradeoff

GIF file size scales linearly with frame count. Dropping from 30fps to 15fps halves the size. For most content, 12–15fps is indistinguishable from 30fps to casual viewers — the brain interpolates motion. For slow, deliberate content (text fading in, a tooltip appearing), 8–10fps is enough.

Target file size

# Rough heuristics after the two-pass palette:
480x270 @ 12fps, 3 sec:   300-600 KB
640x360 @ 12fps, 3 sec:   500-900 KB
640x360 @ 15fps, 5 sec:   1.2-2.0 MB
720x405 @ 15fps, 4 sec:   1.5-2.5 MB
1080x608 @ 15fps, 5 sec:  3-5 MB (usually too big)

Ship GIFs under 2MB for blog posts, under 500KB for Slack. If you’re over, reduce dimensions first (biggest lever), then shorten duration, then lower frame rate.

Scaling and aspect ratio

Lanczos filtering (flags=lanczos) produces sharper downscaled output than the default bilinear. Always specify it. For aspect ratio, use scale=WIDTH:-1 or scale=-1:HEIGHT to let FFmpeg compute the other dimension proportionally. Making it -2 instead of -1 ensures the resulting dimension is divisible by 2, which some downstream tools require.

APNG and animated WebP alternatives

If your target platform supports them, both formats beat GIF decisively. WebP animated is typically 30–50% the size of equivalent GIF with full color and real alpha. Supported by all modern browsers and most chat platforms. Not supported by most email clients.

APNG is lossless-capable PNG with animation. Universal browser support, excellent for UI animations, but larger than animated WebP.

# Animated WebP (much smaller than GIF for same quality)
ffmpeg -i input.mp4 -vf "fps=15,scale=640:-2:flags=lanczos" \
  -loop 0 -q:v 80 output.webp

Default to animated WebP for web embeds. Export GIF only when you need email compatibility or you’re posting to a platform that strips unknown formats.

Quality at the edges

Sharp transitions between frames (cuts, fades, text appearing) are where GIFs look worst — the palette has to accommodate both states, which means less palette space for each. If a clip has a hard cut mid-loop, consider splitting it into two GIFs or holding a frame before the cut to give the palette breathing room.

Looping and frame hold

FFmpeg’s default loop is infinite. Specify -loop 0 to be explicit. For polished output, pad the last frame by 500–800ms (hold it before the loop restarts) — feels professional instead of yanked.

Common mistakes

Single-pass palette encoding. Generic palette makes colors look wrong. Always use the two-pass palettegen/paletteuse workflow.

Converting at full video resolution. 1080p GIFs are almost never what you want. Downscale to 480–720px.

Leaving unused footage at the head/tail. Every extra second balloons the file. Trim to the exact moment.

Dithering on flat UI screencasts. Adds noise, hurts compression, looks grimy. Turn it off for synthetic content.

Using GIF when WebP is supported. WebP is half the size with better color. Default to WebP unless your target platform doesn’t accept it.

Cranking frame rate past 20fps. Diminishing returns in perceived smoothness, linear cost in file size.

Converting 30-second clips to GIF. At any quality they’ll be 10MB+. Use muted autoplay video for anything over 6–8 seconds.

Run the numbers

Convert videos to looping GIFs with the video-to-GIF converter. Pair with the video trimmer to cut the source down to the exact segment worth looping, and the GIF maker when you’re assembling frames from scratch rather than converting existing footage.