Amazon Product Video Requirements: Pass Review With One Encode

Your listing video matches every number Amazon publishes, and it still came back rejected with a message that doesn't say why. The spec sheet is the easy part. The three things that actually bounce a product video never show up in a spec table, and all three live in the encode.

Quick answer: The Amazon product video requirements are an MP4 or MOV file with H.264 video, a minimum of 1920x1080 at 16:9, a constant frame rate of 23.976 or 30 fps, AAC audio at 96 kbps or higher, and a file under 500 MB running roughly 6 to 45 seconds. From a phone capture, one FFmpeg pass gets you there: ffmpeg -i input.mov -vf "fps=30,scale=1920:1080,format=yuv420p" -fps_mode cfr -c:v libx264 -crf 20 -c:a aac -b:a 128k -movflags +faststart out.mp4. If you'd rather not run an encoder, babysit a render box, or rebuild the same command for every SKU, send the file to FFmpeg Micro as one API call and get the Amazon-safe cut back.

What Amazon actually requires for a listing video

Amazon's uploader checks a short list of container and stream properties before a human ever looks at the video. These are the numbers to encode against.

Every agency page you'll find when you search for this reprints that table and stops. The table isn't what fails. A 30-second 1080p clip at CRF 20 lands around 40 to 70 MB, so nobody trips the 500 MB cap by accident. What trips people up is a variable frame rate from a phone, a watermark baked in by a free export tier, and an intro card that hides the product for the first five seconds. Those three account for most of the bounces, and FFmpeg fixes all three.

Variable frame rate is the rejection nobody diagnoses

A phone records at a variable frame rate to save power in low light, so a clip that reports "30 fps" can actually carry frames spaced anywhere from 1/60 to 1/24 of a second apart. Amazon's ingest wants a constant rate, and a VFR file can pass a casual spec check while still failing on submission. Check it before you encode anything:

ffprobe -v error -select_streams v:0 \
  -show_entries stream=codec_name,width,height,r_frame_rate,avg_frame_rate \
  -of default=noprint_wrappers=1 input.mov

If r_frame_rate reads something like 600/1 while avg_frame_rate reads 2997/100, the file is variable. For a definitive answer, count how many distinct frame durations exist:

ffprobe -v error -select_streams v:0 -show_entries frame=duration_time \
  -of csv=p=0 input.mov | sort | uniq -c | sort -rn | head -5

One line of output means constant. Five means variable. On FFmpeg builds older than 7.0 the field is pkt_duration_time instead, and the command silently returns nothing if you use the wrong name.

The normalize pass pins the rate, fits the frame to 1080p without distorting it, and pads to 16:9 in white so the bars match the product detail page background:

ffmpeg -i input.mov \
  -vf "fps=30,scale=1920:1080:force_original_aspect_ratio=decrease,\
pad=1920:1080:(ow-iw)/2:(oh-ih)/2:color=white,format=yuv420p" \
  -fps_mode cfr -r 30 \
  -c:v libx264 -profile:v high -level 4.0 -preset medium -crf 20 \
  -c:a aac -b:a 128k -ar 48000 -ac 2 \
  -movflags +faststart \
  amazon-ready.mp4

The fps=30 filter and -fps_mode cfr do different jobs and you want both. The filter duplicates or drops frames to build an even timeline; the mode flag tells the muxer to write constant timestamps. On FFmpeg 4.x, -fps_mode doesn't exist and you use -vsync cfr.

Third-party branding is the free-tier watermark you stopped noticing

Amazon rejects listing videos that show branding other than your own, and the most common source isn't a competitor logo, it's the corner watermark a free video tool stamped on your export. The same rule catches other retailers' logos, price badges, and URLs in the footage.

The honest fix is re-exporting from the original project without the watermark. When the source is gone and all you have is the stamped MP4, delogo interpolates the region from surrounding pixels:

ffmpeg -i watermarked.mp4 \
  -vf "delogo=x=1496:y=962:w=400:h=96" \
  -c:v libx264 -preset medium -crf 20 -c:a copy clean.mp4

Be realistic about what that buys you. delogo works well over flat backgrounds like a white sweep or a plain wall, and smears visibly over texture, motion, or the product itself. If the watermark sits in a solid band along the bottom, crop it away and scale back up instead, which keeps 16:9 intact by taking a slightly tighter window:

ffmpeg -i watermarked.mp4 \
  -vf "crop=1778:1000:71:0,scale=1920:1080:flags=lanczos,format=yuv420p" \
  -c:v libx264 -preset medium -crf 20 -c:a copy clean.mp4

Your own logo is allowed, so once the foreign mark is gone you can stamp the brand back on with a single overlay:

ffmpeg -i clean.mp4 -i brand.png -filter_complex \
  "[1:v]scale=220:-1[wm];[0:v][wm]overlay=W-w-48:H-h-48" \
  -c:v libx264 -crf 20 -c:a copy branded.mp4

The first five seconds have to show the product

A logo card, an animated brand sting, or a black fade at the head of the video is a common reason a listing video gets sent back, because Amazon wants the product visible almost immediately. Shoppers on a product page have already decided what they're looking at, and the intro you'd use on YouTube works against you here.

Find where the card ends with scene detection rather than scrubbing:

ffprobe -v error -f lavfi -i "movie=input.mp4,select=gt(scene\,0.4)" \
  -show_entries frame=pts_time -of csv=p=0

The first timestamp is usually the cut from the card to the first real shot. Trim from there and cap the duration:

ffmpeg -ss 4.5 -i input.mp4 -t 22 \
  -c:v libx264 -preset medium -crf 20 -pix_fmt yuv420p \
  -c:a aac -b:a 128k -movflags +faststart trimmed.mp4

Putting -ss before -i makes FFmpeg seek the input, which is fast and, because this pass re-encodes, frame-accurate. Add -c copy to that command and the seek snaps back to the nearest keyframe, which can leave two seconds of the logo card you just tried to remove.

The one pass that does all three

Running three separate encodes generation-losses the footage and burns time, so chain the filters into a single pass and encode once. The delogo coordinates refer to the source frame, so it has to come before any scale or pad:

ffmpeg -ss 4.5 -i input.mov -t 30 \
  -vf "delogo=x=1496:y=962:w=400:h=96,fps=30,\
scale=1920:1080:force_original_aspect_ratio=decrease,\
pad=1920:1080:(ow-iw)/2:(oh-ih)/2:color=white,format=yuv420p" \
  -fps_mode cfr -r 30 \
  -c:v libx264 -profile:v high -level 4.0 -preset medium -crf 20 \
  -c:a aac -b:a 128k -ar 48000 -ac 2 \
  -movflags +faststart amazon-ready.mp4

That command is fine for one SKU. At forty SKUs, with a different watermark position and a different intro length in each, it turns into a scripting job with an FFmpeg install and a machine to run it on. The Listing Kit blueprint is the automated version of exactly what this post teaches: upload the raw clip and it returns the Amazon-safe 16:9 cut along with 9:16 for TikTok and Reels, 1:1, and 4:5, all normalized to constant frame rate in one pass, with no encoder to host. Most sellers need those other three anyway, and cutting them from the same master keeps the product framing consistent across every channel.

Pitfalls that pass ffprobe and still fail review

Most of these show up only after submission, which is why they're worth checking in the encode rather than after the fact.

If you want to confirm the re-encode didn't visibly degrade the product shot, a VMAF score against the original is a faster check than eyeballing it.

When the encode isn't the problem

Encoding can't fix claims. If the rejection references performance claims, medical language, pricing, competitor comparisons, or contact information shown on screen, that's a content review decision and no filter chain touches it. Re-shoot or re-edit the offending segment.

Encoding also isn't an editor. If the video needs a scripted voiceover, animated callouts, or a designed template per product, you want a template-based motion graphics tool or an editor for that step, then normalize the export with the pass above before upload. FFmpeg Micro and FFmpeg itself both sit at the encode stage, not the creative one.

FAQ

What video format does Amazon accept for product listings?

Amazon accepts MP4 and MOV files with H.264 video and AAC audio for product listing videos. MP4 with -movflags +faststart is the safer of the two, because MOV files from editing tools often carry ProRes or extra data tracks that the uploader refuses.

What is the maximum file size for an Amazon listing video?

Amazon's listing video upload caps at 500 MB. A 45-second 1080p30 clip encoded with libx264 at CRF 20 typically lands between 60 and 100 MB, so hitting the cap usually means the file is an uncompressed or intermediate export rather than a delivery encode.

Why did Amazon reject my product video when it matched the specs?

Amazon most often rejects spec-compliant videos for variable frame rate, third-party branding such as a free-tier export watermark, or an opening that doesn't show the product within the first few seconds. All three pass a basic resolution and file-size check and all three are fixable in a single FFmpeg pass.

Can I use the same video for my Amazon listing and for TikTok?

You can use the same source footage, but not the same file. Amazon requires 16:9 at 1920x1080, while TikTok and Reels want 1080x1920 vertical, so cut both from one master rather than re-encoding the Amazon file into a vertical crop. The TikTok spec details and the reframing approach differ enough to matter.

Does Amazon allow watermarks on listing videos?

Amazon allows your own brand logo on a listing video and rejects third-party branding, including watermarks added by free video tools, other retailers' logos, and URLs. Remove the foreign mark with delogo or a crop, then overlay your own with the overlay filter.

You can run every command above locally with FFmpeg installed, or sign up free and send the raw clip through as one API call to get the Amazon-safe cut and the social variants back without a render box in the loop.