A ten-minute documentary video is a lot to ask of a social feed. A single strong thirty-second moment from it is not. The trick is picking the right moments and cutting them cleanly, and then repeating the process every week without it eating your evenings.
This post describes the workflow I'd use, with a script I wrote and tested to do the mechanical part. Then I'll look at what Pixasocial's Reel Factory says it automates, from its public pages. I haven't used it, so that part is a description and not a review.
Step 1: choose the moments yourself
Tools can suggest clips. Only you know which parts of the story stand up on their own. When I scan a script, I look for five kinds of moments:
The hook
A specific, true opening: a place, a date, a decision. Not "you won't believe what happened".
The decision
A moment where someone had to choose, with the stakes visible.
The visual
A map, a diagram or a photograph that can carry twenty seconds of narration.
The turning point
The line where the story changes direction.
The open question
An honest "what we don't know", which invites comments and sets up the full video.
Then the standalone test: if someone sees only this clip, does it make sense without the rest? If a clip needs the previous two minutes to be understood, move the start earlier or drop it. Write the start and end times into a CSV, one line per clip. Mine is five lines for a four-minute story.
Step 2: decide between fit and crop
A 16:9 frame doesn't fit a vertical screen. You have two options, and the choice matters for documentary footage:
- Crop takes the centre of the frame and fills the screen. It looks bold, but it throws away the left and right sides. For a map, a ship in a wide shot, or two people at a table, that can remove the subject.
- Fit keeps the whole frame, centred on a blurred, enlarged copy of itself. It shows everything and looks less dramatic. For archive footage and maps, this is the one I'd choose by default.
Don't decide for the whole video; decide per clip, and watch each one on a phone before posting.
Step 3: cut with a script you can trust
This Python script wraps ffmpeg. It reads a CSV of start and end times, converts the times, cuts each clip, and writes a 1080x1920 H.264 file with stereo AAC audio at 30 frames per second. It also fails loudly if an end time is before its start, which is the typo I make most.
reels.py
"""Cut a long video into 9:16 clips from a CSV of timestamps, using ffmpeg.
python reels.py talk.mp4 clips.csv out/ [--mode fit|crop]
fit = keep the whole 16:9 frame, centred on a blurred copy of itself (nothing is cut off)
crop = centre-crop to 9:16 (fills the screen, but loses the left and right of the frame)
"""
import argparse
import csv
import subprocess
from pathlib import Path
W, H = 1080, 1920
def to_seconds(ts):
"""'MM:SS', 'HH:MM:SS' or plain seconds -> float seconds."""
parts = [float(p) for p in str(ts).strip().split(":")]
secs = 0.0
for p in parts:
secs = secs * 60 + p
return secs
def read_clips(path):
clips = []
with open(path, newline="") as f:
for row in csv.DictReader(f):
start, end = to_seconds(row["start"]), to_seconds(row["end"])
if end <= start:
raise ValueError(f"{row['slug']}: end must be after start")
clips.append({"slug": row["slug"], "start": start, "dur": end - start})
return clips
def video_filter(mode):
if mode == "crop":
return f"crop=ih*9/16:ih,scale={W}:{H},setsar=1"
return (f"split[a][b];[a]scale={W}:{H}:force_original_aspect_ratio=increase,crop={W}:{H},boxblur=30:5[bg];"
f"[b]scale={W}:-2[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2,setsar=1")
def command(src, clip, out_dir, mode):
out = Path(out_dir) / f"{clip['slug']}.mp4"
return [
"ffmpeg", "-y", "-loglevel", "error",
"-ss", f"{clip['start']:.3f}", "-t", f"{clip['dur']:.3f}", "-i", str(src),
"-filter_complex" if mode == "fit" else "-vf", video_filter(mode),
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-r", "30", "-crf", "20",
"-c:a", "aac", "-b:a", "128k", "-ac", "2", "-movflags", "+faststart", str(out),
]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("src")
ap.add_argument("csv")
ap.add_argument("out")
ap.add_argument("--mode", choices=["fit", "crop"], default="fit")
a = ap.parse_args()
Path(a.out).mkdir(parents=True, exist_ok=True)
for clip in read_clips(a.csv):
subprocess.run(command(a.src, clip, a.out, a.mode), check=True)
print("wrote", clip["slug"], f"({clip['dur']:.0f}s)")
if __name__ == "__main__":
main()
And the CSV for my four-minute example:
clips.csv
start,end,slug
00:04,00:31,opening-hook
00:48,01:15,the-decision
01:40,02:05,what-the-map-shows
02:30,02:58,the-turning-point
03:20,03:50,what-we-dont-know
Does it work?
The tests make a four-minute 1920x1080 test pattern with a tone, so there's no real footage to worry about, then cut the first clip in both modes and ask ffprobe what came out. Each file must be 1080 by 1920 pixels, use the yuv420p pixel format, have two audio channels (in fit mode), and last within 0.2 seconds of the requested 27 seconds. The timestamp parser is tested too, including a backwards range. All five tests pass, though they take over a minute because generating the long source video is the slow part.
test_reels.py
import json
import shutil
import subprocess
import tempfile
import unittest
from pathlib import Path
from reels import to_seconds, read_clips, command
HERE = Path(__file__).parent
def probe(path):
out = subprocess.run(["ffprobe", "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)],
capture_output=True, text=True, check=True).stdout
return json.loads(out)
class Timestamps(unittest.TestCase):
def test_formats(self):
self.assertEqual(to_seconds("01:15"), 75)
self.assertEqual(to_seconds("1:02:03"), 3723)
self.assertEqual(to_seconds("12.5"), 12.5)
def test_rejects_backwards_range(self):
with tempfile.NamedTemporaryFile("w", suffix=".csv", delete=False) as f:
f.write("start,end,slug\n00:30,00:10,bad\n")
with self.assertRaises(ValueError):
read_clips(f.name)
def test_sample_csv(self):
clips = read_clips(HERE / "clips.csv")
self.assertEqual(len(clips), 5)
self.assertEqual(clips[0]["dur"], 27)
@unittest.skipUnless(shutil.which("ffmpeg"), "ffmpeg not installed")
class EndToEnd(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = Path(tempfile.mkdtemp())
cls.src = cls.tmp / "long.mp4"
# 4-minute 1920x1080 test pattern with a tone, so we need no real footage
subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-f", "lavfi", "-i", "testsrc2=size=1920x1080:rate=30",
"-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000", "-t", "240",
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", str(cls.src)], check=True)
def run_mode(self, mode):
out = self.tmp / mode
out.mkdir()
clip = read_clips(HERE / "clips.csv")[0]
subprocess.run(command(self.src, clip, out, mode), check=True)
info = probe(out / f"{clip['slug']}.mp4")
v = next(s for s in info["streams"] if s["codec_type"] == "video")
a = next(s for s in info["streams"] if s["codec_type"] == "audio")
return v, a, float(info["format"]["duration"]), clip
def test_fit_mode_is_vertical_with_audio(self):
v, a, dur, clip = self.run_mode("fit")
self.assertEqual((v["width"], v["height"]), (1080, 1920))
self.assertEqual(v["pix_fmt"], "yuv420p")
self.assertEqual(a["channels"], 2)
self.assertAlmostEqual(dur, clip["dur"], delta=0.2)
def test_crop_mode_is_vertical(self):
v, a, dur, clip = self.run_mode("crop")
self.assertEqual((v["width"], v["height"]), (1080, 1920))
self.assertAlmostEqual(dur, clip["dur"], delta=0.2)
@classmethod
def tearDownClass(cls):
shutil.rmtree(cls.tmp, ignore_errors=True)
if __name__ == "__main__":
unittest.main()
I also looked at a frame of the fit output: the test pattern sits in the middle of the frame with a blurred, stretched copy above and below it, as intended. The tests prove the format, not the editorial quality. They can't tell you whether a clip is a good one.
Step 4: check the platform rules
For YouTube, the help page says Shorts can be up to three minutes if they are square or vertical, and notes that a Short over one minute with an active copyright claim is blocked globally. That is a reason to be careful with music and archive footage: use only material you own or are licensed to use. For Facebook Reels, I couldn't open Meta's requirements, and a search summary suggested 9:16 at 1080 by 1920 and, through the publishing API, a length of 3 to 90 seconds. Don't rely on that; check Meta's current page before you automate anything.
What Reel Factory says it does
Pixasocial's homepage describes Reel Factory as a short-form video editor that clips a long video into 9:16 verticals, finds what it calls hooks, adds auto-captions and lets you publish to TikTok, Instagram Reels, YouTube Shorts and X. Its pricing page lists it as a separate purchase that needs a Starter plan or above, with a Factory tier for 40 reels a month and a Studio tier for 80, each clip up to three minutes, and says the Factory tier has no watermark. Facebook isn't named among the places it publishes to, so check that if Facebook is your main channel.
What I'd want to find out in a trial is the same thing I do by hand: does it choose moments that pass the standalone test? Hook detection on documentary narration is a different job from hook detection on a talking-head podcast. I'd run the same four-minute story through it and compare its picks with my five.
My honest view is that scripts like mine are fine if you are comfortable with a command line and cut a few clips a week. A tool starts to make sense if you cut dozens of clips, if you want captions and cutting in one place, or if you don't want to maintain scripts.
What I haven't verified
- The quality of Reel Factory's clip choices, captions and exports.
- Meta's current Reels specifications and length rules.
- The script on real footage with variable frame rates, or on very large source files.
- How clips perform on any platform.
I have not used Pixasocial for this post. Everything I say about it comes from its public pages, read on 17 November 2026. I haven't tested its publishing, captions, clip cutting or whether a Facebook Page can be connected. Its comparisons with Buffer, Hootsuite and Canva are the vendor's own and I haven't checked them. This post contains an affiliate link.
Want to see Pixasocial yourself?
If you cut many clips from long videos and want to see what Reel Factory includes, you can look at the current product and pricing. This is an affiliate link: RAJIBS may earn a commission if you subscribe, at no extra cost to you. Confirm which platforms it publishes to before you pay.
Look at PixasocialWhat I ran this against
- ffmpeg 7.1.5 and ffprobe on Linux, Python 3.13.5, run on 17 November 2026. The test generates a 4-minute 1920x1080 test pattern with a tone, cuts the first clip in both modes, and checks with ffprobe that the output is 1080x1920, yuv420p, stereo audio and within 0.2 seconds of the requested length. 5 tests pass.
- I looked at one frame of the 'fit' output by eye to confirm the blurred background and centred frame. I used no real documentary footage, and I did not upload any clip to a platform.
- I have not used Pixasocial or its Reel Factory. They are described only from the public pages listed below.
- Facebook Reels requirements are not confirmed: Meta's pages refused my tools, so I mark those figures as unverified.
Sources checked
- FFmpeg documentation, filters (
boxblur,overlay,crop,scale,subtitles): ffmpeg.org/ffmpeg-filters.html. - YouTube Help, "Understand three-minute YouTube Shorts" (square or vertical videos up to three minutes uploaded on or after 15 October 2024 are categorised as Shorts; Shorts over one minute with an active copyright claim are blocked globally): support.google.com/youtube, read 17 November 2026.
- Pixasocial pricing and homepage, read 17 November 2026: app.pixasocial.com/pricing and pixasocial.com. The pricing page says it posts across 14 networks and names ten of them (Instagram, X, LinkedIn, TikTok, YouTube, Telegram, Bluesky, Pinterest, Threads and Reddit); Facebook is not among the names. It lists 300, 500 and 1,000 posts a month on its Start, Workspace and Studio plans and unlimited under fair use on Scale.
- Pixasocial homepage, section on Reel Factory (clip a long-form video into 9:16 verticals, find hooks, add auto captions, publish to TikTok, Instagram Reels, YouTube Shorts and X): pixasocial.com; pricing page lists Reel Factory as billed separately, requiring a Starter plan or above, with a 40-reels-a-month tier at $49 a month and an 80-reels tier at $79 a month, each clip up to 3 minutes. Read 17 November 2026.
- Meta Reels Publishing API documentation and Meta Business Help Center requirements page for Facebook Reels: I could not open them. A search summary reported 9:16, 1080 x 1920, H.264 and AAC audio, and a 3 to 90 second range through the API. Treat these as unconfirmed.