Loom to GIF: The Complete Guide (2026)

Loom has become the go-to tool for async video communication — quick walkthroughs, bug reports, onboarding clips, and product demos. But there's a common frustration: when you want to drop a Loom moment into a Notion doc, GitHub issue, Slack message, or email, a Loom link requires the reader to click away and watch. A GIF, on the other hand, plays inline — no click, no load, no friction.

This guide covers every method to convert a Loom recording into a GIF: from the fastest one-click approach to the most flexible command-line workflow. Whether you're a product manager creating documentation, a developer filing bug reports, or a designer sharing UI feedback, you'll find the right method here.

Why Convert Loom to GIF?

The tradeoff: GIFs are silent, limited to ~256 colors, and get large quickly. For clips over 15 seconds or content that relies on audio explanation, a Loom link is still better. For 3–10 second visual highlights, GIF wins every time.

Method 1: Online Converter (Fastest)

The quickest path: download your Loom video, then convert it to GIF in your browser — no software to install.

Step 1: Download Your Loom Video

1. Open your Loom recording in the browser
2. Click the "..." (more options) menu in the top-right corner
3. Select "Download" → choose MP4 format
4. Wait for the download to complete (file saves to your Downloads folder)

Tip: If you don't see a Download option, check your workspace settings. Some Loom teams restrict downloads — you may need to adjust permissions in your workspace admin panel.

Step 2: Convert to GIF

1. Go to VideoToGifConverter.net
2. Click Upload Video and select your downloaded Loom MP4
3. Set your desired clip range using the start/end time controls
4. Choose output settings:
   • Width: 640px (good balance of quality and file size)
   • FPS: 10–15 fps (Loom recordings are typically 24–30 fps; 12 fps is enough for most UI walkthroughs)
   • Quality: Medium
5. Click Convert — your GIF downloads automatically

Recommended settings by use case:

Method 2: Trim in Loom First, Then Convert

If you only need a specific moment from a longer Loom recording, trim it in Loom before downloading. This saves time and reduces file size.

Trimming in Loom

1. Open your recording in Loom
2. Click Edit in the left sidebar
3. Use the Trim tool to select your start and end points
4. Click Save — Loom creates a trimmed version
5. Download the trimmed MP4

Why This Matters for GIF Conversion

A 60-second Loom recording converted directly to GIF at 640px/12fps will exceed 20 MB — too large for GitHub (10 MB limit) and Slack (free tier: 1 MB). Trimming to 5–10 seconds in Loom first keeps your GIF manageable.

GIF file size estimation formula:

Approx size (MB) ≈ (width × height × fps × duration) / 5,000,000

For a 640×360 GIF at 12 fps for 8 seconds:

(640 × 360 × 12 × 8) / 5,000,000 ≈ 4.4 MB

Method 3: FFmpeg (Maximum Control)

For developers who need precise control over quality, frame rate, and palette optimization, FFmpeg produces the smallest, sharpest GIFs.

Install FFmpeg

macOS (Homebrew):

brew install ffmpeg

Windows (Chocolatey):

choco install ffmpeg

Ubuntu/Debian:

sudo apt install ffmpeg

Basic Loom to GIF Conversion

ffmpeg -i loom-recording.mp4 \
  -vf "fps=12,scale=640:-1:flags=lanczos" \
  -loop 0 \
  output.gif

Parameters explained:

• fps=12 — 12 frames per second (smooth enough for UI walkthroughs)
• scale=640:-1 — 640px wide, height calculated automatically to preserve aspect ratio
• flags=lanczos — high-quality downscaling algorithm
• -loop 0 — infinite loop

Optimized Two-Pass Conversion (Best Quality)

The two-pass method generates a custom color palette for each video, resulting in noticeably sharper GIFs with smaller file sizes:

# Pass 1: Generate optimal color palette
ffmpeg -i loom-recording.mp4 \
  -vf "fps=12,scale=640:-1:flags=lanczos,palettegen=stats_mode=diff" \
  palette.png

# Pass 2: Convert using the generated palette
ffmpeg -i loom-recording.mp4 -i palette.png \
  -filter_complex "fps=12,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle" \
  -loop 0 \
  output.gif

This two-pass approach typically produces GIFs 30–50% smaller than single-pass conversion with equal or better visual quality.

Converting a Specific Time Range

# Convert only the first 8 seconds starting at 0:15
ffmpeg -i loom-recording.mp4 \
  -ss 00:00:15 -t 8 \
  -vf "fps=12,scale=640:-1:flags=lanczos" \
  -loop 0 \
  output.gif

Loom-Specific Conversion Tips

Handle Loom's Variable Resolution

Loom adjusts recording resolution based on your connection. Downloaded Loom MP4s may be anything from 360p to 4K. Always check the source resolution before converting:

ffprobe -v quiet -print_format json -show_streams loom-recording.mp4 | python3 -c "
import json, sys
s = json.load(sys.stdin)['streams'][0]
print(f\"Resolution: {s['width']}x{s['height']}, Duration: {s.get('duration','?')}s\")
"

If your Loom is 1080p or higher, scale down aggressively for GIF — there's no visual benefit in a 1080p GIF for documentation use cases.

Remove the Loom Watermark Area

Loom recordings sometimes include a webcam bubble in the corner. If you want to exclude it, crop the video during conversion:

# Crop to remove bottom-right webcam bubble area (adjust values to fit your recording)
ffmpeg -i loom-recording.mp4 \
  -vf "crop=in_w:in_h-80:0:0,fps=12,scale=640:-1:flags=lanczos" \
  -loop 0 \
  output.gif

Loom Screen Share vs. Webcam-Only Recordings

Loom offers three recording modes:

• Screen + Cam — standard screen recording with webcam bubble
• Screen only — clean screen recording, best for GIF conversion
• Cam only — webcam recording only

For GIF conversion, Screen only mode produces cleaner results. If you're converting an existing Screen + Cam recording, consider cropping out the webcam bubble (see above).

Platform-Specific Optimization

GitHub Issues and Pull Requests

GitHub has a 10 MB attachment limit for images in issues. GIFs larger than this simply won't upload.

# Optimized for GitHub: 640px, 10fps, palette optimization
ffmpeg -i loom.mp4 -ss 0 -t 10 \
  -vf "fps=10,scale=640:-1:flags=lanczos,palettegen" palette.png && \
ffmpeg -i loom.mp4 -i palette.png \
  -ss 0 -t 10 \
  -filter_complex "fps=10,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse" \
  -loop 0 github-demo.gif

If the GIF still exceeds 10 MB after optimization, reduce to 480px width or cut the duration further.

Slack

Slack Nitro users get unlimited file size, but free workspaces cap uploads at 1 MB. For Slack-friendly GIFs:

ffmpeg -i loom.mp4 -ss 0 -t 5 \
  -vf "fps=8,scale=480:-1:flags=lanczos" \
  -loop 0 slack-gif.gif

Alternatively, use Slack's native GIF button to link a hosted GIF rather than uploading directly.

Notion

Notion embeds GIFs from direct URLs or file uploads. Notion works well with larger GIFs (up to 5 MB displays well). For Notion documentation:

ffmpeg -i loom.mp4 \
  -vf "fps=15,scale=800:-1:flags=lanczos" \
  -loop 0 notion-walkthrough.gif

Email

Most email clients render GIFs, but file size directly affects load time. Keep email GIFs under 1 MB when possible:

ffmpeg -i loom.mp4 -ss 0 -t 4 \
  -vf "fps=8,scale=400:-1:flags=lanczos" \
  -loop 0 email-preview.gif

Further Compression with gifsicle

After conversion, gifsicle can reduce GIF file size by an additional 20–40% through frame optimization:

Install:

brew install gifsicle  # macOS
apt install gifsicle   # Ubuntu

Optimize an existing GIF:

gifsicle -O3 --lossy=80 input.gif -o output-optimized.gif

--lossy=80 applies lossy compression (0 = lossless, 200 = maximum compression). Values between 60–100 produce a good balance of quality and size reduction.

Troubleshooting Common Issues

"GIF file is too large"

1. Reduce duration — aim for under 8 seconds
2. Reduce width — 480px is usually sufficient
3. Reduce FPS — 8–10 fps is barely noticeable for UI walkthroughs
4. Run through gifsicle with --lossy=80
5. Use the two-pass FFmpeg method

"GIF looks blurry or pixelated"

This usually means the source video was already low-resolution. Check your Loom recording quality:

• Go to Loom Settings → Quality → set to High (1080p)
• Re-record if needed

For existing recordings, the two-pass palette generation method helps maximize quality from lower-resolution sources.

"Loom won't let me download the video"

• Check workspace settings: Settings → Workspace → Video Privacy → Allow Downloads
• Contact your Loom workspace admin
• As an alternative, use a screen recorder to capture the Loom playback in real time

"Colors look washed out in the GIF"

GIF's 256-color limit causes color banding. Mitigations:

1. Use the two-pass palette generation (biggest improvement)
2. Add dithering: paletteuse=dither=floyd_steinberg
3. Reduce the color range in your recording (avoid gradients and photos)

Batch Converting Multiple Loom Recordings

If you regularly create documentation from Loom recordings, a shell script automates the process:

#!/bin/bash
# batch_loom_to_gif.sh — Convert all MP4s in current folder to GIFs

for f in *.mp4; do
  name="${f%.mp4}"
  echo "Converting: $f"

  # Generate palette
  ffmpeg -i "$f" \
    -vf "fps=12,scale=640:-1:flags=lanczos,palettegen=stats_mode=diff" \
    "${name}_palette.png" -y 2>/dev/null

  # Convert to GIF
  ffmpeg -i "$f" -i "${name}_palette.png" \
    -filter_complex "fps=12,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=5" \
    -loop 0 "${name}.gif" -y 2>/dev/null

  # Cleanup palette
  rm "${name}_palette.png"
  echo "Done: ${name}.gif ($(du -sh "${name}.gif" | cut -f1))"
done

Save as batch_loom_to_gif.sh, make executable (chmod +x batch_loom_to_gif.sh), and run it in any folder containing Loom MP4 downloads.

Quick Reference

Conclusion

The fastest Loom-to-GIF workflow for most people: Download MP4 from Loom → VideoToGifConverter.net → embed anywhere. It takes under 2 minutes and requires no software.

For developers integrating GIF creation into documentation workflows, the FFmpeg two-pass method consistently produces the smallest, sharpest GIFs — worth the one-time setup investment.

The key constraint to keep in mind: GIF is inherently limited to 256 colors and no audio. For technical walkthroughs where the spoken explanation matters, keep the Loom link. For visual proof-of-concepts, UI feedback, and quick demos, GIF is the format that removes all friction between your recording and your audience.

Ready to convert your Loom recordings? Upload your MP4 at VideoToGifConverter.net — no sign-up, no installation, instant results.