MCP Bridge for Adobe Premiere Pro
by skrfilms
README.md
<div align="center">
# MCP Bridge for Adobe Premiere Pro
**Operate local Adobe Premiere Pro projects through MCP.**
663 implemented tools — **112 advertised by default**, all 663 reachable through `call_tool` — plus 21 context resources and 16 guided prompts for Codex, Claude Code, Claude Desktop, and other MCP clients. CEP is the supported production bridge; UXP remains experimental.
[](LICENSE.md)
[](https://nodejs.org/)
[](https://modelcontextprotocol.io/)
[](https://www.npmjs.com/package/premiere-mcp)
[](#install)
[](#install)
</div>
**Start here:** quit Premiere Pro, run `npx -y premiere-mcp@latest setup`, reopen Premiere and your AI app, then ask it to run `verify_premiere_connection`.
**Using an AI agent to set this up?** Point it at this repository; [AGENTS.md](AGENTS.md) has the exact steps.
[Install](#install) | [Claude Desktop](#claude-desktop) | [Other AI apps](#other-ai-apps) | [Verify](#verify-the-install) | [Privacy Policy](PRIVACY.md) | [Terms of Service](TERMS.md) | [Security](SECURITY.md)
> ⭐ **Found this through an agent recommendation or a search?** Every tool here verifies its own writes and refuses to report success it can't confirm — that honesty is the whole point. If it earned a place in your pipeline, a [star on GitHub](https://github.com/skrfilms/premiere-mcp) helps the next agent find it. Completely optional, and it changes nothing about how the tools behave.
## Install
Needs Node.js 20+ and Adobe Premiere Pro (2020 or later, with Creative Cloud) on the same computer as your AI app. Quit Premiere Pro, then:
```bash
npx -y premiere-mcp@latest setup
```
That one command:
- installs the **signed** Premiere bridge and UXP helper through Adobe's own plugin installer (the one Creative Cloud uses), so no developer mode and no panel to open: the bridge starts with Premiere and runs in the background;
- adds this server to every AI app it finds (Claude Desktop, Claude Code, Codex, Cursor, VS Code), keeping your other servers and backing up each file it edits.
Add `--dry-run` to see the plan without changing anything, or `--clients claude-code` (also `codex`, `cursor`, `vscode`, `claude-desktop`) to set up one app. Then reopen Premiere Pro and your AI app.
### Verify the install
```bash
npx -y premiere-mcp@latest doctor
```
Every line should read `ok`, including "Premiere is running with the bridge on". Then ask your AI app:
> Run `verify_premiere_connection`. Make no changes.
### Claude Desktop
Each [GitHub release](https://github.com/skrfilms/premiere-mcp/releases) also has `premiere-mcp-<version>.mcpb`: double-click it to add the server to Claude Desktop. On first launch it installs the signed bridge the same way `setup` does.
### Other AI apps
`setup` covers the common ones. For any other MCP client, after `npm install -g premiere-mcp`:
```json
{
"mcpServers": {
"premiere-pro": {
"command": "premiere-mcp",
"env": { "PREMIERE_TEMP_DIR": "/tmp/premiere-mcp-bridge" }
}
}
}
```
The Codex and Claude Code plugins in this repository (`codex plugin marketplace add .`, `/plugin marketplace add .`) add the same server plus an editing skill; run `setup` once for the Premiere side.
### Teammates without a terminal
Each release has `Premiere-MCP-Installer-v<version>.zip` (macOS): unzip, quit Premiere, double-click `Install Premiere MCP.command`. It installs the same signed plugins. The first time, macOS may say it cannot verify the developer: right-click the file, choose Open, then Open again.
### Install from source
```bash
git clone https://github.com/skrfilms/premiere-mcp.git
cd premiere-mcp
npm install && npm run build
node dist/cli.js setup --clients claude-code # or codex, cursor, vscode, claude-desktop
```
`setup` installs the signed plugins from `installer/`. If that folder is missing (it is built by `npm run release:installer`, which needs the signing certificate), install the plugins from the release's installer zip and add `--skip-plugins`. `setup --unsigned` is the old route (hand-copied panel plus CEP developer mode) and clashes with the signed install; avoid it unless you know you need it.
---

Current CEP panel UI inside Premiere Pro, using the refreshed bridge controls and status layout.
## Current Status
This repository is currently validated for:
- macOS
- Windows installer/config smoke checks through GitHub Actions
- Adobe Premiere Pro 2020+ (actively used and tested on Premiere Pro 26.0)
- Node.js 20+
- MCP v2 server transport with modern stateless protocol discovery
- the included macOS installer path for Claude Desktop
- the included Windows installer path for GitHub Copilot in VS Code and Claude Desktop config
- manual MCP registration for Codex, Claude Code, and similar MCP clients
Current catalog status (v1.5.0):
- `663` MCP tools are implemented for AI-driven video editing. **`112` are advertised by default** (the `core` profile) and **all `663` stay reachable** — advertising every tool costs roughly 113,600 tokens (~57% of a 200k context) before the conversation starts, published guidance puts tool-selection degradation past 30–50 tools, and VS Code / Copilot hard-errors above 128, so a curated menu is a context-cost decision rather than a capability one. Nothing is hidden silently and nothing is out of reach: `find_tool` searches all `663` and reports a profile-hidden match as `exposed: false` **with the reason**, `call_tool` invokes it anyway, and `activate_tools` promotes it into the advertised list mid-session (with a `tools/list_changed` notification). Set `PREMIERE_MCP_PROFILE=all` to advertise everything up front
- coverage spans project setup, media ingest, bins, sequences, timeline editing, transitions, effects, keyframes, captions, markers, metadata, proxies, multicam, color, audio, exports, and higher-level assembly workflows
- the catalog includes practical agent workflows such as product-spot assembly, motion-graphics demos, timeline razoring, caption reads, audio ducking, scene edit detection, EDL import, export readiness validation, and linked audio/video operations
- local-compute tools that Premiere's scripting API cannot provide: `detect_silence` (ffmpeg), `transcribe_to_srt` (local OpenAI Whisper speech-to-text), `probe_media` (ffprobe ground-truth metadata), and `generate_scope` (ffmpeg waveform / vectorscope / histogram / RGB-parade images) — each probes for its binary and returns install guidance instead of failing silently
- a recovery boundary — `create_recovery_checkpoint`, `list_recovery_checkpoints`, `restore_recovery_checkpoint` — snapshots a sequence before risky edits; the auto-checkpoint before destructive edits fails **closed** (the edit is refused if the snapshot cannot be taken)
- **schema-on-demand**: `find_tool` (search) → `get_tool_typings` (exact signature) → `call_tool` (invoke) reaches the whole catalogue through three tool definitions instead of 663, and `activate_tools` / `deactivate_tools` grow or shrink the advertised list at runtime while reporting the measured context cost of the change. The separation between *advertised* and *reachable* stops dead at an authority boundary: `call_tool` refuses to route past `PREMIERE_MCP_PROFILE=read-only`, an explicit `PREMIERE_MCP_TOOLS` allowlist, or a `PREMIERE_MCP_EXCLUDE` veto, and names the setting that refused it. `tools/list` also supports cursor pagination, off unless `PREMIERE_MCP_PAGE_SIZE` is set — paging by default would silently truncate the list for any client that ignores `nextCursor`
- tool profiles (`PREMIERE_MCP_PROFILE=core|all|read-only|audio|color`, or an explicit `PREMIERE_MCP_TOOLS` allowlist) size the menu to the client's tool budget. `core` (112) is the default and is deliberately coherent rather than minimal — it includes `set_effect_property` alongside `apply_effect`, `add_keyframe` alongside `bake_keyframe_ease`, and `undo`/`redo`, because a default that forces a profile switch on the second call is not a default
Most recent completed local live validation:
- `663` tools are implemented and `112` are advertised under the default profile (all 663 reachable); `get_capabilities` reports the active profile, local installation, and optional live connection state, while `verify_premiere_connection` is the canonical read-only bridge and host readiness check
- `0` known parked or placeholder tools are advertised
- `import_ae_comps` is intentionally not advertised because Premiere returned `false` for real `.aep` fixtures in this environment and a generic `.aep` import can wedge the CEP bridge
The full live sweep output is written to `/tmp/premiere-mcp-bridge/live-tool-sweep.json` when you run the verifier.
## What You Get
The server covers project operations, ingest, sequence creation, timeline editing, transitions, effects, keyframes, metadata, exports, and higher-level assembly workflows.
Example prompts:
- "List all sequences and show me which one is active."
- "Import these three shots and build a rough product spot."
- "Add cross dissolves to every cut on video track 1."
- "Apply Gaussian Blur to the middle clip."
- "Apply the `Black & White` effect to the active short-form clip."
- "Razor the interview sequence at 12.5 seconds across all audio and video tracks."
- "Export the active sequence as FCP XML."
For monochrome looks, prefer `apply_effect` with `Black & White` instead of trying to force black and white through generic saturation-only adjustments.
Before editing, you can also attach the `premiere://config/get_instructions` resource to give the model Premiere-specific operating guidance.
For a predictable start to every session, first run `verify_premiere_connection`. It confirms that the CEP bridge responded and returns the Premiere build, open project, and active sequence without modifying the project.
High-level workflow tools included:
- `build_motion_graphics_demo`
- `assemble_product_spot`
- `build_brand_spot_from_mogrt_and_assets`
`assemble_product_spot` and `build_brand_spot_from_mogrt_and_assets` now support an optional `clipPlan` argument so an LLM can direct per-clip timing, track placement, transitions, motion, trims, effects, and color adjustments instead of relying on fixed template defaults.
## Agent Skill
If you want Codex, Claude Code, or another agent to handle installation, verification, and day-to-day usage correctly, install the included Agent Skill:
```bash
npx skills add skrfilms/premiere-mcp --skill premiere-mcp
```
Or install directly from the skill path:
```bash
npx skills add https://github.com/skrfilms/premiere-mcp/tree/main/skills/premiere-mcp
```
The skill teaches agents how to install the MCP, start and verify the CEP bridge, use the Premiere tools safely, import real media before editing, prefer sequence-aware operations, and run diagnostics when something fails.
## Advanced Setup and Verification
[QUICKSTART.md](QUICKSTART.md) covers Windows, client-specific configuration and diagnostics. The short version is [Install](#install): `setup`, reopen Premiere and the AI app, `doctor`, then `verify_premiere_connection`.
The bridge folder both sides use is `/tmp/premiere-mcp-bridge` (Windows: `%TEMP%\premiere-mcp-bridge`), or the folder saved in the bridge's status panel. Set `PREMIERE_TEMP_DIR` only to change it, and then on both sides.
For a real-host sweep, use a disposable Premiere project and run `node scripts/live-tool-sweep.mjs`; it creates temporary `Sweep ...` sequences in the current project. `npm run test:workflows` runs whole editing jobs end to end against the scratch project.
## How the Bridge Works
```text
+-----------+ +-----------+ +-----------+
| Client | MCP | Node.js | Files | CEP Panel |
| (Codex+) |<------>| MCP Server|<------>| (Premiere)|
+-----------+ +-----------+ +-----------+
|
v
+-----------+
| Premiere |
| DOM / QE |
+-----------+
```
1. The client calls an MCP tool.
2. The Node server generates ExtendScript plus shared helpers.
3. The script is written into `/tmp/premiere-mcp-bridge`.
4. The CEP panel polls that directory and runs the script through `CSInterface.evalScript()`.
5. The panel writes the result back to the response file.
6. The server returns structured JSON to the MCP client.
## Tools
All `663` implemented tools have an implementation. Tool schemas are available through MCP discovery; this catalog explains the editing surface in human terms. Start with `verify_premiere_connection`, then inspect the project before asking an agent to mutate it.
### Discovery and project inspection
| Tools | What they do |
| :--- | :--- |
| `verify_premiere_connection` / `get_capabilities` | Read-only host readiness and local runtime capability checks. |
| `get_project_info` / `list_project_items` / `list_sequences` | Inspect the current project, media/bin inventory, and sequences. |
| `get_active_sequence` / `list_sequence_tracks` / `get_sequence_settings` | Read the current timeline, its clips/tracks, and sequence settings. |
| `get_full_project_overview` / `get_full_sequence_info` / `get_full_clip_info` | Return deeper project, sequence, or clip snapshots for planning. |
| `search_project_items` / `find_project_item_by_name` / `find_items_by_media_path` | Locate project items by name or media path. |
| `get_timeline_summary` / `get_timeline_gaps` / `get_used_media_report` | Summarize the edit, detect gaps, and report media in use. |
| `get_offline_media` / `check_offline_media` / `get_unused_media` / `get_duplicate_media` | Find missing, unused, or duplicated media before an edit or export. |
| `get_clip_properties` / `get_clip_speed` / `get_clip_at_position` / `get_clip_at_playhead` | Inspect clip framing, speed, and timeline position. |
| `get_premiere_state` / `get_version_info` / `ping` | Read a broad host state, Premiere version, or bridge health. |
### Projects, media, and bins
| Tools | What they do |
| :--- | :--- |
| `create_project` / `open_project` / `save_project` / `save_project_as` / `close_project` | Project lifecycle and file operations. |
| `import_media` / `import_folder` / `import_image_sequence` | Bring video, audio, stills, or image sequences into the project. |
| `import_fcp_xml` / `import_sequences_from_project` / `import_sequences` | Import supported timeline interchange or sequences from another project. |
| `create_bin` / `rename_bin` / `delete_bin` / `create_smart_bin` | Create and organize project-panel bins. |
| `move_item_to_bin` / `move_items_to_bin` / `rename_project_item` / `rename_clip` | Organize and rename existing project items. |
| `delete_project_item` / `delete_multiple_project_items` | Remove project items explicitly. These are destructive operations. |
| `create_subclip` / `refresh_media` / `relink_media` / `replace_clip_media` | Create source ranges, refresh media, relink missing files, or replace clip media. |
| `get_metadata` / `set_metadata` / `get_xmp_metadata` / `set_xmp_metadata` | Read and write project metadata and XMP fields. |
| `get_footage_interpretation` / `set_footage_interpretation` | Inspect or change footage frame-rate and pixel-aspect interpretation. |
| `set_color_label` / `get_color_label` / `set_project_panel_metadata` | Label and annotate project-panel items. |
### Sequences and tracks
| Tools | What they do |
| :--- | :--- |
| `create_sequence` / `create_sequence_from_preset` | Make an empty sequence from an installed `.sqpreset` without triggering Premiere's New Sequence dialog. |
| `create_sequence_from_clips` | Derive a sequence from pre-imported media when the clip settings should define the sequence. |
| `duplicate_sequence` | Copy a sequence; `clearContents: true` makes an empty reusable template with the source settings. |
| `delete_sequence` / `close_sequence` / `set_active_sequence` | Manage which sequence is open or active. |
| `create_recovery_checkpoint` / `list_recovery_checkpoints` / `restore_recovery_checkpoint` | Snapshot a sequence (as a reserved-name clone) before a risky edit, list snapshots, and restore one. The auto-checkpoint before destructive edits fails **closed** — if the snapshot cannot be taken, the destructive edit is refused rather than run unprotected. |
| `get_sequence_structure` / `get_sequence_count` | Inspect a sequence layout or count project sequences. |
| `set_sequence_settings` / `set_sequence_frame_rate` / `set_sequence_resolution` | Change supported sequence settings. Verify results because Premiere can quantize or reject changes. |
| `set_sequence_audio_settings` / `set_sequence_pixel_aspect_ratio` / `set_sequence_field_type` | Adjust supported audio, pixel-aspect, and field settings. |
| `add_track` / `add_tracks` / `delete_track` / `rename_track` | Create, remove, and name audio/video tracks. Caption-track deletion returns an explicit unsupported result. |
| `lock_track` / `toggle_track_visibility` / `set_target_track` / `set_all_tracks_targeted` | Control edit protection, visibility, and track targeting. |
| `get_track_info` / `get_target_tracks` / `get_sequence_in_out_points` | Inspect tracks, targeting, and sequence in/out ranges. |
### Timeline editing and trim operations
| Tools | What they do |
| :--- | :--- |
| `add_to_timeline` / `add_to_timeline_batch` | Place one or many project clips with per-clip source ranges and link-audio control. Batch placement returns per-clip results. |
| `insert_from_source` / `overwrite_from_source` / `overwrite_clip` | Perform three-point insert or overwrite editing from the Source monitor. |
| `remove_from_timeline` / `remove_selected_clips` / `ripple_delete` | Remove timeline clips. Ripple deletion closes the gap when the host supports it. |
| `move_clip` / `move_clip_to_track` / `set_clip_start_time` | Reposition a clip in time or on another track. |
| `split_clip` / `razor_timeline_at_time` / `razor_all_tracks` | Cut one clip or multiple tracks at a requested timeline point. |
| `trim_clip` / `roll_edit` / `slide_edit` / `slip_edit` | Adjust edit points and clip content timing. Structural QE edits are read back rather than trusted blindly. |
| `lift_selection` / `extract_selection` / `nest_clips` / `unnest_sequence` | Lift/extract a selected range or create/remove nests. |
| `duplicate_clip` / `replace_clip` / `enable_disable_clip` / `freeze_frame` | Duplicate, replace, enable, or freeze timeline material. |
| `speed_change` / `bake_speed_change` | Change clip speed/duration. `bake_speed_change` renders a true constant-speed clip on disk with ffmpeg where the host cannot honor a scripted remap, then verifies the output. |
| `link_audio_video` / `link_selection` / `unlink_selection` / `get_linked_items` | Manage audio/video link relationships. |
| `undo` / `redo` / `multiple_undo` | Revert or reapply recent Premiere operations. |
### Effects, color, motion, and keyframes
| Tools | What they do |
| :--- | :--- |
| `list_available_effects` / `list_clip_effects` / `get_effect_properties` | Discover installed effects, applied effects, and their properties. |
| `apply_effect` / `remove_effect` / `remove_effect_by_name` / `remove_all_effects` | Add or remove visual/audio effect components. `apply_effect` identifies and reads back the new component, reports its `matchName`, and accepts an optional `expectedMatchName` identity guard. Removal goes through QE `removeEffects()` (the only working path) and verifies by diffing the component list: it is all-or-nothing, so `remove_effect` only succeeds when the target is the sole user effect, and both preserve intrinsic Motion/Opacity/Volume and Lumetri Color (reported in `preservedLumetri`). |
| `apply_video_effect` | Add a video effect and verify it by diffing the clip's components, reporting the `matchName` that actually landed. Because effects resolve by display name, a stock name like "Gaussian Blur" can silently resolve to a third-party plugin; pass `expected_match_name` to enforce identity and roll the add back (when safe) on a mismatch. |
| `batch_apply_effect` / `copy_effects_between_clips` / `copy_effect_values` | Apply or copy effect treatments across clips. |
| `set_effect_property` / `set_color_value` / `set_blend_mode` | Change supported effect parameters, color values, and blend modes. |
| `color_correct` / `apply_lut` / `stabilize_clip` | Apply basic correction, LUTs, or Warp Stabilizer. |
| `list_lumetri_presets` / `apply_lumetri_preset` | List every installed Lumetri color preset, then apply one to a video clip. `apply_lumetri_preset` verifies the grade landed (component gained or property values changed) rather than trusting the engine's always-true return. |
| `crop_clip` / `add_adjustment_layer` / `get_clip_adjustment_layer` | Crop a clip or use an adjustment layer for shared treatment. |
| `set_clip_properties` / `set_clip_properties_batch` | Set opacity, scale, rotation, and position with verified per-property output. |
| `set_clip_position` / `set_clip_scale` / `set_clip_rotation` / `set_clip_anchor_point` | Address individual Motion transform values. |
| `add_keyframe` / `get_keyframes` / `remove_keyframe` / `remove_keyframe_range` | Create, inspect, and remove parameter keyframes. |
| `set_keyframe_interpolation` / `get_value_at_time` | Set interpolation or query a parameter value at a given time. |
| `bake_keyframe_ease` | Animate a scalar parameter (opacity, scale, rotation, volume) along any of 30 Penner easings or a CSS cubic-bezier, baked as a dense run of value keyframes. Premiere exposes no way to read a keyframe's ease back, so the shape is baked into readable values and every written point is verified — a genuine eased move that cannot silently misland. |
### Audio, transitions, and captions
| Tools | What they do |
| :--- | :--- |
| `adjust_audio_levels` / `set_clip_volume` / `set_clip_pan` | Set clip gain, volume, or pan. |
| `add_audio_keyframes` / `setup_ducking` | Build volume automation or a full ducking curve from supplied windows. |
| `mute_track` / `apply_audio_effect` / `apply_audio_effect_to_all_clips` | Mute a track or apply audio processing to one or many clips. |
| `detect_silence` | Analyze a local media file with ffmpeg and return silence ranges. It does not edit the timeline. |
| `transcribe_to_srt` | Transcribe a media file's speech to an `.srt` with a local OpenAI Whisper install (Premiere has no speech-to-text API). Probes for the `whisper` CLI, returns install guidance if absent, and verifies the `.srt` was written before reporting its cue count. |
| `list_available_transitions` / `list_available_audio_transitions` | Discover installed transition names. |
| `add_transition` / `add_transition_to_clip` / `batch_add_transitions` | Add one or many transitions. Results distinguish verified changes from accepted-but-unverified host responses. |
| `create_caption_track` | Create a caption track from an imported subtitle project item, such as an SRT. Pair with `transcribe_to_srt` → `import_media` to caption a clip end to end. |
| `read_sequence_captions` | Reports scripting-visible caption data and explicitly flags that Premiere's DOM often cannot read existing caption text. |
| `read_srt` / `validate_srt` / `write_srt` | Read, QC, and write `.srt` subtitle files on disk. Because Premiere's DOM often cannot read caption text back, editing the `.srt` before ingest is the honest caption path. |
| `update_srt_cue` / `insert_srt_cue` / `remove_srt_cue` / `shift_srt_timing` | Full cue-level CRUD and bulk timing shifts on an `.srt`, verified against the re-read file. |
### Markers, selection, navigation, and playback
| Tools | What they do |
| :--- | :--- |
| `add_marker` / `update_marker` / `delete_marker` / `list_markers` | Create and manage timeline markers. |
| `add_marker_to_project_item` / `get_clip_markers` / `get_sequence_markers_by_type` | Work with markers on project items, clips, or sequences. |
| `set_sequence_in_out_points` / `clear_sequence_in_out` / `set_work_area` / `get_work_area` | Set or inspect sequence in/out points and work area. |
| `get_playhead_position` / `set_playhead_position` / `get_next_edit_point` / `move_playhead_to_edit` | Inspect and navigate the CTI/playhead. |
| `get_selected_clips` / `select_clips_by_name` / `select_clips_in_range` | Inspect or create targeted timeline selections. |
| `select_all_clips` / `deselect_all_clips` / `select_disabled_clips` / `invert_selection` | Broader selection controls. |
| `open_in_source` / `close_source_monitor` / `set_source_in_out` / `clear_item_in_out` | Control Source monitor media and source in/out points. |
| `play_timeline` / `stop_playback` / `play_source_monitor` | Start or stop timeline and source playback. |
### Delivery, interchange, and media management
| Tools | What they do |
| :--- | :--- |
| `validate_project_for_export` / `get_encoder_presets` / `get_export_file_extension` | Validate a delivery, discover readable user `.epr` presets, and resolve output extensions. |
| `export_sequence` / `add_to_render_queue` | Queue a sequence through Adobe Media Encoder using a real preset path or exact preset name. |
| `get_render_queue_status` / `start_batch_encode` | Report queue-monitoring availability or start supported batch encoding. |
| `get_timeline_render_status` | Report the timeline's render-bar state (green rendered / yellow real-time / red drop-risk / empty), with timed segments, totals, and a rendered fraction. Reads the QE DOM and addresses the sequence by guid. Distinct from `get_render_queue_status` (Media Encoder). |
| `export_frame` / `capture_frame` | Write a still image from a sequence at a given time. Formats verified against Premiere's QE exporters: png, jpg/jpeg, tiff/tif, dpx, tga/targa. Hands Premiere the path stem so no double extension is written, and verifies the file landed on disk before reporting the real path. |
| `export_as_fcp_xml` / `export_aaf` / `export_omf` | Export supported interchange formats. |
| `encode_project_item` / `encode_file` / `export_as_project` | Encode a source item/file or export a project representation. |
| `manage_proxies` / `has_proxy` / `detach_proxy` | Inspect, attach, or detach proxies. |
| `set_offline` / `refresh_media` / `set_scale_to_frame_size` | Change offline status, refresh media, or apply frame-size scaling. |
| `consolidate_duplicates` / `consolidate_and_transfer` | Consolidate duplicate items or prepare a transfer workflow. |
| `probe_media` | Read ground-truth technical metadata from any file on disk with ffprobe — exact codec, pixel format, color space/range, bit depth, frame rate, sample rate, channel layout, duration — including files Premiere has not imported. Returns a distilled summary plus the full ffprobe JSON. |
| `generate_scope` | Render a signal scope (waveform, vectorscope, histogram, or RGB parade) from one frame to a PNG with ffmpeg, because Premiere's Lumetri scopes cannot be scripted or exported. Verifies the image was written before reporting success. |
### Graphics, workflows, workspace, and advanced operations
| Tools | What they do |
| :--- | :--- |
| `add_text_overlay` / `import_mogrt` / `import_mogrt_from_library` | Add a MOGRT and optionally populate supported text fields. |
| `get_mogrt_component` / `get_graphics_white_luminance` / `set_graphics_white_luminance` | Inspect Motion Graphics components and graphics white luminance. |
| `build_motion_graphics_demo` | Create a complete demo sequence with generated assets, dissolves, and subtle animation. |
| `assemble_product_spot` / `build_brand_spot_from_mogrt_and_assets` | Assemble real media into a directed product/brand edit with optional clip plans and MOGRT overlays. |
| `auto_reframe_sequence` / `detect_scene_edits` / `scene_edit_detection` | Use Premiere-assisted reframing or scene-change detection where the host supports it. |
| `get_workspaces` / `set_workspace` | Inspect and switch Premiere workspace layouts. |
| `create_bars_and_tone` / `set_transcode_on_ingest` / `set_scratch_disk_path` | Generate utility media or manage ingest and scratch-disk behavior. |
| `execute_extendscript` / `evaluate_expression` / `inspect_dom_object` | Advanced diagnostic and scripting operations. Use only with trusted inputs and explicit user intent. |
| `reflect_dom_object` | Enumerate the callable API surface of any DOM object via ExtendScript's `.reflect` interface — every method with its return type and argument names/types, plus properties — revealing native methods `inspect_dom_object` cannot see. Roots `qe.*` paths at the QE engine (auto-enabled). Read-only; pairs with `execute_extendscript` to discover a hidden capability and then drive it. |
### Project-file surgery (off by default)
A `.prproj` is a gzip'd XML document, so the server can read and edit a project on disk without Premiere running. That reaches state the scripting API does not expose — but it also means a bug corrupts a real cut, so the write side is opt-in and heavily guarded.
| Tools | What they do |
| :--- | :--- |
| `project_file_inspect` | Read-only. Reports format version, byte size, SHA-256, a structural census of nodes and `ObjectUID` definitions, optional literal string counts, and an optional XML excerpt. Needs no env flag. |
| `project_file_edit` | Applies exact literal replacements to a copy of a project. Requires `PREMIERE_MCP_ALLOW_PROJECT_FILE_SURGERY=1` in the server's environment. |
`project_file_edit` refuses rather than guesses, and each refusal returns a `code`:
- never writes in place — `outputPath` must be a new file, and the source is re-hashed afterwards to prove it was untouched
- refuses if the target's realpath is open in Premiere; if the bridge is down and Premiere may be running, it refuses with `OPEN_STATE_UNKNOWN` rather than assuming
- refuses an unrecognised `PremiereData Version`
- runs a per-file container canary (gunzip → gzip must reproduce the input byte-for-byte) before editing
- exactly-N matches or refuse — there is no replace-all, and every count is checked against the original document before any edit is applied
- refuses a bare `&` in a replacement (write `&`) and a raw `<`/`>` unless `allowMarkupEdit` is set
- checks the whole edited document for balanced angle brackets and valid entity references
- requires the structural census to be unchanged unless `allowCensusChange` is set, and reports the diff either way
- reports `premiereWillLoad: "unverified"`. XML validity is not acceptance; only opening the file proves that, so use `open_project` and read the result back
- `dryRun` returns the full report and the census diff without writing anything
Both tools are excluded from the `core` profile, so neither is advertised by default and neither is ever invoked as part of another tool. Reach them with `PREMIERE_MCP_PROFILE=all`, an explicit `PREMIERE_MCP_TOOLS` allowlist, or `call_tool`. The env flag gates the write side specifically: it is enforced inside `project_file_edit` rather than by the profile, because `call_tool` deliberately routes past a cost-shaped profile and an opt-in that a router can reach past is not an opt-in.
### Additional supported operations
The remaining catalog covers lower-level control of media properties, project settings, display formats, anti-aliasing, poster frames, color labels, selection, track targeting, project paths, and project counts. It includes `set_override_frame_rate`, `set_override_pixel_aspect_ratio`, `set_frame_blend`, `set_time_interpolation`, `set_poster_frame`, `set_anti_alias_quality`, `set_uniform_scale`, `set_scale_width_height`, `set_sequence_display_format`, `set_project_scratch_disk`, `get_project_scratch_disks`, `get_all_project_paths`, `get_total_clip_count`, `get_insertion_bin`, `is_work_area_enabled`, and `match_frame`.
Use MCP introspection in your client for each tool's exact input schema and return shape. An agent should inspect first, make a focused mutation, and read back the affected state before continuing a multi-step edit.
## Real Limits
- Premiere scripting still does not expose every UI operation cleanly.
- Professional title design still depends on real MOGRT assets or external graphics workflows.
- `get_render_queue_status` is only useful when Adobe Media Encoder integration is available.
- The best results come from real source footage, real audio, and real brand assets. The automation layer assembles and manipulates them; it does not replace editorial judgment.
- The bridge is signed with this project's own certificate. Premiere accepts it without developer mode, but it is not Adobe Marketplace approval, and macOS asks once before running the teammate installer.
## Troubleshooting
Run `npx -y premiere-mcp@latest doctor` first: each failing line names the problem and the fix.
- **"no heartbeat" / calls time out:** Premiere is not running, or was not restarted after setup. The bridge starts with Premiere; `Window > Extensions > MCP Bridge (CEP)` shows its status.
- **The AI app does not list the tools:** quit and reopen the app (it loads servers at start). In Claude Code, start a new session.
- **"Adobe's plugin installer was not found":** install Creative Cloud and Premiere Pro, then run `setup` again.
- **A call timed out but may have run:** ask for `get_recent_calls` before retrying an edit.
- **Something else:** open an issue with the `doctor` output.
## Developer Notes
Useful commands:
```bash
npm run build
npm test -- --runInBand
npm run setup:doctor
node scripts/live-tool-sweep.mjs
```
See:
- `QUICKSTART.md` for the shortest install path
- `KNOWN_ISSUES.md` for current limits
- `CONTRIBUTING.md` for development workflow
This server cannot be deployed
Maintenance
ActivityMaintained
ResponsivenessNo recent community issues