Skip to main content
Glama
MCP Bridge for Adobe Premiere Pro

MCP Bridge for Adobe Premiere Pro

by skrfilms

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: MIT Node.js MCP npm CEP UXP

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 has the exact steps.

Install | Claude Desktop | Other AI apps | Verify | Privacy Policy | Terms of Service | Security

⭐ 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 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:

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

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 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:

{
  "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

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 MCP Bridge (CEP) panel

Current CEP panel UI inside Premiere Pro, using the refreshed bridge controls and status layout.

Related MCP server: Premiere Pro MCP

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:

npx skills add skrfilms/premiere-mcp --skill premiere-mcp

Or install directly from the skill path:

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 covers Windows, client-specific configuration and diagnostics. The short version is 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

+-----------+        +-----------+        +-----------+
|  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 &amp;) 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:

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

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      C
      maintenance
      Gives an AI client local control over Adobe Premiere Pro, letting it inspect footage frame-by-frame to find the best moments, assemble and trim edits on the timeline, render animated title cards, review its own work, and export the finished video. Vision and editing tools run entirely on the user's own computer, with nothing sent to the publisher.
      289
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables editing Adobe Premiere Pro projects and sequences from Claude Code through local pr_* tools, including media import, clip placement and properties, effects and LUT copying, frame/video export, and batched edit plans.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Lets AI agents drive a running Adobe Premiere Pro (~440 verified operations). Works with every UI language Adobe ships and sees the frame: draws Object Masks on what it sees (a click for a person, a lasso for a face; ⊕/⊖, tracking) and places speed keyframes on the timeline by sight. A large skills library, built for Generative Extend, Generative Media, Object Mask, Enhance Speech.
      4
      9
      796 npm
      Apache 2.0