Skip to main content
Glama
Sign In
adobe-premiere-cc-mcp

adobe-premiere-cc-mcp

by MarvelCollin
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Local

adobe-premiere-cc-mcp

CI npm License: MIT Premiere Pro 26.2

An MCP server for driving Adobe Premiere Pro from an AI assistant. Inspect a project, cut and arrange a timeline, grade by measurement rather than by eye, mix and normalise audio to a real loudness target, and export frames or finished video.

The design rule is one tool per expert capability, not one per API call. analyse_clips renders each shot and measures it; it does not expose getClipScale and leave the thinking to you. The expertise lives inside the tool, which is why the surface stays small while the capability grows.

The second rule is that every write verifies itself. A tool reads the value back, and the ones that cannot be checked say so rather than reporting a cheerful success. That matters because several Premiere scripting calls return "No Error" while doing nothing at all.

Built and verified against Premiere Pro 26.2 on Windows. Every tool listed below has been run against a real project, not just typechecked, including the destructive ones.

What makes it different

  • Measurement instead of guesswork. analyse_clips renders each clip, isolates it from the tracks above, and reports its black point, contrast and colour cast, so a grade follows numbers rather than a hunch. analyse_loudness renders the audio and measures true LUFS to ITU-R BS.1770, because Premiere exposes no loudness figure to a script at all.

  • Tools that admit failure. set_clip_speed reads the speed back off the clip and reports when Premiere clamped it. get_stabilizer_status says plainly that a clip was never analysed. export_sequence confirms the file exists before claiming success.

  • A verdict you can act on. critique_edit judges a sequence against published short form norms: what happens in the opening seconds, how often the picture changes, and whether the message survives muted playback.

  • Nothing borrowed. The CEP panel that carries commands into Premiere was written from the protocol for this project and is signed with its own certificate.

  • Capabilities, not wrappers. Other Premiere MCP servers ship several hundred to over a thousand tools, most of them one scripting call each, which leaves every expert decision to the model. Every tool's name, description and schema is also sent on every request, so a large surface is paid for before any work happens. These tools cost roughly 4,400 tokens of that budget and each one does a whole job.

Related MCP server: davinci-resolve-mcp

Documentation

  • Recipes — session start, grading, loudness, partial export, and a nine up grid built end to end.

  • Grading — how to read the measurements and choose a correction.

  • Contributing — the development loop and what a good change looks like.

  • Security — what this server can do to your machine, and the signing model.

  • Roadmap — what is done, what is blocked, and the Premiere limits found so far.

Paths may be passed with forward or backslashes; they are normalised before they reach Premiere, because exportAsMediaDirect fails with a bare Error: Unknown Error on forward slashes.

How it works

assistant  <--stdio-->  MCP server  <--temp files-->  CEP panel  <--evalScript-->  Premiere

The server writes cmd_<id>.jsx into a shared temp folder. The CEP panel inside Premiere claims it with an atomic rename, evaluates it, and writes res_<id>.json back. Anything slower than two seconds also gets a busy_<id>.json heartbeat, which is how the server tells "still working" apart from "the panel is not running".

Requirements

  • Node.js 20 or newer, tested on 20 and 22

  • Adobe Premiere Pro 2020 or newer

  • Adobe Media Encoder is not required; exports use Premiere's own encoder

Setup

npm install
npm run build
npm run sign-panel      # signs panel/ into artifacts/PremiereMcpLink.zxp
npm run install-panel   # installs it and sets PlayerDebugMode

Then restart Premiere. The panel starts itself when Premiere becomes active, so there is nothing to open by hand; Window > Extensions > Premiere MCP Link shows its status and log if you want to watch it.

Signing needs Adobe's ZXPSignCmd in tools/, from Adobe-CEP/CEP-Resources (ZXPSignCMD/4.1.103/win64). npm run sign-panel generates a self-signed certificate the first time. Premiere refuses unsigned extensions even with PlayerDebugMode enabled, so signing is not optional.

The server and panel meet in %TEMP%\premiere-mcp-link. Override it on both sides with PREMIERE_MCP_BRIDGE_DIR if you need to run two setups side by side.

Register it with your MCP client, for example:

{
  "mcpServers": {
    "premiere": {
      "command": "node",
      "args": ["C:/BINUS/SELF/adobe-premiere-cc-mcp/dist/index.js"]
    }
  }
}

Then ask the assistant to call ping.

Tools

64 tools.

Tool

Parameters

What it does

ping

—

Check that Premiere is running and the bridge panel is alive.

get_timeline

detail, track_type, track_index, empty_tracks

Picture of the active sequence: resolution, frame rate, duration, and every clip on every track with its node ID, timing and Motion scale.

get_clip

node_id

Everything about one clip: timing, in-point, and every effect with all of its property values and keyframe state.

list_sequences

—

List every sequence in the project and say which one is active.

set_active_sequence

sequence

Make a sequence the active one, so every other tool operates on it.

create_sequence_from_items

name, item_ids

Create a new sequence built from one or more project items, and confirm it exists.

check_edit

max_scale, max_audio_db

Inspect the whole sequence and report the problems that quietly ruin an edit: clips scaled above 100 percent, stabilisers that were never analysed, audio above unity or with keyframes that spike, disabled clips, gaps on the main video track, muted tracks, and clips missing a grade while their neighbours have one.

critique_edit

platform

Judge the active sequence against what actually holds attention on a given platform, and say whether it is ready to post.

review_sequence

output_dir, frames, start_seconds, end_seconds

One pass over a whole sequence for judging it rather than editing it: writes evenly spaced stills across the running time, measures each one, and reports the sequence settings alongside them.

contact_sheet

output_dir, track_index, limit, isolate

Export one still per clip on a video track, taken from the middle of each clip, and return the file paths.

analyse_frame

time_seconds

Measure the image at a point in the sequence and suggest Basic Correction moves.

analyse_clips

track_index, limit

Measure one frame per clip on a video track and report the numbers side by side, so shots can be grouped by how they actually look rather than by eye.

read_scopes

time_seconds

Read the video scopes at a point in the sequence, the way a colourist would.

match_shots

reference_node_id, target_node_ids, apply, max_passes

Match one clip's grade to another by measurement rather than by eye.

get_playhead

—

Current playhead position in the active sequence, in seconds and as timecode.

set_playhead

time_seconds

Move the playhead to a time in seconds and read the position back.

get_sequence_range

—

Read the sequence in and out points and the work area, the two ranges that decide what a partial export covers.

set_sequence_range

in_seconds, out_seconds

Set the sequence in and out points, then read them back.

set_track_state

track_type, track_index, muted

Mute or unmute a video or audio track and read the state back.

list_markers

—

List every marker on the active sequence with its time, name and comment.

add_marker

time_seconds, name, comment, duration_seconds

Add a marker to the active sequence at a given time, then confirm it exists.

delete_marker

time_seconds, tolerance_seconds

Delete the marker nearest a given time, within a small tolerance, and report how many remain.

detect_beats

range, timeout_ms

Find the tempo of the sequence audio and return the beat grid, without changing anything.

mark_beats

grid, offset_seconds, limit, range, timeout_ms

Write sequence markers on the beat grid so the cuts can be placed by eye or by tool.

cut_to_beats

track_index, grid, offset_seconds, limit, range, timeout_ms

Razor a video track on the beat grid, so every cut lands on the music.

make_split_edit

cut_seconds, type, overlap_seconds, video_track, audio_track

Turn a straight cut into a J or L cut, the technique that most separates professional cutting from amateur.

find_action_peaks

node_id, samples

Measure movement across a clip and report where the action peaks, so a cut can land on the movement rather than near it.

check_delivery

samples, start_seconds, end_seconds

Run the quality control pass a broadcaster would run before accepting a file.

check_audio

range, timeout_ms

Render the mix and find the audio faults that ruin a delivery: passages clipped into distortion, stretches of dead silence, and a noise floor high enough to hear.

duck_music

music_track_index, dialogue_track_indexes, duck_db, attack_seconds, hold_seconds, release_seconds, on_existing_keyframes, dry_run, timeout_ms

Pull a music bed down under the talking and let it back up in the gaps, the way a mixer rides a fader, instead of leaving one flat level for the whole timeline.

clean_dialogue

track_index, high_pass_hz, ratio, threshold_db, attack_ms, release_ms, compress, dry_run, timeout_ms

Put the standard dialogue chain on a voice track and prove it did something: a high pass to kill rumble, then compression to even out the level.

list_project_items

limit

List the project panel contents: bins and media, with the node ID of each.

import_media

file_paths, bin_name

Import one or more media files into the project panel and confirm the item count grew.

create_bin

name

Create a bin in the project panel and confirm it exists.

check_media

limit

Report the link state of every media item: whether it is offline, where its media actually lives on disk, and whether a proxy is attached.

attach_proxy

item_id, proxy_path

Attach a proxy file to a project item, so Premiere edits against the light version while keeping the original for export.

relink_media

item_id, new_path

Point an offline project item at its file in a new location and confirm it came back online.

set_clip_enabled

node_id, enabled

Enable or disable a clip.

split_clip

track_type, track_index, time_seconds

Cut every clip on a track at the given time, the same as the razor tool.

remove_clip

node_id, ripple

Remove a clip from the timeline.

add_to_timeline

item_id, track_type, track_index, time_seconds, mode

Place a project item onto a track at a given time and confirm the clip count grew.

move_clip

node_id, time_seconds, overwrite

Move a clip to a new start time on its own track and confirm it landed.

set_clip_speed

node_id, speed_percent

Change a clip's playback speed.

trim_clip

node_id, edge, time_seconds

Trim a clip's start or end on the timeline and confirm the new duration.

set_scale

node_id, scale

Set a clip's Motion scale and read it back to confirm.

grade_clips

node_ids, add_lumetri_if_missing, exposure, contrast, highlights, shadows, whites, blacks, saturation, temperature, tint, look_intensity

Apply the same Lumetri Basic Correction to a group of clips in one pass, then read every value back.

set_lumetri

node_id, exposure, contrast, highlights, shadows, whites, blacks, saturation, temperature, tint, look_intensity

Set Lumetri Basic Correction values on a clip and read them back.

match_grade

source_node_id, target_node_ids

Copy one clip's Lumetri Basic Correction onto other clips as a starting point, then read every value back.

get_grade

—

Read the Lumetri Basic Correction values of every graded clip in one call, so a grade can be compared across shots without inspecting clips one at a time.

set_audio_level

node_id, db

Set a clip's audio level in decibels and read it back.

normalise_loudness

target, track_index, range, allow_clipping, timeout_ms

Measure the sequence loudness and then actually move the audio to hit the target, in one pass.

analyse_loudness

target, range, timeout_ms

Measure how loud the sequence actually is, in LUFS to ITU-R BS.1770, by rendering its audio to a temporary WAV and analysing it here.

set_fade

node_id, fade_in_seconds, fade_out_seconds

Put a clean fade in and/or out on a clip: Opacity for video, Volume for audio.

list_effects

kind, filter

List every video or audio effect name Premiere can apply.

apply_effect

node_id, effect_name

Add a video or audio effect to a clip by name and confirm it attached.

list_transitions

filter

List every video transition name Premiere can apply, for use with add_transition.

add_transition

node_id, transition_name, at

Add a video transition at a clip's head or tail and confirm it appeared on the track.

get_stabilizer_status

—

Report Warp Stabilizer state for every clip that has it.

set_stabilizer_mode

node_id, mode, max_scale

Set Warp Stabilizer to 'no_motion' (locked static frame, what static-camera edits need) or 'smooth_motion' (keeps camera movement, smoothed).

export_frame

output_path, time_seconds

Write a full resolution still of the sequence at a given time.

list_export_presets

filter, limit

List Adobe .epr export presets on disk, including the ones Premiere ships itself.

export_sequence

output_path, preset_path, range, timeout_ms

Render the active sequence to a file using Premiere's own encoder; Adobe Media Encoder is not required.

save_project

—

Save the current project.

run_script

code, timeout_ms

Escape hatch: run raw ExtendScript in Premiere for anything the typed tools do not cover.

Premiere behaviours worth knowing

These cost real debugging time and are encoded in the tools:

  • getVideoEffectList() returns an array of name strings, not objects. Entries have no .name and the array has no .numItems. Effect objects must come from getVideoEffectByName().

  • Keyframe times are absolute source time. Stills and graphics sit near 3600s, so a keyframe written at 0.5 lands outside the clip and never fires.

  • New keyframes interleave with existing ones rather than replacing them, which is how a fade ends up spiking to full mid-clip. Clear before writing.

  • getKeys() returns undefined, not [], when a property has no keyframes.

  • Warp Stabilizer never re-analyses from a script. A clip can report the mode you set while being completely unstabilised. The tell is the auto-scale display name: a percentage means solved, a bare label means not analysed.

  • QE track item indexes count empty gaps, so they do not match DOM clip indexes. Match on start time.

  • Creative Looks cannot be set by script. The name property accepts a string but the LUT never loads. Pick looks in the Lumetri panel; only intensity is scriptable.

  • exportAsMediaDirect returns "No Error" even when it writes nothing, so the file has to be checked on disk.

Development

npm run dev      # tsc --watch
npm test         # vitest
npm run check    # typecheck + tests, no build
npm run build    # emit dist/
npm run verify   # run every tool against the open project

npm run verify covers the read-only tools. Add -- --destructive to also exercise splitting, removing, importing and speed changes; that edits the open project, so point it at a scratch one.

Testing against a live Premiere without restarting your assistant

An MCP client loads the server once at startup, so a rebuild does not reach it until the client restarts. npm run smoke skips the client entirely and drives the built server over stdio the same way:

npm run build
npm run smoke                                    # read-only sweep
npm run smoke -- --list                          # tool names
npm run smoke -- ping
npm run smoke -- get_clip '{"node_id":"000f4241"}'
npm run smoke -- export_frame '{"output_path":"C:/tmp/check.png","time_seconds":12}'

That is the fast loop: edit, npm run build, npm run smoke -- <tool>. Restart the assistant only when you want the new tools exposed to it.

License

MIT

Available Tools

41 tools
add_markerA

Add a marker to the active sequence at a given time, then confirm it exists. Handy for noting beats, cut points or review comments.

Inputs: time_seconds (required), name, comment, duration_seconds.

add_to_timelineA

Place a project item onto a track at a given time and confirm the clip count grew. Overwrite replaces whatever is already there; insert pushes later clips further down the track. Use list_project_items to get the item ID.

Inputs: item_id (required), track_index (required), time_seconds (required), mode, +1 more.

add_transitionA

Add a video transition at a clip's head or tail and confirm it appeared on the track. Note that a transition needs media beyond the cut to draw from; without handles Premiere may refuse or shorten it.

Inputs: node_id (required), at, transition_name.

apply_effectA

Add a video or audio effect to a clip by name and confirm it attached. Use list_effects for exact names.

Inputs: node_id (required), effect_name (required).

check_editA

Inspect the whole sequence and report the problems that quietly ruin an edit: clips scaled above 100 percent, stabilisers that were never analysed, audio above unity or with keyframes that spike, disabled clips, gaps on the main video track, muted tracks, and clips missing a grade while their neighbours have one. Read only, so it is always safe to run.

Inputs: max_scale, max_audio_db.

contact_sheetA

Export one still per clip on a video track, taken from the middle of each clip, and return the file paths. Read the images afterwards to judge a grade across the whole edit at once instead of one frame at a time. Slow, since every frame is a real render.

Inputs: output_dir (required), limit, track_index.

create_binA

Create a bin in the project panel and confirm it exists.

Inputs: name (required).

create_sequence_from_itemsA

Create a new sequence built from one or more project items, and confirm it exists. Premiere derives the settings from the first item, so this needs no preset and opens no dialog. Useful for making a scratch sequence to experiment in.

Inputs: name (required), item_ids (required).

delete_markerA

Delete the marker nearest a given time, within a small tolerance, and report how many remain. Deleting cannot be undone from here, so check list_markers first.

Inputs: time_seconds (required), tolerance_seconds.

export_frameA

Write a full resolution still of the sequence at a given time. Use this to actually look at your work after a grade or a reframe, instead of trusting a tool's success flag.

Inputs: output_path (required), time_seconds (required).

export_sequenceA

Render the active sequence to a file using Premiere's own encoder; Adobe Media Encoder is not required. Long running, so raise timeout_ms for big sequences. The output file is confirmed on disk before this reports success.

Inputs: output_path (required), preset_path (required), timeout_ms.

get_clipA

Everything about one clip: timing, in-point, and every effect with all of its property values and keyframe state. Read this before changing a clip so you know what you are overwriting.

Inputs: node_id (required).

get_gradeA

Read the Lumetri Basic Correction values of every graded clip in one call, so a grade can be compared across shots without inspecting clips one at a time.

Inputs: no named parameters.

get_playheadB

Current playhead position in the active sequence, in seconds and as timecode.

Inputs: no named parameters.

get_stabilizer_statusA

Report Warp Stabilizer state for every clip that has it. solved: false means the clip has NOT been analysed and is not actually stabilised, whatever its settings say. Always check this after changing stabiliser settings, because scripted changes do not trigger re-analysis.

Inputs: no named parameters.

get_timelineA

Full picture of the active sequence: resolution, frame rate, duration, and every clip on every track with its node ID, timing, effects and Motion scale. The best first call before editing anything.

Inputs: no named parameters.

grade_clipsA

Apply the same Lumetri Basic Correction to a group of clips in one pass, then read every value back. Grade shot groups that share a lighting condition together; a single correction across mixed lighting is what makes an edit look amateur. Reports per clip, so one failure does not hide the rest.

Inputs: node_ids (required), tint, blacks, whites, +8 more.

import_mediaA

Import one or more media files into the project panel and confirm the item count grew. Paths must be absolute.

Inputs: file_paths (required), bin_name.

list_effectsA

List every video or audio effect name Premiere can apply. Use this to get exact names for apply_effect.

Inputs: kind, filter.

list_export_presetsA

List Adobe .epr export presets on disk, including the ones Premiere ships itself. Adobe Media Encoder does not need to be installed. Pass the path of one to export_sequence.

Inputs: limit, filter.

list_markersA

List every marker on the active sequence with its time, name and comment.

Inputs: no named parameters.

list_project_itemsA

List the project panel contents: bins and media, with the node ID of each. Use this to find footage before adding it to a timeline.

Inputs: limit.

list_sequencesA

List every sequence in the project and say which one is active.

Inputs: no named parameters.

list_transitionsA

List every video transition name Premiere can apply, for use with add_transition.

Inputs: filter.

move_clipA

Move a clip to a new start time on its own track and confirm it landed. The move fails if another clip already occupies the destination.

Inputs: node_id (required), time_seconds (required).

pingA

Check that Premiere is running and the bridge panel is alive. Returns the Premiere version, project name and active sequence. Call this before anything else.

Inputs: no named parameters.

remove_clipA

Remove a clip from the timeline. Ripple closes the gap and shifts everything after it; lift leaves a gap. Destructive, so confirm the node ID with get_timeline first.

Inputs: node_id (required), ripple.

run_scriptA

Escape hatch: run raw ExtendScript in Premiere for anything the typed tools do not cover. ES3 only (var, no arrow functions, no template literals, no JSON object). End with return __result({...}) or return __error('...'). Helpers available: __seq, __qe, __findClip, __qeClipAt, __qeTrackFor, __component, __property, __componentNames, __clearKeys, __ticksToSeconds, __secondsToTicks.

Inputs: code (required), timeout_ms.

save_projectA

Save the current project. Nothing auto-saves, so call this after a batch of edits.

Inputs: no named parameters.

set_active_sequenceA

Make a sequence the active one, so every other tool operates on it. Match by name or sequence ID.

Inputs: sequence (required).

set_audio_levelA

Set a clip's audio level in decibels and read it back. 0 dB is unity and the practical ceiling; dialogue usually sits near -14 dB with a music bed under it around -26 dB. Any existing volume keyframes on the clip are cleared first, since they would otherwise override the level.

Inputs: db (required), node_id (required).

set_clip_enabledA

Enable or disable a clip. A disabled clip stays on the timeline but is skipped in playback and export, which makes it a safe way to try removing a shot.

Inputs: enabled (required), node_id (required).

set_clip_speedA

Change a clip's playback speed. 100 is normal, 50 is half speed and twice as long, 200 is double speed. Confirms the new duration.

Inputs: node_id (required), speed_percent (required).

set_fadeA

Put a clean fade in and/or out on a clip: Opacity for video, Volume for audio. Existing keyframes on that property are cleared first, because new keys interleave with old ones rather than replacing them, which is how envelopes end up spiking to full. Also handles the source-time offset that makes naive keyframes on stills and graphics silently never fire.

Inputs: node_id (required), fade_in_seconds, fade_out_seconds.

set_lumetriA

Set Lumetri Basic Correction values on a clip and read them back. Only the fields you pass change. The clip needs a Lumetri Color effect already; add one with apply_effect. Note that the creative Look itself cannot be set by script, only its intensity.

Inputs: node_id (required), tint, blacks, whites, +7 more.

set_playheadA

Move the playhead to a time in seconds and read the position back. Useful before export_frame, since that captures wherever the playhead lands.

Inputs: time_seconds (required).

set_scaleA

Set a clip's Motion scale and read it back to confirm. 100 means native pixels. Check the source resolution first: scaling above 100 on footage that already matches the sequence frame throws away real detail and cannot be recovered on export.

Inputs: scale (required), node_id (required).

set_stabilizer_modeA

Set Warp Stabilizer to 'no_motion' (locked static frame, what static-camera edits need) or 'smooth_motion' (keeps camera movement, smoothed). Premiere will NOT re-analyse from a script, so the response tells you whether the clip still needs Analyze clicked in Effect Controls.

Inputs: mode (required), node_id (required), max_scale.

set_track_stateA

Mute or unmute a video or audio track and read the state back. Muting a video track hides it from the program monitor and from exports.

Inputs: muted (required), track_type (required), track_index (required).

split_clipA

Cut every clip on a track at the given time, the same as the razor tool. Returns the new clip count so you can confirm the cut landed.

Inputs: track_index (required), time_seconds (required), track_type.

trim_clipA

Trim a clip's start or end on the timeline and confirm the new duration. Trimming the end shortens the tail; trimming the start moves the head later, leaving a gap.

Inputs: edge (required), node_id (required), time_seconds (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    A3.8/5.0

    Scored across 41 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, with detailed descriptions that prevent confusion. Even similar tools like get_clip vs get_timeline operate at different scopes (single clip vs whole sequence), and grade_clips vs set_lumetri target group vs individual clips. No two tools appear to do the same thing.

    Naming Consistency4/5

    The vast majority of tools follow a consistent verb_noun pattern (get_, set_, list_, create_, delete_, add_, etc.). Minor exceptions like 'ping' and 'contact_sheet' deviate from this pattern, but they are easily recognizable and do not significantly harm overall consistency.

    Tool Count2/5

    With 41 tools, the server is heavily overloaded. While Premiere is a complex application, this many tools in one MCP server makes it unwieldy and could benefit from being split into focused sub-servers (e.g., editing, effects, export). The number falls well beyond the 'too many' threshold of 25.

    Completeness4/5

    The tool set covers the core editing workflow well: project management, sequence handling, timeline operations, clip properties, effects, grading, markers, playhead, export, and saving. Minor gaps exist, such as no generic effect property setter (only specific ones like set_lumetri and set_scale) and limited transition editing, but run_script provides an escape hatch for these cases.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers