The local-first AI clipper that finishes the job. Drop in a long video → get ranked, caption-burned, speaker-tracked 9:16 clips out — and schedule them to post while your PC is off.
Paste a YouTube link or drop a file. AutoClip transcribes it, uses an LLM to find the moments actually worth clipping, reframes them to vertical while tracking whoever is speaking, burns in animated captions, exports platform-ready MP4s — then hands the finished clips to Buffer to publish on schedule. No accounts with us. No uploads to our servers. No watermarks. No subscription.
Your machine edits. Your Buffer publishes. Your R2 bridges the media. Nobody owns your content but you.
- Ingest anything — a YouTube URL or a local file, hours long or minutes.
- Find the real hooks — an LLM reads the transcript and ranks the moments worth clipping, down to the word. Timing is measured, never guessed.
- Reframe to vertical — 9:16 (or 1:1, 16:9) crops that track the speaker and cut on shots, never pan across an edit like the janky stuff.
- Burn in captions — four animated styles (word-pop, karaoke fill, clean lower-third, high-contrast boxed), edited word by word with find/replace and lock-in.
- Export and post — professional MP4s at three ratios with loudness-matched audio — then schedule them straight to Instagram, YouTube, Facebook, or TikTok through Buffer, and close the laptop.
Two ways to run it:
- Fully local — Whisper + Ollama. Nothing leaves your machine, no API costs.
- Bring your own key — Anthropic, OpenAI, Gemini, or any OpenAI-compatible endpoint (OpenRouter, Groq, DeepSeek, LM Studio) for better clip selection.
Only transcript text is ever sent to a provider — never video or audio. With Ollama, nothing is sent at all.
AutoClip isn't a SaaS and never will be. Posting is a hand-off, not a hosted service:
- Buffer — the schedule lives here. You bring your own Buffer API key, and the social accounts already connected inside Buffer show up as channels to pick from.
- Cloudflare R2 — your own bucket acts as a temporary media bridge, because Buffer needs a public URL to fetch the clip from. Once Buffer confirms the post went out, the object is deleted.
- Your PC — only needs to be running long enough to hand the job over.
Your PC (edit + export + hand off)
│ upload → your R2 bucket (temporary)
▼
public media URL
│
▼
Buffer → scheduled post → Instagram / YouTube / Facebook / TikTok
│
└── post sent → R2 object deleted
Schedule a post, and the machine can go to sleep. Buffer owns the schedule from that moment on.
Configure everything once in Settings → Keys (Buffer API key, R2 access key + secret) and Settings → Publishing (R2 endpoint, bucket, public URL). After that, publishing is: pick a clip → Publish/Schedule → pick Buffer → pick a channel → caption → confirm. No credential forms in the publish flow, ever. Secrets live in your OS keyring and are never sent to us, logged, or echoed back through the API.
Working end to end: ingest, transcription, highlight detection across four providers, speaker-tracked reframing, four caption styles, export at three aspect ratios, the full review UI — and remote publishing/scheduling through Buffer with a BYOK R2 media bridge. Verified on real footage — see what "verified" means.
Pre-1.0. The reframe quality bar hasn't been validated against a fixed golden set yet, which is the gate for tagging v0.1.0.
| Python | 3.11 or 3.12 — not 3.13. MediaPipe publishes no 3.13 wheels and the reframe stage needs it. |
| ffmpeg | A full build with libass and libx264. Both ffmpeg and ffprobe on PATH. See below — the default package is the wrong one on macOS and Windows. |
| Node | 20+, to build the UI. Not needed at runtime. |
| GPU | Optional. NVIDIA or Apple Silicon speeds up transcription several-fold; CPU works, just slower. |
autoclip doctor checks all of this and tells you exactly what to fix. Run it before anything else.
Captions are burned in with libass, and on two platforms the obvious package doesn't include it. It installs cleanly, then fails to burn a single caption.
macOS — Homebrew split the formula; the plain one is a reduced build:
brew install ffmpeg-fullIf you already installed the plain one: brew unlink ffmpeg && brew link --force --overwrite ffmpeg-full.
Windows — install the full build, not Gyan.FFmpeg.Essentials:
winget install Gyan.FFmpegLinux — the distro package is fine:
sudo apt install ffmpeggit clone https://github.com/artbyjazi/autoclip.gitcd autoclip && uv venv --python 3.11 && uv pip install -e ".[dev]"cd frontend && npm install && npm run build && cd ..autoclip doctorautoclip serveThat opens http://localhost:8000. If you don't use uv, a plain python -m venv .venv and pip install -e ".[dev]" works the same way.
Clip selection needs a language model. Either paste a key in Settings → Keys, or:
autoclip config set-secret anthropicKeys go into your OS keyring — Credential Manager, Keychain, or Secret Service — never into a config file. If no keyring backend exists, AutoClip falls back to a file and says so, in the UI and in doctor.
For a fully local setup, install Ollama and pull a model instead:
ollama pull llama3.1:8bClip quality tracks model quality closely. A 7B model returns valid JSON full of mediocre picks; a frontier model is noticeably better at spotting a real hook. That's the honest trade for running offline.
- Buffer: create an API key in your Buffer account (and connect the social accounts you want to publish to).
- Cloudflare R2: create a bucket, generate an R2 API token (read/write for that bucket only), and enable public access — either a custom domain or the
r2.devpublic bucket URL. - Paste the secrets in Settings → Keys:
buffer_api_key,r2_access_key_id,r2_secret_access_key. - Fill in Settings → Publishing: R2 endpoint (
https://<ACCOUNT_ID>.r2.cloudflarestorage.com), bucket name, public base URL, and optionally a Buffer organization ID.
The UI should then show Buffer ✓ Connected and R2 ✓ Configured. You're done — publish and schedule from any clip. Prefer the CLI? The same keys work via autoclip config set-secret buffer_api_key (and r2_access_key_id, r2_secret_access_key).
uv pip install -e ".[gpu]"CUDA runtime libraries for NVIDIA GPUs. Install these if doctor reports that CTranslate2 can't see your GPU — pip puts them somewhere the OS loader doesn't search, and AutoClip registers the location itself. On macOS this deliberately installs nothing: there's no CUDA there, and Apple Silicon takes the CPU path.
uv pip install -e ".[diarization]"Speaker diarization via WhisperX — what lets the reframe stage cut to whoever is talking in a multi-person video. Pulls PyTorch (large), and needs a HuggingFace token plus acceptance of the gated pyannote model licences.
The guaranteed path — ffmpeg, Python version, and fonts all pinned:
docker compose -f docker/compose.yaml up --builddocker compose -f docker/compose.yaml --profile gpu up --buildEverything the UI does is also on the CLI:
| command | does |
|---|---|
autoclip doctor |
check this machine and explain what's missing |
autoclip serve |
start the web app |
autoclip clip <url|file> |
run the whole pipeline and export |
autoclip jobs |
list recent jobs |
autoclip providers |
check which providers are reachable |
autoclip styles |
list caption presets |
autoclip config show |
print settings |
autoclip update-ytdlp |
update yt-dlp after a YouTube change |
| style | look |
|---|---|
bold_pop |
chunky white, heavy outline, spoken word grows and turns yellow |
karaoke_fill |
words fill with colour exactly as they're spoken |
clean_lower |
minimal lower third, no animation |
boxed |
high-contrast text on a solid block |
Fonts are bundled under the SIL Open Font License, so nothing is fetched at runtime.
Real failures from development and daily use — not hypotheticals.
autoclip doctor says Python is wrong. You're on 3.13. MediaPipe has no wheels for it. uv venv --python 3.11.
Scheduling fails with an R2 error. Publishing needs all four R2 pieces: credentials in Keys, and endpoint + bucket + public URL in Publishing. If the public base URL is wrong, Buffer can't fetch the clip later even though the schedule is accepted — fix it and re-sync.
A Buffer-scheduled post shows "scheduled" but the platform never gets it. Check Buffer's own dashboard first — it owns the schedule after hand-off. Then open Publishing → Sync now in AutoClip to pull the live provider status back into local history. If it errored, retry from the history row.
Transcription fails with "Library cublas64_12.dll is not found". The CUDA runtime libraries aren't installed. uv pip install -e ".[gpu]". AutoClip registers their location itself — pip installs them somewhere the OS loader doesn't search, which is why the error is so unhelpful.
"Requested int8_float16 compute type, but the target device does not support..." Clear whisper.compute_type in ~/.autoclip/config.json and let AutoClip choose. It queries the backend for what's actually supported rather than guessing from your GPU model.
Captions don't appear in exports, or ffmpeg says "No such filter: ass". Your ffmpeg has no libass. doctor reports this and prints the right command for your platform. On macOS that means brew install ffmpeg-full, not brew install ffmpeg; on Windows the full Gyan build, not "essentials".
YouTube downloads fail with a bot check. As of 2026, YouTube blocks most anonymous downloads and proof-of-origin tokens no longer clear it. Set Settings → Ingest → cookies from browser to a browser you're signed into, and close that browser first — it locks its cookie database while running. Uploading a file always works and needs none of this.
Exports are slower than expected. Check doctor for GPU encoding. A build can list h264_nvenc and still be unusable if your driver is older than the NVENC API it was compiled against; AutoClip probes this and falls back to CPU encoding, which is identical quality and just slower.
No sound in the review player. Click Test audio under the player. It measures the actual signal leaving the video element and tells you whether the problem is in AutoClip or between your browser and your speakers.
ingest → prepare → transcribe → highlights → reframe → captions → export
Each stage writes artifacts to ~/.autoclip/work/{job_id}/, so a retry resumes at the stage that failed rather than starting over. Two decisions carry most of the design:
Highlight detection returns word indices, not timestamps. Models are unreliable at arithmetic and completely reliable at copying a number they can see. Timing is looked up from measured word timings afterwards.
Crop paths never interpolate across a cut. Shots are detected first and framed independently. Panning through an edit is the most obvious sign of an auto-reframed video.
ARCHITECTURE.md covers the rest, including why several odd-looking choices exist.
Has been: the full pipeline on real talking-head footage, asserted end to end — 1080×1920 h264/yuv420p output, AAC at −14 LUFS, crop segments tiling each clip without gaps, captions burned in, framing correctly following a cut to a second speaker. Remote publishing (Buffer hand-off, status sync, R2 cleanup) is covered by mocked transport tests that need no credentials. Run the pipeline test yourself:
AUTOCLIP_E2E_MEDIA=/path/to/clip.mp4 pytest -m e2eHasn't been: the §6.4 reframe acceptance bar — no visible jitter, no cut-off faces, speaker on screen ≥95% of speaking time — against a fixed three-video golden set. The mechanics have unit coverage, but "looks right on footage I picked" isn't the bar. This is the gate for v0.1.0.
Also unverified: whether the clip picks are good. That's a judgement call about your material and your model, and no test settles it.
Deliberate, not oversights:
- No direct posting integrations to TikTok/Instagram/YouTube. Their APIs are approval-gated; posting is handed off to Buffer, which already owns the connected accounts.
- No cloud version, no accounts, no telemetry. No central scheduler, no central media storage, no multi-tenant backend — your R2 and your Buffer do the work, and your SQLite is history only.
- No timeline editor beyond trim handles and caption edits.
- No DRM circumvention, ever.
Prompts and caption styles are the highest-leverage places to start, and neither needs deep knowledge of the codebase — backend/autoclip/prompts/highlight_v1.txt is plain text and affects output quality more than most code changes. See CONTRIBUTING.md.
AutoClip bundles yt-dlp. Only download content you own or have the rights to process. AutoClip contains no workarounds for DRM or paywalled content and never will.
MIT — see LICENSE. Bundled fonts (Anton, Inter) are under the SIL Open Font License.