An AI-driven video editor that allows agents to remove silence, edit via transcripts, add captions, and export projects to professional editing software.
Also known as MakeMyClip/editor, editor, @makemyclip/editor
- Stars
- 11
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.5.1
- Last commit
- Nov 13, 2026
- License
- MIT
What is MakeMyClip Editor MCP?
MakeMyClip Editor is an AI-driven video editor that allows agents to remove silence, edit via transcripts, add captions, and export projects to professional editing software.
Summary generated from the project's README
About MakeMyClip Editor MCP server
Editing video through natural language conversation is what MakeMyClip Editor enables for developers and creators using AI agents. This open-source tool allows you to manage video projects locally on your machine using FFmpeg and whisper.cpp for transcription. It functions as an MCP server for clients like Claude Desktop or Cursor, as well as a Claude Code skill and a command-line interface. Because it runs entirely on your hardware, it requires no cloud uploads, no accounts, and no API keys.
Users can perform complex editing tasks such as removing silence, cutting specific words from a transcript, and deleting repeated takes. The server provides tools to add burned-in captions or create title cards. Once the initial automated edits are complete, you can export the results as an mp4 or as professional project files for Final Cut Pro, DaVinci Resolve, or Premiere Pro. This bridge between AI-driven automation and professional manual editing ensures that every change is recorded on a non-destructive timeline that supports undo and redo operations.
What you can do with it
- 1Clean up talking-head recordingsAsk an agent to remove pauses, delete repeated takes, and add captions to a raw video file.
- 2Assemble product demonstrationsCombine multiple screen recordings into a single polished video with title cards and specific durations.
- 3Verify edit qualityIdentify specific moments where a cut might accidentally clip a spoken word.
Written from the project's README. Every use case is checked against a quote from it.
How to install MakeMyClip Editor MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall MakeMyClip Editor MCP in Claude Code
$ claude mcp add editor -- npx -y @makemyclip/editorInstall MakeMyClip Editor MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Install MakeMyClip Editor MCP in VS Code
.vscode/mcp.json
{
"servers": {
"editor": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Install MakeMyClip Editor MCP in VS Code CLI
$ code --add-mcp '{"name":"editor","type":"stdio","command":"npx","args":["-y","@makemyclip/editor"]}'Install MakeMyClip Editor MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Install MakeMyClip Editor MCP in Codex
$ codex mcp add editor -- npx -y @makemyclip/editorInstall MakeMyClip Editor MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.editor] command = "npx" args = ["-y", "@makemyclip/editor"]
Install MakeMyClip Editor MCP in Gemini CLI
$ gemini mcp add -s user editor npx -- -y @makemyclip/editorInstall MakeMyClip Editor MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Configuration
MAKEMYCLIP_FFMPEG_PATHOptional: an FFmpeg to use instead of the one ffmpeg-static downloads.
MAKEMYCLIP_WHISPER_MODELOptional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions.
MAKEMYCLIP_WHISPER_PATHOptional: the whisper-cli binary, when it isn't on PATH.
MAKEMYCLIP_WORKSPACEFolder the editor may read and write; put your videos here. Defaults to a folder in the temp directory.
| Name | Description | |
|---|---|---|
| MAKEMYCLIP_FFMPEG_PATH | Optional: an FFmpeg to use instead of the one ffmpeg-static downloads. | |
| MAKEMYCLIP_WHISPER_MODEL | Optional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions. | |
| MAKEMYCLIP_WHISPER_PATH | Optional: the whisper-cli binary, when it isn't on PATH. | |
| MAKEMYCLIP_WORKSPACE | Folder the editor may read and write; put your videos here. Defaults to a folder in the temp directory. |
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubMakeMyClip Editor is a free, open-source (MIT) video editor that AI agents drive. You ask Claude to edit a recording; it calls the editor's tools, and FFmpeg and a local whisper.cpp do the work on your computer. It ships as a Claude Code skill, the clip CLI, an MCP server, and a browser timeline editor. No cloud upload, no account, no API key, no telemetry, no generative AI.
"Cut the repeated takes and the pauses out of talk.mp4, caption it, and give me a DaVinci Resolve project."
Claude transcribes the recording locally, cuts the earlier take of each repeated phrase and the silences, captions the speech, flags any cut that may clip a word, and writes
talk.fcpxml. Each edit is one undoable step on a timeline you can open in the browser and take over.
What it does
Version 0.4.0 turns a raw talking-head recording into a clean, captioned cut that opens in a pro editor:
| Feature | What it does | CLI |
|---|---|---|
| Remove silence | Cuts the pauses out of a recording, with a sensitivity control and a dry run | clip timeline silence |
| Local transcription | Word-level transcript with timeline times, from whisper.cpp on your machine | clip timeline transcribe |
| Edit by transcript | Cuts a range of words out of a clip | clip timeline cut-words |
| Remove repeated takes | Cuts the earlier take of each phrase said twice in a row | clip timeline remove-retakes |
| Captions | Burned-in captions timed to the words, as short phrases or one word at a time | clip timeline captions |
| Cut check | Flags cuts where a word may be clipped, with a contact sheet of the frames on each side | clip timeline check |
| Export to Final Cut Pro and DaVinci Resolve | FCPXML 1.10 project | clip timeline export --format fcpxml |
| Export to Premiere Pro | Final Cut Pro 7 XML project, captions as .srt files |
clip timeline export --format xmeml |
| Render | mp4 of the finished cut | clip timeline export |
All of it works from chat (the Claude Code skill or the MCP server), the CLI, and the browser UI; the cut check isn't in the UI yet. Every edit is one step on a non-destructive timeline that undo and redo walk through. Underneath sit 19 single-file FFmpeg tools for everything else: trim, split, concat, transitions, text and title cards, zoom/pan, overlay, speed, color, chroma key, stabilize, and render.
Install in 30 seconds
As a Claude Code skill (chat-driven, no global install):
npx skills add MakeMyClip/editor
Or install it as a Claude Code plugin from this repo's marketplace, inside Claude Code:
/plugin marketplace add MakeMyClip/editor
/plugin install makemyclip-editor@makemyclip
As a CLI (for scripts and CI):
npm i -g @makemyclip/editor
clip --help
As a browser UI (dark visual timeline editor):
clip ui # opens http://127.0.0.1:5573
As a Claude Desktop extension (one click, no Node or config file):
- Install FFmpeg:
brew install ffmpegon macOS,winget install Gyan.FFmpegon Windows. - Download
makemyclip-editor.mcpband double-click it, or drag it into Claude Desktop.
Put your videos in the extension's Media folder (by default Documents/MakeMyClip); the editor reads and writes only there. The extension doesn't include FFmpeg (see License): it finds the one Homebrew, MacPorts, winget, Scoop or Chocolatey installed, or you pick it in the extension's settings, along with the optional whisper model.
As an MCP server (drive it from Claude Desktop / Cursor / any MCP client — no API key, on your existing Claude):
// claude_desktop_config.json → "mcpServers"
{
"makemyclip-editor": {
"command": "npx",
"args": ["-y", "@makemyclip/editor", "mcp"],
"env": {
"MAKEMYCLIP_WORKSPACE": "/path/to/your/media",
"MAKEMYCLIP_WHISPER_MODEL": "/path/to/ggml-base.en.bin"
}
}
}
It is listed in the official MCP Registry as io.github.MakeMyClip/editor, so MCP clients that browse the registry can install it from there. The Claude Code skill auto-discovers triggers and shells out via npx -y on demand. The MCP server exposes the timeline tools (show / edit / check / transcribe / undo / redo / export) and a doctor setup check over stdio; media stays confined to MAKEMYCLIP_WORKSPACE, and MAKEMYCLIP_WHISPER_MODEL is only needed for transcription and captions. Everything runs locally and offline — no API key.
Optional: local transcription (for editing by transcript, removing retakes, and captions):
brew install whisper-cpp # macOS; other platforms: https://github.com/ggml-org/whisper.cpp
export MAKEMYCLIP_WHISPER_MODEL=/path/to/ggml-base.en.bin
Download a model such as ggml-base.en.bin from huggingface.co/ggerganov/whisper.cpp, and set MAKEMYCLIP_WHISPER_PATH if whisper-cli isn't on your PATH. The editor never downloads a model itself.
Check your setup:
npx -y @makemyclip/editor doctor # add --json for a machine-readable report
It checks Node, which FFmpeg runs and whether it can draw text and captions, the workspace, a caption font, and the optional whisper.cpp and model, and prints the fix for anything missing. In Claude Desktop or another MCP client, ask "is my setup OK?" and Claude runs the same check.
Quick start: clean up a talking-head recording
In Claude Code (with the skill) or Claude Desktop (with the MCP server), ask:
Clean up talk.mp4: remove the repeated takes and the pauses, add captions, check the cuts, then export an mp4 and a Final Cut Pro project.
The same steps from the CLI:
clip timeline new
clip timeline add-media talk.mp4 # prints the clip id, e.g. clip_ec2f047d
clip timeline transcribe clip_ec2f047d # each word with its time, plus repeated takes
clip timeline remove-retakes clip_ec2f047d # cut the earlier take of each repeated phrase
clip timeline silence clip_ec2f047d # cut the pauses
clip timeline captions # caption every transcribed clip
clip timeline check --sheet cuts.jpg # flag cuts that may clip a word
clip timeline export talk-clean.mp4 # render the cut
clip timeline export talk.fcpxml # or open it in Final Cut Pro / DaVinci Resolve
clip timeline export talk.xml # or in Premiere Pro
A cut splits the clip into pieces: the first keeps its id, and clip timeline show lists the rest, so run silence on each piece you want tightened (in chat, the agent does this for you). clip timeline undo reverses any step.
Another example: a product demo from screen recordings
Five screen recordings → one polished product demo. Type this into Claude Code (or Claude Desktop, via the MCP server):
Import these five recordings. Trim each to the most interesting 8–12 seconds. Add black title cards saying "Demo 1: Inbox", "Demo 2: Search", "Demo 3: Compose", "Demo 4: Calendar", "Demo 5: Reports" between them. Concat in order. Render to 1080p mp4.
The agent runs roughly ingest × 5 → trim × 5 → add_title_card × 5 → concat → render. The final mp4 lands in your workspace folder, every step is appended to session.json, and you can ⌘Z any of it.
Or skip the chat and do it from a script:
clip ingest demo1.mp4
clip trim demo1.mp4 5 20
clip add_title_card demo1-trim.mp4 "Demo 1: Inbox"
clip concat demo1-with-card.mp4 demo2.mp4 demo3.mp4
clip render concat-output.mp4 mp4 23 fast 1920
Same registry, same session log, same output.
All 19 tools
19 tools across 5 categories, four surfaces (Claude Code skill, CLI, browser UI, MCP server), one shared op log.
| Category | Tools |
|---|---|
| Cut & arrange | trim, split, concat, transition (12 kinds) |
| Text & captions | add_text, add_title_card, add_captions |
| Visual primitives | transform, adjust, zoom_pan (Ken Burns), overlay, speed |
| Composites & specialty | highlight_reel, silence_remove, chroma_key, stabilize |
| Output & I/O | ingest, preview, render, add_audio |
Plus four meta-ops not in the registry: snapshot, undo, inspect, delete.
The browser UI is a dark timeline editor: drag-drop import, a monitor (the composited frame at the playhead), an editable timeline (select a clip to trim / split / move / transition / remove, cut its silences, or cut words and retakes from its transcript), captions from transcripts, one-click export (an mp4, or a project for Final Cut Pro, DaVinci Resolve or Premiere Pro), timeline undo/redo, snapshot, and keyboard shortcuts.
Why it exists
Existing tools force a tradeoff that doesn't need to exist:
- iMovie / CapCut / DaVinci Resolve — mouse-and-timeline desktops. Can't be driven by an agent, scripted in CI, or version-controlled.
- Descript — closed-source, cloud-based, rewrites audio with generative AI you can't inspect.
- Runway / Pika / Luma — generate video from text. Useful for VFX, useless for assembling a 90-second demo from recordings you already have.
- Raw FFmpeg — deterministic and free, but the surface is hostile to LLMs: cryptic filter graphs, no session model, no undo, no tool catalog.
MakeMyClip Editor closes the gap: deterministic editing an agent can drive end to end (silence, transcript cuts, captions, export to pro editors) on a timeline it can inspect and a human can open and take over.
Feature matrix
| Feature | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Agent-driven (chat to edit) | ✅ | ❌ | ⚠️ | ❌ | ❌ |
| Open-source (MIT) | ✅ | ❌ | ❌ | ❌ | LGPL/GPL |
| Local-only (no cloud) | ✅ | ✅ | ❌ | ❌ | ✅ |
| Deterministic output (no AI generation) | ✅ | ✅ | ✅ | ❌ | ✅ |
| Free forever | ✅ | ✅ | freemium | paid | ✅ |
| Programmable CLI | ✅ | ❌ | ❌ | API | ✅ |
| Visual timeline UI | ✅ | ✅ | ✅ | ✅ | ❌ |
| Snapshot & undo | ✅ | ✅ | ✅ | ⚠️ | ❌ |
| Inspectable session log (JSON) | ✅ | ❌ | ❌ | ❌ | ❌ |
| Works as a Claude Code skill | ✅ | ❌ | ❌ | ❌ | manual |
| Stream-copy for lossless cuts | ✅ | ⚠️ | ⚠️ | ❌ | ✅ |
| Zero telemetry | ✅ | ❌ | ❌ | ❌ | ✅ |
Use-case matrix
| Job to be done | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Trim screen recordings to highlights | ✅ | ✅ | ✅ | ❌ | ✅ |
| Assemble a product demo from N clips + title cards | ✅ | ✅ | ⚠️ | ❌ | ⚠️ |
| Add script-provided timed captions | ✅ | ⚠️ | ✅ | ❌ | ⚠️ |
| Transcribe & edit video by its transcript | ✅ (local whisper.cpp) | ⚠️ | ✅ | ❌ | ❌ |
| Auto-cut silence from a recording | ✅ | ❌ | ✅ | ❌ | ⚠️ |
| Finish the cut in Final Cut Pro, Resolve or Premiere | ✅ | ⚠️ | ✅ | ❌ | ❌ |
| Chroma-key / green-screen compositing | ✅ | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Generate b-roll / VFX shots from a prompt | ❌ | ❌ | ⚠️ | ✅ | ❌ |
| Multi-track audio mixing with effects | ❌ | ⚠️ | ✅ | ❌ | ⚠️ |
| Drive editing from an AI agent in natural language | ✅ | ❌ | ⚠️ | ⚠️ | ❌ |
| Run as a scriptable CI pipeline | ✅ | ❌ | ❌ | ⚠️ (API) | ✅ |
| Long-form (>30 min) with hundreds of clips | ⚠️ | ✅ | ✅ | ❌ | ✅ |
| Edit on Linux / headless / fully offline | ✅ | ❌ | ❌ | ❌ | ✅ |
Legend: ✅ great fit · ⚠️ works but not the best · ❌ doesn't fit.
Honest summary: MakeMyClip Editor is the right pick when you want deterministic, scriptable editing that an AI agent can drive end-to-end. Not the right pick for generative video (Runway), a hosted transcript editor with collaboration and AI voice features (Descript), or a heavy multi-track NLE (DaVinci, Premiere) — though it can hand its cut to one.
Claude Code → skill triggers → npx -y @makemyclip/editor <tool | timeline …>
│
Browser UI → /api/tools/:name · /api/timeline/verbs → registry + verb layer
│
Claude Desktop → clip mcp (MCP server) → timeline verbs
│
▼
Tool handlers (TypeScript)
│
▼
FFmpeg subprocess (args as array, no shell)
│
┌───────────────────────┴───────────────────────┐
▼ ▼
Composition document session.json
(non-destructive timeline, (append-only op log
op-log undo/redo) of every tool call)
Two layers of state, by design. The composition document is the source of truth for assembled edits: a non-destructive, multi-track timeline that clip timeline, the browser UI, and the agent (the Claude Code skill or the clip mcp server) all mutate through one op-aware path, with a coupled op log that powers undo/redo. session.json is an append-only op log of every tool invocation — { id, tool, args, result, timestamp } — written through the same appendOp() path by the single-file tools (clip trim, /api/tools/:name, …); it is the audit trail and recovery layer. Both layers are written through one serialized path, so any combination of human + agent edits stays consistent.
Build a composition end-to-end (CLI shown; the browser UI and the agent — Claude Code or MCP — drive the same document):
clip timeline new # start an empty composition
clip timeline add-media intro.mp4 # ingest + append a clip
clip timeline add-media demo.mp4
clip timeline transition <afterClipId> fade 0.5
clip timeline show # inspect tracks, clips, timings
clip timeline export final.mp4 # compile the document to a render
Every edit is undoable (clip timeline undo / redo, clip timeline log), and clip timeline at <sec> / frame <sec> give an agent read-only eyes on the document. Run clip timeline --help for the full subcommand list.
- Language: TypeScript (Node 24+) and React 19 (browser UI)
- Timeline schema: Zod (shared with the MakeMyClip.com web app)
- Subprocess: execa — args as an array, no shell injection
- FFmpeg: downloaded by
ffmpeg-staticwhen the npm package installs, with aMAKEMYCLIP_FFMPEG_PATHoverride and an installed FFmpeg as the fallback (the Claude Desktop extension always uses an installed one) - Transcription: optional, user-installed whisper.cpp, run as a subprocess
- MCP:
@modelcontextprotocol/sdk— theclip mcpserver (Claude Desktop / any MCP client) - UI: Hono server + Vite + React, plain CSS
Setup & installation
Do I need FFmpeg installed separately?
Not for the npm package, the CLI or the Claude Code skill: ffmpeg-static downloads an FFmpeg build for your platform when the package installs. The Claude Desktop extension is the exception: it doesn't include FFmpeg, so install it first (brew install ffmpeg or winget install Gyan.FFmpeg). For your own FFmpeg build (LGPL-only, custom codecs, hardware acceleration), set MAKEMYCLIP_FFMPEG_PATH to its path and the downloaded binary is ignored. clip doctor shows which FFmpeg runs.
What platforms does it run on?
macOS, Linux, and Windows — anywhere Node 24+ runs. The browser UI binds to 127.0.0.1 and needs no internet connection.
Can I use it without Claude Code?
Yes. The clip CLI and clip ui browser app are first-class surfaces, and clip mcp lets Claude Desktop (or any MCP client) drive it. Claude Code is one of several entry points — the editor is agnostic to which agent (or human) drives it.
Does it require an API key? No — nowhere. The CLI, the browser UI, the Claude Code skill, and the MCP server all run with no API key. Agent-driven editing uses whichever Claude you already run (Claude Code, or Claude Desktop via MCP); the editor itself never calls a language model.
Capabilities & limits
Is it production-ready? This release is feature-complete for local editing — a dark timeline editor (view, edit, preview, export), silence removal, transcript editing, captions, export to Final Cut Pro, DaVinci Resolve and Premiere Pro, 19 single-file tools, an MCP server, and 741 tests passing. The API surface is still pre-1.0 (tool schemas may change in minor ways before 1.0). Use it for real work; pin a version in CI.
What's the maximum video size or duration? No hardcoded limit. FFmpeg streams the file rather than loading it into memory, and the browser UI streams uploads to disk — multi-GB recordings work fine. This release isn't tuned for projects with hundreds of clips or runtime above 30 minutes; for those, drive the CLI directly.
Does it support 4K, HDR, or vertical (TikTok / Reels) formats?
4K and vertical aspect ratios work out of the box — render takes a maxWidth and preserves the source aspect ratio. HDR pass-through works; deliberate HDR-to-SDR tone-mapping isn't a named tool yet.
Privacy & data
Does it send my video files anywhere? No. The editor makes zero network calls — period. The agent runs in Claude Code or Claude Desktop, not inside the editor, so nothing leaves your machine.
Where does it store my files?
In a local workspace folder — $TMPDIR/makemyclip-editor by default; override with MAKEMYCLIP_WORKSPACE. The folder holds input files, output files, composition.json (the timeline), session.json (the op log), and snapshots/. You can version-control the whole folder.
Working with agents
Which AI model does it use? No language model — the agent is whatever you already run: Claude Code, or Claude Desktop / Cursor via the MCP server. They call the editor's tools; the editor executes them deterministically with FFmpeg. Transcription, if you set it up, runs your local whisper.cpp with a model file you download.
How does the agent know which tool to call?
Each tool and timeline verb ships with a Zod input schema (parameter docs inline via .describe()) and a one-line description. The Claude Code skill and the MCP server expose that catalog to the agent; it reads the descriptions, picks a tool, and fills in the arguments.
What if the agent makes a mistake?
Every edit appends to session.json and produces a new output file in the workspace; nothing is destructive. Press ⌘Z to pop the last op; click Snapshot before risky operations to save a named restore point; the entire workspace is a folder you can git init.
License & comparisons
Is it free?
Yes — MIT-licensed, free forever for local editing. No paid tier, no signup, no upsell in the editor. Paid AI-generation features (voice synthesis, music, stock footage) will live on MakeMyClip.com when they ship, behind a separate @makemyclip/generation package.
What's the license situation with FFmpeg?
The MakeMyClip Editor source code is MIT. FFmpeg is a separate program the editor runs as a subprocess, so its license covers the binary, not your application code. The build ffmpeg-static downloads is GPLv3 on Intel Macs, Windows and Linux. On Apple Silicon it is a build with nonfree parts that FFmpeg marks as not redistributable, so the Claude Desktop extension ships no FFmpeg at all. For LGPL-only or custom-build requirements (e.g. iOS App Store), set MAKEMYCLIP_FFMPEG_PATH to your own binary.
How is this different from running FFmpeg directly? FFmpeg is one binary with a complex CLI; MakeMyClip Editor is 19 named tools with typed inputs, a session log, snapshot/undo, a browser UI, and an agent-callable API. You're still running FFmpeg under the hood — but with a catalog any LLM can call, input validation that prevents bad commands, and a log you can inspect or version-control.
What's the relationship between this editor and the MakeMyClip.com website? The editor (this repo) is MIT-licensed, free, local, and limited to deterministic FFmpeg operations. MakeMyClip.com is the separate hosted product where paid AI generation features will live. The two share the timeline schema, so projects move between them.
How do I add my own editing tool?
Add a file in src/tools/<name>.ts exporting a Zod input schema and a handler, register it in src/ui/tool-registry.ts, and the tool becomes available in the CLI and the browser UI's tool picker. See AGENTS.md for conventions.
Questions people ask
Answers describe v0.4.0 (November 2026).
How do I edit a video with Claude Code?
Install the MakeMyClip Editor skill with npx skills add MakeMyClip/editor, then ask Claude Code in plain words, for example "cut the pauses out of talk.mp4 and add captions." The skill runs the clip CLI through npx, edits a timeline document in a local workspace folder, and renders with FFmpeg on your machine. Every edit can be undone.
Is there an iMovie or CapCut for Claude?
MakeMyClip Editor is built for that job: an open-source video editor that Claude drives through a Claude Code skill or an MCP server, with a browser timeline (clip ui) where you can watch and take over. It covers everyday edits (trim, join, transitions, titles, captions, silence removal) but isn't a full desktop editor; for finishing, it exports to Final Cut Pro, DaVinci Resolve or Premiere Pro.
MakeMyClip Editor MCP questions
How do I add MakeMyClip Editor MCP to Claude Code?
Run claude mcp add editor -- npx -y @makemyclip/editor in your terminal. Add --scope user to make it available in every project.
How do I add MakeMyClip Editor MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Does this tool require a cloud upload or an API key?
No, everything runs locally on your machine with no cloud upload, no account, and no API key required.
Can I export my edits to professional video editing software?
Yes, you can export to Final Cut Pro, DaVinci Resolve, or Premiere Pro.
How does the transcription work?
It uses whisper.cpp to perform local, word-level transcription on your own machine.
Is there a way to undo an edit?
Yes, every edit is a single undoable step on a non-destructive timeline.