MP4 to GIF: Best Settings for a Small, Clean File

TL;DR

GIFs come out enormous because the format has no video-style compression — it uses only simple per-frame (LZW) compression and none of the inter-frame motion compression video formats have, so a clip that's a few MB as an MP4 can be 10–20× bigger as a GIF.
Four settings control GIF size, in order of impact: duration, frame rate, width, and colour count. Trim hard, drop the frame rate, cap the width, and reduce colours, and a huge GIF becomes a small one.
Sensible defaults for chat and docs: 5–10 seconds, 12–15 fps, 480–640 px wide, 128 colours, Bayer dithering. That's usually a 1–4 MB GIF that still looks clean.
Colour quality is a separate problem from size — it depends on the palette and dithering. A tool that uses a two-pass palette (generate an optimal palette, then apply it) avoids the muddy banding most converters produce. The Clipy MP4-to-GIF converter does this by default, free and with no watermark.
If your "GIF" is really just a short video, you'll get a far smaller, sharper file by keeping it an MP4 — see when not to use a GIF below.

Why GIFs balloon in size

The frustrating part of making a GIF is that you start with a small, crisp MP4 and end up with a file several times larger that somehow looks worse. That's not your fault — it's the format. GIF is from 1987, and it has two limitations that define everything about working with it.

First, no video-style inter-frame compression. Modern video formats like H.264 (MP4) are smart: they store one full frame, then for every frame after that they only record what changed. A talking head against a static background compresses beautifully because most of the picture is identical frame to frame. GIF doesn't do that kind of motion compression — it applies only simple lossless (LZW) compression to each frame, so file size still scales heavily with how many frames there are, which is why duration and frame rate matter so much.

Second, a 256-colour limit. Each GIF frame can use at most 256 colours from a palette. A real video has millions. Squeezing a full-colour clip into 256 colours is where GIFs get their muddy, banded look — unless the conversion is done carefully (more on palettes below).

Put those together and you get the core trade-off: a GIF's size is driven by frame count, and its quality is driven by the palette. Once you understand that, keeping a GIF small and clean is just a matter of turning the right knobs.

The four settings that actually control file size

In rough order of how much they move the needle:

1. Duration — trim ruthlessly

This is the biggest lever because it directly sets the frame count. A 30-second GIF is three times the size of a 10-second one, all else equal. Most GIFs that need to be shared — a bug repro, a UI interaction, a reaction clip — only need 3–10 seconds. Before touching anything else, trim to the exact moment that matters. If you find yourself wanting 30+ seconds, that's a sign you want a video, not a GIF.

2. Frame rate — drop it to 12–15 fps

Source video is usually 30 or 60 fps. A GIF almost never needs that. For screen recordings and UI demos, 12–15 fps looks perfectly smooth and roughly halves the frame count versus 30 fps. Even 10 fps is fine for slow interactions. The only time you want higher is fast motion where choppiness is obvious — and even then, a video is the better format.

3. Width — cap it at 480–640 px

Almost nobody views a GIF at full HD. In Slack, Discord, X, and GitHub, GIFs render small. Capping the width at 640 px (or 480 px for chat) shrinks the file dramatically because every frame has fewer pixels to store, and it still looks sharp at the size people actually see it. Keep the aspect ratio so it isn't squashed.

4. Colour count — drop from 256 to 128 or 64

If the GIF is still too big after the first three, reduce the palette. Many clips — especially screen recordings with flat UI colours — look almost identical at 128 or even 64 colours, and the file gets smaller because there's less palette data per frame. Photographic or gradient-heavy footage needs more colours; flat UI footage needs fewer. This is the lever to reach for last, after duration, frame rate, and width. In the Clipy tool the palette is generated automatically, so in practice your direct levers are duration, frame rate, and width.

A practical recipe for a screen recording: 5–10 seconds, 15 fps, 640 px wide, 128 colours. That typically lands around 1–4 MB — small enough for Slack, GitHub, and docs, and still crisp.

Palette and dithering — why your GIFs look bad (and how to fix it)

Size is one problem; ugly colour is the other, and it's separate. The muddy, banded look most GIFs have comes from how the converter picks and applies those 256 colours.

Many lightweight converters use a single fixed palette for the whole clip, which throws away colours your footage actually needs. The right way is a two-pass palette: first scan the clip to generate an optimal palette for that specific video (palettegen), then apply it with dithering (paletteuse). Dithering scatters the limited colours in a pattern that tricks the eye into seeing smoother gradients — Bayer dithering is the standard for clean, professional-looking GIFs.

This is exactly the pipeline the Clipy MP4-to-GIF converter runs by default — native server-side ffmpeg doing palettegen then paletteuse with Bayer dithering — which is why its output doesn't have the washed-out banding you get from many browser-based tools. (Some browser-based converters run ffmpeg compiled to WebAssembly, which is single-threaded and struggles with the two-pass palette path, so they skip it and the colour suffers.)

Best-settings cheat sheet by where it's going

Tune to the destination:

Slack / Discord: 480–640 px, 12–15 fps, 5–10 s, 128 colours. Keep it under a few MB so it autoplays smoothly inline.
GitHub issues / PRs / README: 640 px, 12–15 fps, short. GitHub has upload size limits, and a tight bug-repro GIF embeds and loads fast for reviewers.
X (Twitter): 480–600 px, 10–15 fps. X converts GIFs to video on its end anyway, so don't over-invest in size, but small still uploads faster.
Docs / Notion / knowledge base: 640 px, 12 fps. Loops are great for showing a repeatable UI action; keep them short so the page stays light.
A landing page or marketing site: honestly, use a muted autoplaying MP4 instead of a GIF — it's smaller and sharper. See the next section.

How to convert an MP4 to a small GIF, free

You don't need an app for this. Open the Clipy MP4-to-GIF converter, drop in your file (one MP4, MOV, or WebM, up to 500 MB — it also works on screen recordings, phone clips, and downloaded Loom videos), and set the controls that matter:

Trim to the exact start time and duration (up to 120 seconds) — the single biggest size win.
Set the frame rate and width using the recipe above (for example, 15 fps and 640 px).
Convert. The palette and dithering are handled automatically — a two-pass palettegen/paletteuse with Bayer dithering — so you get clean colour without tuning it by hand.

The conversion runs as native server-side ffmpeg (your file uploads over a presigned link to the nearest storage region, gets processed, and the finished GIF is delivered through a CDN and auto-deleted within 24 hours), so it doesn't choke on big files the way browser tools do — a typical 10-second 720p clip clears in a handful of seconds. It's free, no signup, and adds no watermark.

When NOT to use a GIF (use a video instead)

Half of "my GIF is huge" problems are really "this shouldn't be a GIF." GIF earns its place for short, silent, auto-looping clips embedded where a video player is awkward — chat, issues, inline docs. Outside that, a video wins on every axis: smaller file, sharper image, real colour, sound, and a seek bar.

Reach for a video (MP4) instead of a GIF when:

The clip is longer than ~15 seconds. GIF size grows linearly; a 60-second GIF can be tens of MB while the MP4 is a fraction of that.
You need audio, full colour, or HD sharpness.
It's going on a website or landing page — a muted autoplaying MP4 looks like a GIF to the viewer but is far lighter.

If you already made a heavy GIF and want it back as a compact video, the GIF-to-MP4 converter turns it into an H.264 MP4 that's typically a small fraction of the GIF's size — useful for exactly the landing-page and X cases above. And if the file you have is a long video you only want a slice of, trimming it first (or compressing it with a video compressor) beats forcing the whole thing into GIF.

Common mistakes that make GIFs huge

Leaving the frame rate at 30/60 fps. The single most common cause of a bloated GIF. Drop to 12–15.
Exporting at full resolution. A 1920 px GIF is pointless when it renders at 400 px in Slack. Cap the width.
Not trimming. People convert a whole 40-second recording when only 6 seconds matter.
Forcing 256 colours on flat UI footage. Screen recordings often look identical at 128 or 64 colours.
Using a GIF for something with audio or fine detail. That's a video; keep it one.

A worked example: from ~45 MB to a few MB

To make the knobs concrete, here's a typical screen recording and what each change does. Say you record a 20-second UI walkthrough at 1080p and 30 fps and convert the whole thing at full resolution with 256 colours. You'll get something in the neighbourhood of 40–50 MB — far too big for Slack or a GitHub comment, and it'll stutter as it loads.

Now apply the recipe, one knob at a time:

Trim 20 s → 8 s (only the part that matters): a big cut straight away, because you reduce the frame count by more than half.
Drop 30 fps → 15 fps: about half the remaining frames, so roughly half the size again.
Cap width 1080 px → 640 px: each frame has far fewer pixels — another big cut.

Stack those and, for a flat UI recording, the same clip can drop from 40–50 MB to roughly 2–6 MB — while still looking clean at the size people view it. (Photo-heavy or fast-motion footage will land higher.) In the Clipy tool you control the first three directly — duration, frame rate, and width — and the palette is optimised automatically. The order matters: always trim first, because every later setting operates on fewer frames.

GIFs for bug reports and dev workflows

The single most common professional use of MP4-to-GIF is the engineering bug report. A GIF in a GitHub issue or pull request shows a reviewer exactly what happens — the broken state, the misaligned element, the race condition — in a way a screenshot or a wall of text never can, and it autoplays inline without anyone clicking out to a video.

For that use, small and fast beats pretty. Record the repro (a screen recorder or even a phone clip of a device works), trim to the few seconds that show the bug, convert at 12–15 fps and 640 px, and drop it straight into the issue. Reviewers see it the moment the page loads. GitHub enforces an upload size limit on attachments, so the size discipline above isn't optional there — a 40 MB GIF simply won't attach, while a 2 MB one drops in cleanly. If your repro is genuinely long or needs audio narration, post a video link instead and keep the GIF for the money moment.

The same pattern works for design review (show a hover/transition), support replies (show the fix in two steps), and changelogs (a five-second loop of the new feature). In every case the workflow is: capture → trim hard → 12–15 fps, 640 px → embed.

Cropping and framing for the destination

Size isn't the only thing that changes by platform — shape does too. A full-screen recording is 16:9, but that's not always what you want embedded. The MP4-to-GIF tool keeps your source framing, so to change the shape, crop the video first with the crop-video tool and then convert. Done that way, cropping both fits the destination and trims size (fewer pixels per frame):

Center-crop to square (1:1) for a tidy inline chat or feed clip where the action is in the middle of the screen.
Crop to 9:16 (vertical) if the GIF is destined for a mobile-first context.
Keep source 16:9 for desktop UI demos and GitHub, where the wide frame shows context.
Tightly crop to just the relevant UI region — often the best move for a bug repro, because it both shrinks the file and focuses the reviewer's eye on the one element that matters.

Cropping to the part that matters is underrated: a GIF of one button misbehaving is smaller, clearer, and more useful than a GIF of your whole screen.

Where your clips come from

MP4-to-GIF works on anything you can get into an MP4, MOV, or WebM. Screen recordings are the obvious one — Clipy's own screen recorder captures a tab, window, or full screen and gives you a file to GIF. Phone clips work. And if the clip you want to turn into a GIF lives in a Loom, you can pull the MP4 first with the Loom downloader and then convert it — a common path for turning a recorded walkthrough into a short, embeddable loop.

FAQ

Why is my GIF so much bigger than the original MP4? Because GIF uses only simple per-frame (LZW) compression and has no video-style inter-frame compression, while MP4 only records what changes between frames. A 30-second 1080p MP4 of a few MB can become tens of MB as a GIF. Lower the frame rate, width, and duration to bring it down.

What frame rate should a GIF be? For screen recordings and UI demos, 12–15 fps looks smooth and roughly halves the size versus 30 fps. Use 10 fps for slow content; only go higher for fast motion (and consider a video instead).

What's the best width for a GIF? 480–640 px for chat, issues, and docs — that's how big they actually render, and it cuts file size sharply versus full HD while still looking crisp.

How do I make a GIF look less grainy or banded? Use a converter that runs a two-pass palette (palettegen then paletteuse) with Bayer dithering rather than a single fixed palette. The Clipy converter does this by default.

Is there a free MP4-to-GIF converter with no watermark? Yes — the Clipy MP4-to-GIF tool is free, adds no watermark, requires no signup, runs native server-side ffmpeg, and handles a single file up to 500 MB.

Should I use a GIF or a video? Use a GIF for short, silent, auto-looping clips in chat, GitHub, and inline docs. For anything longer than ~15 seconds, anything with audio, or anything on a webpage, use a video — it's smaller and sharper. You can convert an oversized GIF back with the GIF-to-MP4 converter.

The short version: a GIF's size is frame count, and its quality is the palette. Trim hard, drop to 12–15 fps, cap the width around 640 px, and let a two-pass-palette tool handle the colour. Drop your clip into the MP4-to-GIF converter, dial in those settings, and you'll get a small, clean GIF instead of a 40 MB mess.