# Dakkshin/after-effects-mcp: remote control for After Effects through MCP

> An MIT-licensed MCP server that drives Adobe After Effects through ExtendScript, with a bridge panel polling a command queue. It installs via npm and works best for scripted composition and layer work, not for pixel-level editing.

**Dakkshin/after-effects-mcp** — MCP Server for Adobe After Effects. Enables remote control (compositions, text, shapes, solids, properties) via the Model Context Protocol using ExtendScript.

- Repository: https://github.com/Dakkshin/after-effects-mcp
- Stars: 674 · Forks: 128
- Language: JavaScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/dakkshin-after-effects-mcp

## What after-effects-mcp actually automates

After Effects has an automation story, but it is ExtendScript, and ExtendScript has to be driven from somewhere. This project puts a Model Context Protocol server in front of it, so an MCP client (the README names Claude and Cursor as examples) can send commands instead of a human clicking through the timeline. The scope is composition and layer construction: create a composition with a given width, height, frame rate and duration; add text, shape, solid, camera and null layers; change position, scale, rotation, opacity, blend mode, 3D flag and track matte; set keyframes and expressions; batch the same properties across several layers. The audience is motion graphics people who already think in scripts, and developers building assistants that manipulate a project file. It is not a renderer and not a compositor. If your job is trimming footage or grading, the tool list has nothing for you.

## The bridge panel and the polling command queue

The architecture is two processes and a folder of scripts. The Node server exposes MCP tools such as create-composition, run-script, get-results, setLayerKeyframe, setLayerExpression, setLayerProperties, batchSetLayerProperties, getLayerInfo, createCamera, createNullObject, duplicateLayer, deleteLayer and setLayerMask. On the After Effects side, install-bridge.js copies a panel into the AE installation, and the README tells you to open Window > mcp-bridge-auto.jsx. That panel checks for commands every few seconds and executes them when the Auto-run commands checkbox is on. So the data flow is: MCP client calls a tool, the server writes a command where the panel can find it, the panel runs ExtendScript inside AE, and results come back through get-results. The polling interval is the latency floor. This is not a push channel, and the README does not document a way to shorten that interval or subscribe to events. The generic run-script tool is the escape hatch for anything the named tools do not cover, which is also the honest admission that the tool list is a subset of what AE can do.

## Install and first composition

The README lists Adobe After Effects 2022 or later and Node.js v14 or later as prerequisites, with npm or yarn. Clone the repository, install, build, then copy the bridge scripts into your After Effects installation. Note that package.json also declares a postinstall script that runs the build, so the explicit build step is belt and braces.

```bash
git clone https://github.com/Dakkshin/after-effects-mcp.git
cd after-effects-mcp
npm install
npm run build
npm run install-bridge
```

After that, point your MCP client at the built server. The repository ships a .mcp.json you can copy; the only thing you must change is the path to build/index.js.

```json
{
  "mcpServers": {
    "AfterEffectsMCP": {
      "command": "node",
      "args": ["PATH/TO/after-effects-mcp/build/index.js"]
    }
  }
}
```

Start the server, open After Effects, and open the bridge panel from the Window menu. The README's first real use is a composition: the example calls the create_composition tool with a name, 1920 by 1080, frame rate 30 and duration 10.

```javascript
mcp_aftereffects_create_composition({
  name: "My Composition",
  width: 1920,
  height: 1080,
  frameRate: 30,
  duration: 10
});
```

What you should see is a new composition in the AE project panel with those settings. If nothing appears, the panel is the first thing to check: it must be open and the Auto-run commands checkbox enabled.

## Where the design gets in the way

Polling every few seconds means a chain of ten tool calls can take a noticeable amount of wall-clock time, and there is no documented batching at the transport level, only batchSetLayerProperties for layer properties specifically. The README is silent on error handling: if the bridge panel is closed, or Auto-run is off, or After Effects is not running, the documentation does not describe what the server returns. It also does not document rollback, undo grouping, or how a partially applied batch is reported. That matters because batchSetLayerProperties touches multiple layers, and a half-applied batch in a real project is worse than a failed one. Finally, run-script executes arbitrary JavaScript inside AE, which is exactly as powerful and as dangerous as it sounds; there is no sandbox described. Anyone wiring an AI assistant to this should treat run-script as the sharp tool in the drawer.

## How it compares to scripting AE directly

The obvious alternative is writing ExtendScript or an AE script directly and running it with File > Scripts > Run Script File. That approach has no Node process, no MCP client, no polling delay, and no dependency on a panel being open; it is the right choice for a repeatable render or export pipeline that runs on a schedule. The difference in approach is who supplies the intelligence. A plain script encodes the decisions at authoring time. after-effects-mcp moves the decisions to the MCP client, so the same server can be asked to build a title sequence one way today and a different way tomorrow. That flexibility is the whole product. It costs you a running server, a running AE, an open panel, and a few seconds of latency per step. If your automation is fixed, the plain script wins on every axis except convenience of authoring.

## Maintenance, licence and the version question

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive arrangement and it is not legal advice; check the LICENSE file for the exact text. On maintenance, the last push was on 2026-04-01, which is more than six months before today's date, so treat this as a project without recent activity rather than one under active development. The README documents no release history and no changelog, so there is no upgrade path to read. Practically, upgrading means pulling the branch and rerunning npm install, npm run build and npm run install-bridge, because the bridge scripts are copied into the After Effects installation and will otherwise go stale against the server. That copy step is also the main source of version drift: if Adobe changes the panel location or the ExtendScript API in a future AE release, the install script is where it will break first.

## Conclusion

Adopt it if you already script After Effects or want an AI assistant to build compositions, text, shape and solid layers, keyframes and expressions through the MCP tool list, and you accept running the bridge panel inside AE. Skip it if you need frame-accurate rendering pipelines, headless operation, or anything the tool table does not cover; the README documents no render tool. Before you wire it into a real project, verify that npm run install-bridge copies the panel into your specific AE version, that the Auto-run commands checkbox is enabled, and that your client launches build/index.js from the path you configured.

## FAQ

### Is there an after-effects-mcp for controlling After Effects?

Yes. Dakkshin/after-effects-mcp is an MIT-licensed MCP server that controls Adobe After Effects through ExtendScript, with a bridge panel opened from Window > mcp-bridge-auto.jsx that polls for commands every few seconds.

### Does Adobe support MCP?

The README does not describe any official Adobe MCP support. This project is a third-party server that copies its own bridge scripts into the After Effects installation via npm run install-bridge.

### What is MCP in after-effects-mcp?

MCP is the Model Context Protocol. In this project it is the interface an AI assistant or another application uses to call tools such as create-composition, setLayerProperties and setLayerKeyframe, which the server relays to After Effects.

## Sources

- [Dakkshin/after-effects-mcp on GitHub](https://github.com/Dakkshin/after-effects-mcp)
- [Issues](https://github.com/Dakkshin/after-effects-mcp/issues)
- [License: MIT](https://github.com/Dakkshin/after-effects-mcp/blob/main/LICENSE)
- [README](https://github.com/Dakkshin/after-effects-mcp/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/dakkshin-after-effects-mcp