Convert Videos for YouTube Shorts

YouTube Shorts has strict technical specs, but the bigger challenge is aspect ratio: most content is recorded in landscape (16:9) or square (1:1) and needs to be adapted for vertical (9:16) display. This guide covers the exact specs, how to handle the landscape-to-vertical conversion, and the encoding settings that avoid YouTube's re-compression quality loss.

YouTube Shorts: exact specifications

Per YouTube's Shorts creation guide:

• Aspect ratio: 9:16 (vertical). Landscape or square videos are accepted but won't be promoted as Shorts — they'll appear as regular videos.
• Resolution: 1080 × 1920 px recommended. Minimum 720 × 1280 px (YouTube upscales).
• Max duration: 60 seconds (videos over 60s are uploaded as regular videos, not Shorts).
• Max file size: 100MB per the mobile app; 128GB via desktop upload. Keep under 500MB for practical upload speed.
• Container: MP4 (recommended), MOV, AVI, WebM, or MKV. MP4 has the lowest re-processing risk.
• Video codec: H.264 (AVC). YouTube also accepts H.265/HEVC and VP9 but transcodes everything to VP9/AV1 for delivery anyway.
• Frame rate: 24, 25, 30, 48, 50, or 60 fps. Variable frame rate (VFR) causes audio sync issues — always use constant frame rate (CFR).
• Audio codec: AAC-LC, 128–384 kbps, 44.1 kHz or 48 kHz. Stereo. Mono is accepted but stereo is recommended.
• Color space: BT.709 (standard for web/TV). HDR (BT.2020) is supported on supported devices.

Recommended source-to-target pairs

Conversion commands (curl + Python)

Convert a landscape MP4 to vertical MP4 for YouTube Shorts:

# curl — convert to MP4 (vertical Shorts-ready)
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key_here" \
  -F "file=@landscape-clip.mp4" \
  -F "target=mp4" \
  -o shorts-ready.mp4

import requests
from pathlib import Path

API_KEY = "ctf_sk_your_key_here"

def convert_for_shorts(in_path: str, out_path: str) -> None:
    with open(in_path, "rb") as f:
        resp = requests.post(
            "https://changethisfile.com/v1/convert",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": f},
            data={"target": "mp4"},
            timeout=300,
        )
    resp.raise_for_status()
    Path(out_path).write_bytes(resp.content)
    size_mb = len(resp.content) / (1024 * 1024)
    print(f"Saved {out_path} ({size_mb:.1f} MB)")

convert_for_shorts("landscape-clip.avi", "shorts-ready.mp4")

For precise vertical crop control, FFmpeg gives you more options than a general converter:

# FFmpeg: crop 16:9 landscape to 9:16 vertical (center crop)
ffmpeg -i input-landscape.mp4 \
  -vf "crop=ih*9/16:ih:(iw-ih*9/16)/2:0,scale=1080:1920" \
  -c:v libx264 -crf 23 -preset fast \
  -c:a aac -b:a 128k -ar 48000 \
  -r 30 -vsync cfr \
  output-shorts.mp4

# FFmpeg: blur-pad landscape to 9:16 (keeps full width, blurs sides)
ffmpeg -i input-landscape.mp4 \
  -filter_complex \
    "[0:v]scale=1080:-1,boxblur=20:5[bg]; \
     [0:v]scale=-1:1920[fg]; \
     [bg][fg]overlay=(W-w)/2:(H-h)/2" \
  -c:v libx264 -crf 23 -preset fast \
  -c:a aac -b:a 128k \
  output-shorts-blurred.mp4

Batch script: convert video folder to Shorts format

#!/usr/bin/env bash
# Usage: ./convert_shorts_batch.sh ./raw-clips ./shorts-ready

API_KEY="ctf_sk_your_key_here"
INPUT_DIR="${1:-.}"
OUTPUT_DIR="${2:-./shorts-ready}"

mkdir -p "$OUTPUT_DIR"
success=0; failed=0

for vid in "$INPUT_DIR"/*.{mp4,mov,avi,mkv,wmv,webm,MP4,MOV}; do
  [ -f "$vid" ] || continue
  base=$(basename "$vid" | sed 's/\.[^.]*$//')
  out="$OUTPUT_DIR/${base}.mp4"

  printf "%-55s" "$(basename $vid) → ${base}.mp4 "
  code=$(curl -s -o "$out" -w "%{http_code}" \
    -X POST https://changethisfile.com/v1/convert \
    -H "Authorization: Bearer $API_KEY" \
    -F "file=@$vid" \
    -F "target=mp4")

  if [ "$code" = "200" ]; then
    mb=$(du -m "$out" | cut -f1)
    echo "OK (${mb}MB)"
    ((success++))
  else
    echo "FAILED (HTTP $code)"
    ((failed++))
  fi
done

echo ""
echo "$success converted, $failed failed. Output: $OUTPUT_DIR"

Common gotchas for YouTube Shorts

• Variable frame rate (VFR) causes audio sync drift. iPhone recordings and screen captures often use VFR. YouTube's encoder handles it but sync issues appear at 20–30 seconds. Always re-encode to CFR: ffmpeg -i input.mp4 -vsync cfr output.mp4.
• Over 60 seconds = not a Short. Even one extra second means YouTube classifies the video as a regular upload. It won't appear in Shorts feed or recommendations. Trim precisely to ≤60 seconds.
• HEVC/H.265 from iPhones gets heavily re-encoded. iPhone 12+ records in HEVC by default. YouTube accepts it but re-encodes to VP9/AV1, sometimes aggressively. Transcoding to H.264 yourself first gives you more control over quality.
• Aspect ratio without 9:16 = not promoted as a Short. YouTube uses aspect ratio detection to classify Shorts. If your video is 1:1 or 16:9, it will upload fine but won't be surfaced in the Shorts tab or Shorts recommendations.
• Audio loudness. YouTube normalizes audio to -14 LUFS. Content recorded much louder gets turned down; content recorded quietly sounds muddy when normalized. Aim for -14 to -12 LUFS integrated loudness before upload.

Shorts thumbnail: auto-selected frame

YouTube Shorts thumbnails are auto-selected from a frame in the video — you can't upload a custom thumbnail for Shorts (as of 2025). This means your opening frame matters. Ensure the first frame (or first 3 seconds) contains a compelling visual, since that's what YouTube uses for the thumbnail in recommendations. Put text overlays or hooks in the first 2 seconds, not just the content itself.

For Shorts, the two hardest constraints are 9:16 ratio and ≤60 seconds. Nail those and encoding is straightforward. For casual conversions, the API handles most formats cleanly. For landscape-to-vertical reframing, FFmpeg's crop and blur-pad filters give precise control. Free tier covers 1,000 conversions/month.