How to Capture Screenshots From an MPEG-TS Video Stream

Use FFmpeg and limit video output to one frame. For a frame around 30 seconds in a local transport-stream file, run:

ffmpeg -ss 00:00:30 -i input.ts -frames:v 1 screenshot.jpg

Replace input.ts with a UDP or other stream URL when the source is on the network. Use input-side -ss for speed, output-side -ss when frame placement matters more than startup time, and omit -ss on a live feed when you want the first decodable frame.

What you need

• FFmpeg, including its ffmpeg and ffprobe commands, installed and available on your PATH.
• Read access to the MPEG-TS file or stream URL.
• Write permission in the directory where the still image will be saved.

An MPEG transport stream can contain several programs, video PIDs, discontinuous timestamps, and long GOPs. FFmpeg normally chooses a video stream automatically, but inspecting the input first avoids capturing the wrong program.

ffprobe -show_programs -show_streams input.ts

For a network source, quote the URL so shell characters are not interpreted:

ffprobe -show_programs -show_streams 'udp://HOST:PORT'

Capture one frame at a timestamp

Local .ts file

This command seeks near 30 seconds, decodes as needed, and writes exactly one JPEG:

ffmpeg -ss 00:00:30 -i input.ts -frames:v 1 screenshot.jpg

-frames:v 1 stops after one video frame. The output suffix selects the image format: .jpg creates a compressed JPEG, while .png preserves the decoded pixels without JPEG compression.

UDP or another network URL

ffmpeg -ss 00:00:30 -i 'udp://HOST:PORT' -frames:v 1 screenshot.jpg

The timestamp is meaningful only when the source and protocol provide seekable or usable timestamps. A live UDP sender generally cannot be rewound; in that case FFmpeg must receive packets from the point at which it joins the stream.

First available frame from a live feed

ffmpeg -i 'udp://HOST:PORT' -frames:v 1 live-shot.jpg

This waits until FFmpeg detects and decodes a video frame, then exits. A live source has no natural end, so always retain the process exit status and use an external timeout or supervisor if a stalled sender could otherwise leave the command running indefinitely.

Choose between fast and precise seeking

Input-side -ss: fast startup

Placed before -i, -ss seeks to the closest seek point before the requested position. With transcoding and accurate seeking enabled, FFmpeg decodes the intervening segment and discards it, so the emitted image can be close to the requested timestamp without decoding the entire file.

ffmpeg -ss 00:00:30 -i input.ts -frames:v 1 fast.jpg

This is usually the practical choice for thumbnails from a well-indexed file.

Output-side -ss: safer placement

Placed after the input, FFmpeg decodes from the beginning (or selected seek point) and discards frames until the target position. It can take longer, but is generally safer when an exact frame location matters:

ffmpeg -i input.ts -ss 00:00:30 -frames:v 1 exact.jpg

For a difficult or poorly indexed transport stream, combine output-side seeking with an explicit video mapping:

ffmpeg -i input.ts -map 0:v:0 -ss 00:00:30 -frames:v 1 exact-video.jpg

Do not expect exact random access from a non-seekable live URL. For those sources, join the feed, wait for a decodable frame, and capture relative to the packets you actually receive.

Select the correct program and video stream

Digital TV and contribution streams can carry multiple programs. First inspect the program and stream indexes:

ffprobe -show_programs -show_streams input.ts

Then map the desired video stream explicitly. The first video stream in the selected input is represented by 0:v:0:

ffmpeg -i input.ts -map 0:v:0 -frames:v 1 selected.jpg

If the desired video belongs to a particular program, use the stream information reported by ffprobe to choose its corresponding video stream. Explicit mapping also prevents an unrelated video PID from being selected when the container has several candidates.

Control format, dimensions and interlacing

PNG, JPEG and WebP

Choose the extension that matches your use case:

Output	Typical reason	Example
PNG	Lossless stills, diagrams or pixel inspection	frame.png
JPEG	Smaller photographic thumbnails	frame.jpg
WebP	Compact web delivery when supported by your consumer	frame.webp

Resize during capture

Add a video filter when a full-resolution frame is unnecessary. A height of -1 keeps the aspect ratio:

ffmpeg -ss 00:00:30 -i input.ts -frames:v 1 -vf 'scale=1280:-1' -q:v 2 screenshot.jpg

For JPEG output, lower quality-number values generally request higher quality. Test the setting against your storage and delivery requirements rather than assuming one value is ideal for every source.

Interlaced video

An interlaced source can show comb-like motion lines in a still. Deinterlace only when those artifacts are visible, because the filter changes the pixels:

ffmpeg -i input.ts -frames:v 1 -vf 'yadif' deinterlaced.png

For a sequence of deinterlaced thumbnails, combine filters such as yadif,fps=1.

Capture screenshots continuously

One image per second

ffmpeg -i input.ts -vf 'fps=1' shots-%04d.jpg

FFmpeg writes files such as shots-0001.jpg. The image2 muxer creates one image per frame and expands the numbered filename pattern.

One image every five seconds

ffmpeg -i input.ts -vf 'fps=1/5' shots-%04d.jpg

Limit a finite run by duration:

ffmpeg -i input.ts -t 00:01:00 -vf 'fps=1' shots-%04d.jpg

Or limit it to a known number of output frames:

ffmpeg -i input.ts -frames:v 60 -vf 'fps=1' shots-%04d.jpg

If filenames must reflect presentation timestamps instead of simple sequence numbers, use the image2 muxer’s frame_pts option and a filename pattern supported by that muxer. Timestamp-based names are useful when a downstream process must correlate an image with stream time.

Send a screenshot to another program

Use the image2pipe muxer when the consumer expects an image on standard output rather than a file pattern:

ffmpeg -i input.ts -frames:v 1 -f image2pipe -vcodec png pipe:1 > screenshot.png

In automation, capture both standard output and standard error, check FFmpeg’s exit status, and treat a nonzero status as a failed capture. A successful process does not necessarily mean the requested wall-clock moment existed in a live source; log the input URL, selected stream, seek position and output path so failures can be reproduced.

Troubleshoot common failures

“No such file or directory” or an unreadable URL

Check the path, shell quoting and permissions. For URLs containing &, question marks or brackets, quote the entire URL. Run ffprobe against the same input to separate input-access problems from image-writing problems.

FFmpeg exits without an image

The input may contain no decodable video, may have ended before the requested timestamp, or may be a live source that has not delivered a complete frame. Remove -ss for a live first-frame test, wait for packets, and verify that ffprobe -show_streams reports a video stream.

The wrong channel or camera appears

Map the intended stream explicitly with -map 0:v:0 or the video stream index identified by ffprobe. Multi-program transport streams often contain several video PIDs.

The frame is near, but not exactly at, the timestamp

Move -ss after -i and allow FFmpeg to decode and discard intervening frames. Long GOPs and missing indexes can still make seeking slower or less predictable.

The command hangs on a live URL

Live streams do not provide a finite duration. Add a short capture window such as -t 00:00:10, enforce a process-level timeout, and make your supervisor terminate and retry stalled jobs. Keep stderr because it records network, demuxer and decoder diagnostics.

The still has combing or motion artifacts

The source is likely interlaced. Apply -vf 'yadif' before writing the image, and do not deinterlace automatically if the source is progressive.

The output is unexpectedly large or soft

Use PNG only when lossless pixels are required. For JPEG, set a quality option such as -q:v 2 and resize with scale when the display does not need the source resolution. Compare representative frames, because fine text and fast motion respond differently to compression.

Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

Performance and reliability choices

• Latency: input-side seeking is normally faster on files; output-side seeking trades startup time for more dependable placement.
• Decode cost: one frame still requires decoding from a usable seek point through the target frame. Long GOPs increase that work.
• Network behavior: UDP may lose packets and has no rewind operation. A capture service should retry, record diagnostics, and distinguish “no frame arrived” from “image encoding failed.”
• Storage: periodic capture can create many files quickly. Choose an interval, output dimensions and retention policy together.
• Stream selection: explicit -map makes jobs deterministic when a transport stream changes its program layout.
• Validation: verify that the output file exists and has a nonzero size before publishing it. For critical workflows, decode the produced image or inspect its dimensions as a second check.

Or skip the browser setup

If your MPEG-TS feed is displayed by a public web page and you need a screenshot of that page rather than a decoded raw transport-stream frame, ScreenshotNeo provides a website screenshot API. It is not a replacement for FFmpeg’s MPEG-TS decoder; use the FFmpeg commands above for direct file or UDP capture.

A single GET request returns a PNG, JPEG, WebP or PDF. The API documentation is at https://screenshotneo.com/docs/.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com/player -o shot.webp

Python

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://example.com/player"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com/player' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Before capture, ScreenshotNeo accepts the cookie or consent banner like a visitor and removes more than 60 known consent platforms, newsletter popups and chat widgets; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed as clean shots, and response headers report the page verdict and billing status. Its MCP server gives Claude, Cursor and other MCP clients take_screenshot, get_page_info and capture_pdf tools.

The Free plan includes 1,000 shots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is included on every plan, and yearly billing gives two months free. Create a free ScreenshotNeo account.

Frequently Asked Questions

Can I capture a frame from an encrypted MPEG-TS feed?

Only if FFmpeg receives a stream it can legally and technically decrypt. The commands here assume the input is available as a decodable MPEG-TS source; encryption and key acquisition are outside this workflow.

Does a still-image command include the stream’s audio?

No. The -frames:v 1 option limits video output to one image; audio is not written to a JPEG, PNG or WebP file.

Why does a live capture sometimes show a later frame than expected?

A live UDP input can only use packets that arrive after FFmpeg joins. Network jitter, decoder startup and the next available keyframe determine which decodable frame is first.

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.