A Beginner’s Guide to Using FFmpeg in Python for Video Processing

FFmpeg is an incredibly powerful tool for working with video and audio, but working with its command-line interface (CLI) for complex tasks can quickly become overwhelming. Handling filters, signal graphs, and complex video manipulations often results in long, hard-to-read command strings.

Using FFmpeg with Python makes these operations more structured, readable, and maintainable. Instead of chaining together confusing command-line arguments, Python provides a clearer and more intuitive way to construct and execute FFmpeg commands. This approach is especially useful for developers building video editing applications, automation tools, or content pipelines.

In this guide, we’ll cover how to use the ffmpeg-python library to handle common video processing tasks, from simple format conversions to adding overlays. If you’re looking for a more efficient way to work with FFmpeg, this tutorial will help you get started.

🐱 Meow Memo: The ffmpeg-python library is a wrapper around the FFmpeg command-line tool, allowing you to use FFmpeg's capabilities in Python.

What is FFmpeg

FFmpeg is a complete, cross-platform solution to record, convert, and stream audio and video. It can decode, encode, transcode, mux, demux, stream, filter, and play media files in any format. It is also highly portable—it compiles and runs in a wide variety of build environments, machine architectures, and configurations like Linux, Mac OS X, Microsoft Windows, etc.

FFmpeg contains multiple tools for end-users to convert, play, and analyze media files and libraries for developers to use in different applications. Libraries like libavcodec, libavutil, libavformat, libavfilter, libavdevice, libswscale, and libswresample will be downloaded automatically when you download FFmpeg to your machine.

Although FFmpeg is mainly a command-line tool, you can easily use it in Python or integrate it into your Python project with the ffmpeg-python library.

Installing FFmpeg-Python

Before installing the ffmpeg-python library, make sure you have these installed on your machine:

• Python
• pip (package manager)
• FFmpeg

🐱 Meow Memo: The ffmpeg-python library is simply a Python wrapper around the FFmpeg installed on your machine, so it doesn't function on its own. To use it in your Python project, you’ll need to have FFmpeg installed first.

Once you’ve installed them, open your terminal/command prompt and run the following command in your working directory to install ffmpeg-python in your Python project:

pip install ffmpeg-python

Then, create a Python file (e.g., index.py), import ffmpeg into your code, and use it to perform various operations on media files.

import ffmpeg

// use ffmpeg here to perform various operations here

We’ll look at some examples in the following section…

Video Processing Using FFmpeg-Python

Using the ffmpeg-python library typically involves specifying the input video file with the ffmpeg.input() function, defining the output file with the output() function, and then executing the command with the run() function.

Convert a Video Format

Here’s an example of converting an MP4 video to AVI format:

import ffmpeg

(
	ffmpeg.input("input.mp4")
	.output("output.avi")
	.run()
)

FFmpeg offers more flexibility than basic conversion. You can apply various filters to the input file after the input() function, as well as pass different parameters like ss, to, acodec, and others to both the input() and output() functions for more advanced control.

Extract Audio from a Video

Extracting audio from a video or converting an MP4 video to MP3 is straightforward. The process is similar to converting video formats, as shown earlier. Instead of specifying a video file extension for the output, simply use an audio extension like ".mp3". FFmpeg will automatically convert the video to MP3 using the default audio codec, libmp3lame.

Here’s an example of extracting the audio from a video file:

import ffmpeg

(
	ffmpeg.input("input.mp4")
	.output("audio.mp3")
	.run()
)

You can also use a different audio codec by specifying it in the acodec parameter of the output() function. For example, the code below uses the libshine encoder instead of the default one:

import ffmpeg

(
	ffmpeg.input("input.mp4")
	.output("audio.mp3", acodec="libshine")
	.run()
)

Trim a Video

Trimming a video is simple. All you need to do is add a few parameters in the input() function. In the input() function, set the start time using the ss parameter and the end time using the to parameter.

The example below cuts a specific part of a video from 00:00:10 to 00:00:20 and saves it as a new “output.mp4” video:

import ffmpeg

start_time = '00:00:10' # Start time for trimming (HH:MM:SS)
end_time = '00:00:20' # End time for trimming (HH:MM:SS)

(
	ffmpeg.input("input.mp4", ss=start_time, to=end_time)
	.output("trimmed_output.mp4")
	.run()
)

Extract a Frame from a Video

Another thing you can do by adding parameters to the input() function is to extract frames from the input video. To specify how many frames you want to extract, use the vframes parameter.

The example below extracts the first three frames from the input video:

import ffmpeg

(
	ffmpeg.input("input.mp4")
	.output("frame_%d.png", vframes=3)
	.run()
)

🐱 Meow Memo: The default frame rate is 25fps.

You can also use the fps filter to change the frame rate of the video. The code below will extract frames from the whole video (since vframes is not specified) at 1fps, instead of 25fps:

import ffmpeg 

(
	ffmpeg.input("input.mp4")
	.output("frame%d.png", vf="fps=1")
	.run()
)

For both methods, you can also use the ss parameter to specify the start time:

import ffmpeg

(
	ffmpeg.input("input.mp4", ss="00:00:15")
	.output("frame%d.png", vframes=3)
	.run()
)

This will extract the first three frames starting from 00:00:15:

Add a Watermark to a Video

To add a watermark to a video, you're essentially overlaying an image onto it. This can be done by using the overlay filter, where you specify the position of the watermark with (x, y) coordinates.

Here’s an example that places a watermark at the top-right corner of the video:

import ffmpeg

(
	ffmpeg.input("input.mp4")
	.filter("overlay", x=(main_w-overlay_w), y=0)
	.output("output.mp4")
	.run()
)

🐱 Meow Memo: If your image is too big or too small, you can use the scale2ref  filter to adjust the size of the image as needed.

Merge Videos

Merging multiple videos into one can be done using the concat filter. Here's an example of merging two videos into a single output file:

import ffmpeg

input1 = ffmpeg.input("input1.mp4")
input2 = ffmpeg.input("input2.mp4")
(
    ffmpeg
    .concat(input1, input2)
    .output("output.mp4")
    .run()
)

Exploring Alternatives to FFmpeg-Python

Using FFmpeg in Python offers great flexibility and readability, especially compared to working with the CLI. However, depending on your specific needs, there could be other libraries or tools that might suit you better.

Here are a few alternatives worth considering:

• GStreamer - A powerful multimedia framework that allows you to build custom pipelines for various media manipulation tasks. However, it may require more setup and configuration compared to FFmpeg.
• MoviePy - A Python library built on top of FFmpeg but provides a more user-friendly API. It is great for developers who are already working with Python.
• Clipcat - An API built for automated video generation, allowing you to create videos from templates with placeholders for text, logos, and video clips.

Conclusion

The ffmpeg-python library makes it easier to work with FFmpeg’s powerful video and audio processing features by adding structure and readability to your code. With Python, you can also create more maintainable workflows for tasks like format conversion, trimming, extracting frames, and adding watermarks. Whether you're developing a video editing app, automating content creation, or experimenting with multimedia projects, ffmpeg-python is a handy tool that can make your video processing tasks easier.

That said, if you're handling repetitive tasks like merging videos or adding watermarks automatically, you might find an API-based approach like Clipcat even more efficient. Clipcat simplifies video automation by letting you generate videos from templates with placeholders for text, images, and clips. This is ideal for tasks like creating personalized videos or batch-processing content at scale, without the hassle of handling complex FFmpeg commands.

🐱 Meow Memo: Clipcat is currently in development, but you can join the waiting list to get early access when it launches!