How to convert MP4 to GIF on Mac (Discord-ready, offline, 2026)

You have a screen recording of a bug, a clip of your app doing the new thing, or three perfect seconds out of a two-minute video — and you need it as a GIF. Not because GIF is a good format (it isn’t; it’s from 1989), but because of what a GIF does that a video file doesn’t: it plays by itself. In a Discord channel, a GitHub issue, a Notion doc, a Slack thread, or a pull-request description, a GIF loops silently inline while an attached MP4 sits behind a play button nobody clicks.

So the job is real: convert MP4 to GIF on a Mac, at a file size the destination will actually autoplay. This guide covers the free command-line route and the drag-and-drop route, both running entirely on your Mac — plus the sizing rules that decide whether your GIF loops inline or lands as a dead attachment.

First, make sure a GIF is actually the right output

A GIF is a downgrade from video in every technical sense: it’s limited to 256 colors per frame, it has no audio, and it compresses each frame as a full image with none of the motion tricks H.264 uses. The same clip as a GIF is routinely five to twenty times larger than the MP4 it came from, and looks worse.

You accept all of that for exactly one feature — autoplay — so check that the destination doesn’t give you autoplay some cheaper way:

• Twitter/X, Bluesky, iMessage, WhatsApp autoplay short videos inline. Send the MP4; it’ll look better and weigh less. If the video is just too big, that’s a compression job, not a GIF job — see compressing video for email and chat on Mac.
• Discord, Slack, GitHub, Notion, Linear, most wikis and READMEs do not autoplay uploaded video. Here the GIF earns its bloat: it loops the moment it scrolls into view.

If your clip needs sound, GIF is disqualified entirely — there is no such thing as a GIF with audio. And if what you actually want from the video is only the sound, that’s the opposite conversion: extract the audio to MP3.

The three numbers that decide everything

Every MP4-to-GIF conversion is a negotiation between three values. Get them wrong and you produce a 40 MB monster no platform will inline.

1. Duration. The single biggest lever. GIFs are for moments — two to six seconds. Nobody has ever wanted a 45-second GIF, and no platform autoplays one.
2. Frame rate. Video runs at 24–60 fps; GIFs read fine at 10–15 fps. Halving the frame rate roughly halves the file.
3. Dimensions. A 480-pixel-wide GIF is chat-sized. Full-resolution 4K screen recordings converted as-is are how 100 MB GIFs happen.

Keep those three in your head and both methods below become easy to steer.

Method 1: ffmpeg (free, command line)

macOS ships nothing that converts video to GIF — QuickTime and Photos can’t do it — so the free route is ffmpeg:

brew install ffmpeg

The naive command (ffmpeg -i in.mp4 out.gif) produces ugly, banded GIFs, because GIF’s 256-color limit needs a palette chosen for your footage. The proper command generates that palette and applies it in one pass:

ffmpeg -ss 4 -t 3 -i input.mp4 \
  -vf "fps=12,scale=480:-1:flags=lanczos,split[a][b];[a]palettegen[p];[b][p]paletteuse" \
  -loop 0 output.gif

Reading the flags against the three numbers above: -ss 4 -t 3 trims to a 3-second moment starting at 0:04, fps=12 drops the frame rate, and scale=480:-1 resizes to 480 px wide (height follows automatically). The palettegen/paletteuse pair is the quality trick — it builds a custom 256-color palette from your actual frames, which is the difference between a smooth GIF and a posterized one. -loop 0 means loop forever.

There’s no target-size mode, though. If the result comes out at 2.8 MB and the destination wants under 256 KB, you re-run with a shorter -t, a lower fps, a smaller scale — and check the file size again. Repeat until it fits. It’s free and it works; it’s also five or six trial runs the first time, every time the footage changes.

Method 2: Zumkor (trim, pick the destination, done)

If GIFs are a recurring part of your week — bug reports, PR demos, docs, a changelog with receipts — the iterate-by-hand loop is the part worth deleting. Zumkor approaches it from the destination instead (it needs macOS 14 or later on an Apple silicon Mac — any M-series machine):

1. Drag the MP4 in — or the MOV, MKV, WebM, AVI, or whatever the recorder produced; Zumkor reads them all.
2. Trim to the moment. Open the clip’s trim view and drag the QuickTime-style yellow handles around the seconds you want. Only the kept range is converted — the other 57 seconds of the recording never touch the GIF.
3. Pick GIF as the output and choose the preset named for where the file is going:
   • “Best quality” — when it’s headed somewhere without a size limit and you want it to look as good as GIF gets.
   • “Chat & bug reports (10 MB)” — the general-purpose chat size.
   • “Notion (5 MB)” — under Notion’s upload comfort zone.
   • “Discord — plays by itself (256 KB)” — squeezes under the line where Discord loops the GIF automatically instead of hiding it behind a click.
4. Click Convert. The GIF lands in your chosen output folder; the original video stays untouched.

That’s the whole interface: no fps field, no width field, no palette settings. Each preset embodies the duration/frame-rate/dimensions trade-off for its destination, so “make it autoplay on Discord” is one pick instead of six ffmpeg re-runs. Everything runs on-device and offline — a screen recording of your unreleased app never leaves the machine, which is not something a gif-maker website can say.

It’s free for 7 days, then a one-time $19.99 purchase — no subscription — and the same app handles the rest of the media pile: WebM downloads that won’t play, MOV to MP4 handoffs, audio extraction, images, the lot. The honest trade-off: for a one-off GIF, ffmpeg is free once Homebrew is installed. Zumkor earns its price the third time you’d otherwise be bisecting frame rates to hit a size cap.

One more lever for the automation-minded: Zumkor ships a Shortcuts action titled “Make a GIF from a Video”, so a folder-watch automation can turn every recording you drop in a folder into a chat-ready GIF in the background, headless.

Screen recordings work exactly the same way

The most common GIF source on a Mac isn’t an MP4 at all — it’s the .mov file that ⌘⇧5 screen recording produces. Nothing changes: ffmpeg takes -i recording.mov the same way, and Zumkor reads MOV natively, so it’s the same drag, trim, preset, convert.

Two screen-recording-specific tips:

• Record small or resize hard. A full-screen Retina recording is enormous (a 5K frame per frame). Either drag a smaller ⌘⇧5 capture region around just the window that matters, or rely on the resize — chat-destination presets and scale=480:-1 both bring it down.
• UI motion is GIF-friendly. Flat colors and static regions compress well even in GIF, which is why terminal recordings and app demos make decent small GIFs while camera footage of a beach does not. If your GIF of filmed video looks grainy, that’s the 256-color wall, not a settings mistake.

Batching a backlog of clips

GIF jobs rarely arrive alone. A docs refresh means a folder of feature demos; a support wiki means a season of repro recordings; a marketing site means every product moment as a loop. The ffmpeg answer is a shell script around the palette command — workable, but you’re managing trims per file, and a script has no trim handles.

Zumkor treats a folder of videos exactly like a single one: drag the whole directory in (its queue takes up to 2,000 files), pick the GIF preset once, and every clip converts in the same pass, on-device, with the results landing together in your chosen output folder and the source recordings untouched. Conversions keep running with the window closed, so a big batch doesn’t hold your afternoon hostage. Clips that need trimming first can be trimmed individually before the batch runs — and clips headed to different destinations (this one to Discord, that one to Notion) are just two small queues instead of one.

Getting the conversion right

• Trim before anything else. Duration dominates file size. Cutting a 30-second clip to the 4 seconds that matter does more than every other setting combined.
• Target the platform, not “high quality.” A GIF that misses the autoplay threshold has failed at its only job, however sharp it looks. Land under the cap first; spend whatever size budget is left on quality.
• Loop-ability is an editing decision. GIFs loop forever, so a clip whose last frame flows into its first reads as seamless motion. Trim so the action resets — cursor returns, animation completes — and the loop stops being jarring.
• Don’t round-trip. Converting a GIF back to video and out to GIF again stacks palette quantization on palette quantization. Keep the source video; regenerate from it when you need a different size.
• Check the result where it’s going. Drop the GIF in a private Discord channel or a draft issue before the real one. The preview costs ten seconds; a dead attachment in a bug report costs a re-do.

Bottom line

• Video-capable destination (iMessage, X, WhatsApp): don’t make a GIF — send the MP4, or compress it to the platform’s cap.
• One GIF, comfortable in Terminal: brew install ffmpeg, trim with -ss/-t, and use the palettegen/paletteuse filter above. Re-run until the size fits.
• GIFs as a habit — bug reports, demos, docs: Zumkor — drag the recording, trim with the yellow handles, pick “Discord — plays by itself (256 KB)” or “Notion (5 MB)”, convert. Offline, on-device, free for 7 days, then one-time $19.99.

Either way, skip the gif-maker websites: uploading a screen recording of your own product to someone else’s server, to be converted with someone else’s watermark, is strictly worse than a job your Mac finishes locally in seconds.

FAQ

How do I make a GIF from an MP4 that autoplays on Discord?

Discord only plays a GIF automatically — no click, no tap — when the file is tiny; bigger GIFs sit behind a play button like any video. Keep the clip to a couple of seconds and the file well under a megabyte. Zumkor has a preset named “Discord — plays by itself (256 KB)” that lands the file under that line for you; in ffmpeg you get there by trimming hard and lowering fps and resolution until the file is small enough.

Why is my GIF bigger than the MP4 it came from?

Because GIF is a 1989 format: it stores every frame as a full palette-limited image with none of the motion compression modern video codecs use. A few seconds of GIF can easily outweigh a minute of MP4. That’s normal — the fix is shorter clips, fewer frames per second, and smaller dimensions, not a “better” converter.

Can I convert just part of a video to a GIF on a Mac?

Yes, and you almost always should. In ffmpeg, -ss sets the start time and -t the duration, so only that range is converted. In Zumkor, open the clip’s trim view — QuickTime-style yellow handles — drag them around the moment you want, and only the kept range becomes the GIF.