What this guide is really about
Threads treats video as a first-class format: you can attach a clip from the app, upload from the browser, or publish through the API with the same container-plus-publish pattern that handles text and images. The catch is the spec. Upload the wrong container, run past five minutes, or exceed one gigabyte, and the post stalls or fails outright. This guide covers every publishing path, the exact limits Meta documents, and the fix for each common failure.
Meta's Threads API documentation, updated October 30, 2026, supplies the video specifications below. App and web controls vary by version, so check the options your own composer offers.
Open the Threads composer, attach a video, add a caption, and post. Meta's API specifications allow MP4 or MOV video up to 300 seconds and 1 GB, with H.264 or HEVC video, AAC audio, and a maximum width of 1920 pixels. If an upload fails, re-encode to those settings and retry; for API publishing, create a VIDEO container, allow about 30 seconds for processing, then publish when it is ready.
Threads videos cap at 5 minutes, 1 GB, and 1920 pixels wide, in an MP4 or MOV container.
Three paths publish video: the app picker, the web composer, and the API's container-then-publish flow.
A failed upload is usually a spec mismatch: unsupported container, wrong codec, or a duration, size, or width past the documented caps.
A single ffmpeg re-encode to a compliant MP4 fixes most rejected files; duration, size, and width still need a separate check.
YouTube links become the link preview card when they are the first URL in the post text.
Threads video limits: the numbers that matter
The Threads API media specifications pin down the hard caps. Videos can run up to 300 seconds, which is five minutes, and must be longer than zero. Files top out at 1 GB. The container must be MOV or MP4 with the moov atom at the front and no edit lists, the video encoded as HEVC or H.264 in progressive scan with closed GOPs and 4:2:0 chroma subsampling, and the audio as AAC at up to a 48 kHz sample rate in one or two channels.
Resolution rules are width-first: the widest allowed video is 1920 pixels, frame rates must land between 23 and 60 FPS, and aspect ratios can stretch from 0.01:1 to 10:1, although Meta recommends 9:16 vertical to avoid cropping or blank space. Square 1:1 and landscape 16:9 both fall inside the allowed range, but vertical fills the most screen on a phone-first feed. Video bitrate tops out at 100 Mbps variable and audio at 128 kbps. These caps are documented for API uploads, and they make the safest target envelope for any publishing path.
Two edge cases trip people up later. Carousels can mix photos and videos, from 2 to 20 items, and a carousel counts as a single post against the API's 250-published-posts-per-24-hours ceiling. GIFs are the opposite case: the API attaches them to text-only posts, so a video post can never carry one.
Post a video from the Threads app
In the mobile app, start a new post as usual. Tap the attachment control in the composer, choose the video from your camera roll, and trim the clip if the picker offers it. The five-minute ceiling applies before upload, so a longer video has to be cut in your gallery app or an editor first. Add the caption, check the preview, and post.
Meta recommends 9:16 vertical to avoid cropping or blank space, so export that way and preview the clip before posting rather than assuming the player will letterbox it politely. Keep the file under 1 GB, because long 4K exports cross that line fast. If the composer rejects the file outright, work through the failure-to-fix mapping further down this page.
After the post is live you have a 15-minute edit window for the text, and how you break up that text changes whether people actually watch the clip. Take a minute to format Threads posts for readability before you hit publish. If the video itself is the problem, delete and repost rather than hoping the editor covers it.

Post a video from the web
On threads.net, open the composer, use its attachment control, and select the video file from your computer. Treat Meta's documented limits as your export target here too, and check the file against them before uploading. The browser is the natural path for exports that live on a desktop anyway: files cut in Premiere, DaVinci Resolve, or a ffmpeg pipeline are usually sitting in a folder, not a camera roll.
Captions still count against the Threads character limit, so the 500-character ceiling applies to video posts exactly as it does to text. Put the hook in the first line so the opening survives any truncation, and keep the rest short enough that the video stays the main event.
Uploading AVI, MKV, or WebM files when only MP4 and MOV are accepted.
Posting 16:9 landscape footage and accepting letterboxing instead of exporting 9:16.
Letting screen recordings keep variable frame rates outside the 23 to 60 FPS window.
Retrying a 1.2 GB export unchanged instead of compressing it below the cap.
Burying the YouTube link mid-caption, so a different URL wins the preview slot.
Publish video through the Threads API
API publishing follows the official Threads API documentation: a two-step flow. First you create a media container with media_type set to VIDEO and a video_url pointing at a publicly reachable file on your server. Threads pulls the file from that URL, so a localhost address or a signed link that expires mid-processing will fail. Then you publish the container and receive the media ID.
Timing matters here. Meta recommends waiting on average 30 seconds between creating a VIDEO container and publishing it, because the video is still processing on their side; the wait is a rule of thumb, not a guarantee. Poll the media container status endpoint and publish once processing reports finished. Profiles are limited to 250 published posts per rolling 24 hours, and a carousel with up to 20 items still counts as one post.
For the full operator walkthrough, including rate limits and the exact request shapes, read our operator's guide to Threads API publishing on this blog. The video workflow there is the same container-then-publish pattern, with VIDEO as the media type and the processing wait built in.

Share a YouTube video without uploading
You cannot push a YouTube video into Threads as a native upload, and you do not need to. Paste the YouTube link into the post text and Threads uses the first URL in that text as the link preview. That card is what followers see and tap, and playback happens over on YouTube.
Choose between the two deliberately. Upload the file when you want the clip to live natively in the feed and stand on its own. Link out when the YouTube view count matters to you, or when the video runs far past the five-minute ceiling, since a 40-minute stream can only join Threads as a link. That covers most music videos, podcast episodes, and tutorials in full: if it cannot be trimmed to five minutes, the link is the format.
If you are still deciding whether video is the right format at all, read When to use images, video, and carousels on Threads for the strategy layer: which jobs each format wins, and the trade-offs between them for a text-first audience.
Why uploads fail and the exact fix
Most failed uploads come down to a spec mismatch, though the app rarely tells you which limit you hit. The Threads API media specifications are the map: a file that will not attach at all is usually an unsupported container, since AVI, MKV, and WebM are not on the documented MP4 and MOV list. A file that attaches but never finishes processing usually points to the encode itself, with PCM or otherwise non-AAC audio being the frequent offender; the spec wants AAC at up to a 48 kHz sample rate.
Duration and size are the blunt ones: trim or split anything past 5 minutes, and compress anything past 1 GB. Edited files can also carry edit lists and a moov atom at the back of the file, both of which the spec excludes, so re-export with the faststart flag. Screen recordings are the classic silent killer, because they often use variable frame rates outside the documented 23 to 60 FPS window, and a conform pass fixes them.
One re-encode command covers the encode side. Running ffmpeg -i input.mov -c:v libx264 -pix_fmt yuv420p -c:a aac -b:a 128k -ar 48000 -movflags +faststart output.mp4 produces H.264 video in 4:2:0 with 128 kbps AAC audio at 48 kHz and the moov atom in front, matching the documented spec. It does not enforce the 300-second duration, the 1 GB size, the 23 to 60 FPS range, the 1920-pixel width, or the 100 Mbps bitrate ceiling, so check those on the output file before uploading; if the source is wider than allowed, add -vf scale=1920:-2.
Check whether your video posts actually work
A posted video is a hypothesis. You picked vertical, kept it under five minutes, wrote a first-line hook, and now you want to know whether it moved anything. The two numbers that matter early are impressions and replies, because they show whether the clip earned attention or just a slot in the feed.
Pull each post's numbers from your Threads Insights, paste them into our engagement rate calculator, and compare the result across your last ten posts instead of against someone else's benchmark. A single video's number means little on its own; a trend across ten tells you whether video deserves a bigger share of your calendar.
Action checklist
Use this as the practical next pass after reading the guide.
- +Confirm the clip runs 5 minutes or less.
- +Check the container is MP4 or MOV with H.264 or HEVC video and AAC audio.
- +Keep width at 1920 pixels or less and prefer 9:16 vertical.
- +Compress anything over 1 GB before uploading.
- +Put the hook in the caption's first line and break long text into short paragraphs.
- +After a week, compare replies and impressions across your video posts before committing to a format mix.

Conclusion
Posting video on Threads is easy when the file fits the spec and painful when it does not. Keep clips at or under five minutes, at or under one gigabyte, at or under 1920 pixels wide, in MP4 or MOV with H.264 or HEVC video and AAC audio, and you remove the most common failure causes on every publishing path.
When an upload fails, do not retry the same file. Match the failure to its cause, re-encode once, and get back to the part that actually grows an account: measuring what people watched and making the next one better.



