Skip to content
Back to search

aftereffects-mcp

An MCP server that lets AI read, view and edit a live Adobe After Effects project — inspect comps, render frames, write keyframes and expressions, and build projects end to end. Works with Claude Code or any MCP client.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/solomondivyananth--aftereffects-mcp/badge.svg)](/listings/solomondivyananth--aftereffects-mcp)

HTML

<a href="/listings/solomondivyananth--aftereffects-mcp"><img src="/api/listings/solomondivyananth--aftereffects-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requires **After Effects 2022 (22.0)+** and **Node.js 18+**, on **macOS or Windows**. `ffmpeg` is optional but recommended: it powers motion review and contact sheets, and on Windows it also scales preview images (macOS uses the built-in `sips`).

**From npm:**

npx aftereffects-mcp-install       # installs the After Effects panel
claude mcp add after-effects -- npx -y aftereffects-mcp

**From source** (do this if you want to hack on it):

git clone https://github.com/solomondivyananth/aftereffects-mcp.git
cd aftereffects-mcp
./install.sh              # macOS: link the panel, enable unsigned extensions
install.cmd               # Windows: the same (a directory junction, no admin needed)

Then **relaunch After Effects** (`PlayerDebugMode` is read at launch) and open **Window ▸ Extensions ▸ AE MCP Bridge**. A green dot and `Listening on 127.0.0.1:7788` means it's ready.

| Command | | |---|---| | `./install.sh` · `install.cmd` | linked install: edits in the repo are live | | `./install.sh --copy` · `install.cmd --copy` | real copy, for when AE won't follow the link (re-run after edits) | | `./install.sh --global` | macOS: also register the MCP server for every directory | | `node bin/install-panel.js --uninstall` | remove the panel (either platform) |

Where it goes: `~/Library/Application Support/Adobe/CEP/extensions` on macOS, `%APPDATA%\Adobe\CEP\extensions` on Windows. Unsigned panels are enabled with `PlayerDebugMode` (macOS `defaults`, Windows `HKCU\Software\Adobe\CSXS.*`).

The included `.mcp.json` registers the server for this project directory, so Claude Code picks the tools up automatically when run from the repo.

Optional: notes to tweaks with Jev

Give `ae_review_motion` a `note` in plain words ("the logo feels floaty and lands late") and it adds a **tweak plan** to the preview. Code reads every keyframe and describes each move in words. [Jev](https://docs.typesafe.ai), TypeSafe's System One model, judges which layer the note means, which tweaks it asks for (faster, firmer landing, less bounce, tighter stagger, earlier, longer hold, motion blur…) and how much. Code then turns confident answers into exact keyframe edits, returned as one `ae_batch`. When Jev is unsure, the plan asks which layer or which tweak instead of guessing. Nothing is applied until the agent runs the batch, and it is one undo step.

It needs a TypeSafe API key in the server's environment. Never put the key in `.mcp.json`, which is committed:

export TYPESAFE_API_KEY=…            # then start Claude Code from this shell
claude mcp add after-effects -e TYPESAFE_API_KEY=… -- npx -y aftereffects-mcp

Without a key, the note still comes back with every move described in words, for the agent to judge itself. `TYPESAFE_MODEL` pins a version (default `jev-latest`).

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 392 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # AE MCP Bridge: an After Effects MCP server for AI agents
  2. <a href="https://solomondivyananth.github.io/aftereffects-mcp/"><img src="docs/assets/welcome.gif" alt="AE MCP Bridge: After Effects meets AI. Read every layer, see every frame, edit live. 50 tools plus skills, in your timeline." width="100%"></a>
  3. <p align="center"><a href="https://solomondivyananth.github.io/aftereffects-mcp/"><b>Website</b></a> · <a href="docs/assets/welcome.mp4">Watch in HD</a> · <a href="#install">Install</a> · <a href="#tools">Tools</a></p>
  4. **Let an AI actually work in After Effects — read the project, look at rendered
  5. frames, and change keyframes, expressions and effects while the app is open.**
  6. Not a code generator that hands you a `.jsx` to run. A live connection to the
  7. running application: the model inspects your real comp, renders a real frame,
  8. makes a real edit, then re-renders to check its own work.
  9. ```
  10. MCP client ──stdio──► mcp/ae-mcp.js ──HTTP :7788──► CEP panel in AE ──evalScript──► AE DOM
  11. ```
  12. Works with [Claude Code](https://claude.com/claude-code) or any client that
  13. speaks the [Model Context Protocol](https://modelcontextprotocol.io). Nothing in
  14. the bridge is client-specific.
  15. MIT licensed · macOS and Windows · After Effects 2022+ · zero npm dependencies
  16. > Not affiliated with or endorsed by Adobe or Anthropic.
  17. ---
  18. ## What this makes possible
  19. **Read a project you didn't build.** Ask what's animating in a 40-layer comp and
  20. get an answer grounded in the actual property tree — keyframe times, ease
  21. influences, expression source, effect parameters — rather than a guess from
  22. layer names.
  23. **Let the model see.** `saveFrameToPng` renders come back as images. The model
  24. looks at the frame instead of reasoning blind about coordinates. Ask "is the
  25. logo colliding with the lower third at 4 seconds?" and it can check.
  26. **Edit with a real undo story.** Every call runs inside one
  27. `beginUndoGroup`/`endUndoGroup`. Anything the model does is a single ⌘Z (Ctrl+Z on Windows). There
  28. is no half-applied state to clean up.
  29. **Judge motion, not just numbers.** `ae_review_motion` samples a time range,
  30. stitches an MP4, and returns a contact sheet — so timing and easing can be
  31. evaluated as motion rather than as keyframe values that merely look correct.
  32. **Build, not just tweak.** Create projects and comps, import footage, add and
  33. animate layers, precompose, duplicate a master into 9×16 / 1×1 / 16×9, and queue
  34. a background `aerender` job that doesn't freeze the app.
  35. ### Things it is genuinely good at
  36. - Auditing a comp: what animates, where, driven by what
  37. - Motion graphics automation — applying one consistent change across many layers,
  38. many comps, or a whole campaign of format variants
  39. - Format variants from a finished master
  40. - Expression authoring, with After Effects validating the syntax on write
  41. - Catching continuity mistakes by looking at frames, not just properties
  42. ### Things it is not good at
  43. - Taste. It can match an existing ease curve; it cannot tell you the ad is boring.
  44. - Anything unscriptable — Roto Brush, Content-Aware Fill, mocha tracking, puppet
  45. pins. The ExtendScript DOM barely reaches these.
  46. - Real-time playback. It sees sampled frames, never a live preview.
  47. ---
  48. ## Install
  49. Requires **After Effects 2022 (22.0)+** and **Node.js 18+**, on **macOS or
  50. Windows**. `ffmpeg` is optional but recommended: it powers motion review and
  51. contact sheets, and on Windows it also scales preview images (macOS uses the
  52. built-in `sips`).
  53. **From npm:**
  54. ```bash
  55. npx aftereffects-mcp-install # installs the After Effects panel
  56. claude mcp add after-effects -- npx -y aftereffects-mcp
  57. ```
  58. **From source** (do this if you want to hack on it):
  59. ```bash
  60. git clone https://github.com/solomondivyananth/aftereffects-mcp.git
  61. cd aftereffects-mcp
  62. ./install.sh # macOS: link the panel, enable unsigned extensions
  63. install.cmd # Windows: the same (a directory junction, no admin needed)
  64. ```
  65. Then **relaunch After Effects** (`PlayerDebugMode` is read at launch) and open
  66. **Window ▸ Extensions ▸ AE MCP Bridge**. A green dot and
  67. `Listening on 127.0.0.1:7788` means it's ready.
  68. | Command | |
  69. |---|---|
  70. | `./install.sh` · `install.cmd` | linked install: edits in the repo are live |
  71. | `./install.sh --copy` · `install.cmd --copy` | real copy, for when AE won't follow the link (re-run after edits) |
  72. | `./install.sh --global` | macOS: also register the MCP server for every directory |
  73. | `node bin/install-panel.js --uninstall` | remove the panel (either platform) |
  74. Where it goes: `~/Library/Application Support/Adobe/CEP/extensions` on macOS,
  75. `%APPDATA%\Adobe\CEP\extensions` on Windows. Unsigned panels are enabled with
  76. `PlayerDebugMode` (macOS `defaults`, Windows `HKCU\Software\Adobe\CSXS.*`).
  77. The included `.mcp.json` registers the server for this project directory, so
  78. Claude Code picks the tools up automatically when run from the repo.
  79. ### Optional: notes to tweaks with Jev
  80. Give `ae_review_motion` a `note` in plain words ("the logo feels floaty and
  81. lands late") and it adds a **tweak plan** to the preview. Code reads every
  82. keyframe and describes each move in words. [Jev](https://docs.typesafe.ai),
  83. TypeSafe's System One model, judges which layer the note means, which
  84. tweaks it asks for (faster, firmer landing, less bounce, tighter stagger,
  85. earlier, longer hold, motion blur…) and how much. Code then turns confident
  86. answers into exact keyframe edits, returned as one `ae_batch`. When Jev is
  87. unsure, the plan asks which layer or which tweak instead of guessing.
  88. Nothing is applied until the agent runs the batch, and it is one undo step.
  89. It needs a TypeSafe API key in the server's environment. Never put the key
  90. in `.mcp.json`, which is committed:
  91. ```bash
  92. export TYPESAFE_API_KEY=… # then start Claude Code from this shell
  93. claude mcp add after-effects -e TYPESAFE_API_KEY=… -- npx -y aftereffects-mcp
  94. ```
  95. Without a key, the note still comes back with every move described in
  96. words, for the agent to judge itself. `TYPESAFE_MODEL` pins a version
  97. (default `jev-latest`).
  98. ---
  99. ## Safety
  100. This bridge executes arbitrary ExtendScript inside After Effects. That is
  101. powerful and worth being deliberate about, so two independent protections ship
  102. switched on.
  103. ### The sandbox guard
  104. Reads and renders work on whatever project is open. **Writes are refused unless
  105. the open project is the one you designated as the sandbox.** Only a human can
  106. change that, from the panel UI — there is deliberately no tool that unlocks it,
  107. so a model working through these tools cannot talk its way past the guard.
  108. (It is not a sandbox against an agent that already controls your desktop — one
  109. with shell or Accessibility access can untick the box just as you would. See
  110. [SECURITY.md](SECURITY.md).)
  111. Project-level operations (`ae_new_project`, `ae_open_project`) are refused
  112. outright while the guard is on: they close the current project, and a path
  113. comparison cannot make that safe. They also refuse to run unless you say
  114. explicitly what happens to unsaved work — no silent data loss, and never a modal
  115. dialog that would deadlock the bridge.
  116. ### Raw scripting switch
  117. `ae_run_jsx` and `ae_menu_command` can do anything the app can, including
  118. things the guard cannot see coming (a script can open another project). The
  119. panel's **Allow raw ExtendScript and menu commands** switch turns both off; the
  120. dedicated tools still work. With the guard on, the panel also checks whether a
  121. raw call changed the open project and flags it loudly if it did.
  122. ### Network protection
  123. The server binds loopback only and requires a 256-bit token, generated on first
  124. run into `~/.ae-mcp-bridge.json` (mode `0600`). It also refuses any request
  125. carrying an `Origin` or `Referer` header, and requires
  126. `Content-Type: application/json`.
  127. Those three checks close three different routes to the same hole. Without them,
  128. **any web page you happened to be visiting could drive After Effects** — a
  129. cross-origin POST with `Content-Type: text/plain` is a CORS "simple request", so
  130. the browser sends it with no preflight. The attacker can't read the response,
  131. but by then the code has already run. See [SECURITY.md](SECURITY.md).
  132. The server makes one kind of outbound call, and only when you opt in: with
  133. `TYPESAFE_API_KEY` set, `ae_review_motion` with a `note` sends that note,
  134. plus the animated layers' names and a description of their moves in words,
  135. to `api.typesafe.ai`. No frames, footage or project file leave the machine.
  136. ---
  137. ## Tools
  138. 50 tools, named and shaped after After Effects itself.
  139. **Read** — `ae_project_info` · `ae_comp_tree` · `ae_layer_detail` ·
  140. `ae_find_animation` · `ae_selection` · `ae_list_items` · `ae_catalog`
  141. (effects, presets, fonts, render templates)
  142. **See & show** — `ae_render_frame` · `ae_review_motion` · `ae_goto`
  143. **Proof-read** — `ae_proof` (41 checks: overlaps, clipped edges, jitter,
  144. pops, off-grid keys, unreadable text, missing motion blur, switches left on,
  145. and staging: no focal point, no scale contrast, an unused frame)
  146. **Animate** — `ae_set_property` · `ae_add_keyframes` · `ae_edit_keyframes` ·
  147. `ae_set_expression` · `ae_clear_expression` · `ae_apply_effect` ·
  148. `ae_apply_preset` · `ae_text` · `ae_markers` · `ae_masks` · `ae_shape` ·
  149. `ae_add_property` · `ae_remove_property` · `ae_property_meta`
  150. **Layers** — `ae_create_layer` · `ae_delete_layer` · `ae_set_layer_props` ·
  151. `ae_layer_action` (duplicate, split, sequence, freeze frame, align, fit,
  152. centre anchor, copy to comp)
  153. **Project** — `ae_create_comp` · `ae_set_comp_settings` · `ae_duplicate_comp` ·
  154. `ae_precompose` · `ae_import_file` · `ae_item_action` · `ae_essential_graphics` · `ae_delete_item` ·
  155. `ae_new_project` · `ae_open_project` · `ae_save_project`
  156. **Render** — `ae_render_video` · `ae_render_status` · `ae_render_cancel` ·
  157. `ae_render_queue` (Render Queue panel and Media Encoder)
  158. **Templates** — `ae_template` · `ae_welcome`
  159. **Control** — `ae_undo` · `ae_batch` · `ae_menu_command` · `ae_run_jsx`
  160. ### AI-native templates
  161. Finished, animated designs an agent fills from a brief: a lower third, a
  162. kinetic stomp title, a soft word reveal, an app/UI card in 3D, an animated bar
  163. chart, a logo sting, and the bridge's own welcome. Each is a JSON recipe in
  164. `templates/` with typed slots (text with length limits, colours, lists,
  165. options). `ae_template` builds one in 16:9, 9:16, 1:1 or 4:5 as a single undo
  166. step, rolls back on any failure, and returns a contact sheet. Builds come
  167. with a Controls layer and Essential Graphics controls for people to edit.
  168. `ae_welcome` builds the welcome, the quickest way to prove a new install
  169. works. `npm test` validates every template in every format.
  170. ### Skills
  171. Twenty-two skills ship in `skills/`. **Every MCP client gets them as prompts of
  172. the same name**, so they work in Claude Desktop, Codex, Cursor and the rest
  173. with no setup. Claude Code reads skills from a `.claude/skills` folder
  174. instead — run `npm run skills` in a clone to link them into this repo, or
  175. `npm run skills -- --user` to load them in every project on the machine.
  176. | Skill | What it teaches |
  177. |---|---|
  178. | `ae-mcp-bridge` | the tools: read → edit → look → proof, addressing, guard refusals |
  179. | `ae-motion-principles` | timing in frames, easing that reads, overshoot, stagger, stomp type |
  180. | `ae-expressions` | a cookbook of expressions, each one verified to compile in After Effects |
  181. | `ae-effects` | glows, noise, particles, glitch, and every kind of blur and motion blur |
  182. | `ae-transitions` | whips, punches, shape, mask, luma and effect wipes |
  183. | `ae-morph` | shape, mask, letter and gooey morphs that don't twist |
  184. | `ae-camera-3d` | camera rigs, depth of field, lights, shadows, renderers, 3D models |
  185. | `ae-typography` | text animators and selectors: word reveals, waves, scatter, typing, text on a ring |
  186. | `ae-ui-motion` | app and product-launch motion: layered UI in 3D, streaming answers, devices, logo moments |
  187. | `ae-color` | Lumetri grading, looks and LUTs without dialogs, brand tints, matching shots |
  188. | `ae-audio-sync` | beat finder (tempo, hits, grid) to comp markers, cutting and pulsing to music |
  189. | `ae-templates` | Controls nulls, Essential Graphics controls, `.mogrt` export, robust templates |
  190. | `ae-data-driven` | CSV/JSON as footage in expressions, charts, one version per row |
  191. | `ae-ai-templates` | fill the built-in templates from a brief, and write new ones |
  192. | `ae-composition` | staging a frame: one dominant element, scale hierarchy, using the whole frame, varying beats |
  193. | `ae-motion-proof` | screen a comp for overlaps, jitter, pops, unreadable text and under-staged beats |
  194. | `ae-vfx-cleanup` | removing wires, rigs, objects and signs from footage, checking keys, seating a subject in a plate, frozen-frame QA |
  195. | `ae-character-rig` | cut-out characters: joints, IK arms and legs, blinks, gaze, head turns, mouth poses, walk cycles |
  196. | `ae-localization` | language versions: word inventory, translation sheets, fonts for every script, refitting type |
  197. | `ae-deliver` | pre-flight, format variants with safe areas, renders, verifying the file |
  198. | `ae-reference-breakdown` | turn a reference film into a beat map and rebuildable techniques |
  199. | `video-reference-compare` | frame-by-frame comparison of a render against a reference |
  200. Effect, parameter and menu names in the skills were checked against a live
  201. After Effects.
  202. It speaks After Effects:
  203. - **Time** as seconds (`2.5`), frames (`"75f"`) or timecode (`"0:00:02:15"`).
  204. - **Easing** by name: `"easy"` is F9 Easy Ease, plus `"easy_in"`/`"easy_out"`.
  205. - **Colours** as `"#ff8800"` or 0–1 / 0–255 arrays.
  206. - **Many layers** in one call — `"selected"`, `"all"`, a list, or a name regex —
  207. as one undo step. `ae_batch` makes any sequence of calls one atomic step.
  208. - **Every write is one Edit ▸ Undo step**, labelled "MCP: Set Position" and so on,
  209. and writes that change a value return it **before and after**.
  210. - **Edits show up like hand edits**: the comp opens, the layers are selected,
  211. the playhead moves to the change. Switch it off in the panel.
  212. Property paths are arrays: `["Transform","Position"]`,
  213. `["Effects","Gaussian Blur","Blurriness"]`. Names or matchNames both work, and a
  214. wrong segment returns the list of valid children instead of a bare failure — so
  215. the model corrects itself rather than guessing.
  216. The server also exposes the usage guide as the MCP prompt `after-effects`, and
  217. the open project and current selection as resources (`ae://project`,
  218. `ae://selection`).
  219. ---
  220. ## Design notes
  221. Four things in the After Effects DOM will bite anyone building on it. They cost
  222. real debugging time here, so they're written down.
  223. **`elided` does not mean "ignore".** `PropertyBase.elided` marks a group that
  224. isn't drawn as its own row in the timeline — `Animators`, `Selectors`,
  225. `Properties` on a text layer are all elided. Their children are real, and are
  226. frequently where the animation lives. Skipping them made a typewriter-animated
  227. text layer report as "not animated", which produced a confidently wrong edit.
  228. Flatten elided groups; never skip them.
  229. **Transform is not where animation lives.** A layer can be fully animated with an
  230. empty Transform group — text animators, shape trim paths, mask paths and effect
  231. parameters all animate independently. `ae_comp_tree` returns `animatedProperties`
  232. from a full-tree scan for exactly this reason.
  233. **`saveFrameToPng` is asynchronous.** It returns roughly 450 ms before the PNG is
  234. on disk, and the file appears at size 0 first. Both sides of the bridge poll each
  235. frame until it exists and has stopped growing.
  236. **`Folder.temp` is a per-app sandbox.** Anything After Effects writes there is
  237. unreadable from outside the AE process. Frames go to `~/.ae-mcp-bridge/frames/`.
  238. And one that isn't about the DOM: **stills lie about motion.** A frame sampled
  239. mid-reveal is indistinguishable from a hard cut. That mistake is the reason
  240. `ae_review_motion` exists.
  241. ---
  242. ## Layout
  243. ```
  244. panel/ CEP extension loaded by After Effects
  245. CSXS/manifest.xml
  246. index.html status, sandbox controls, live call log
  247. js/main.js HTTP server, auth, guard enforcement, aerender jobs
  248. jsx/bridge.jsx everything touching the AE DOM (ExtendScript, ES3)
  249. mcp/ae-mcp.js MCP server — zero dependencies, stdio JSON-RPC
  250. scripts/ check.js (npm test), live tests (npm run test:live), record-welcome.js
  251. docs/ the website (GitHub Pages) and the welcome animation
  252. templates/ AI-native templates (JSON recipes built by ae_template)
  253. bin/install-panel.js panel installer for macOS and Windows
  254. install.sh · install.cmd wrappers for a linked install from source
  255. skills/ ae-mcp-bridge skill — teaches a model how to use the tools
  256. ```
  257. `bridge.jsx` is **ES3** — no `let`, `const`, arrow functions or native `JSON`
  258. (there's a polyfill at the top). Responses over 100 KB spill to a temp file,
  259. because `evalScript`'s return channel can't carry them.
  260. ---
  261. ## FAQ
  262. **What is this actually for?**
  263. Automating the repetitive half of motion graphics work — audits, bulk edits,
  264. format variants, expression authoring — while you keep the creative decisions.
  265. It is a scripting layer you talk to, not a replacement for a motion designer.
  266. **Does this need an API key?**
  267. No. The bridge holds no credentials. Your MCP client brings its own model.
  268. **Does it work with clients other than Claude Code?**
  269. Yes — it's a standard MCP stdio server. Nothing in it is Claude-specific.
  270. **Will it edit my project without asking?**
  271. Not unless you point the sandbox at that project, or switch the guard off. Reads
  272. and renders always work; writes are gated.
  273. **Can it render video?**
  274. Yes, via `aerender` as a background job that doesn't block the app. It saves the
  275. project first, because `aerender` reads the `.aep` from disk.
  276. **Does it work on Windows?**
  277. Yes. The installer, image scaling, `aerender` discovery and paths all handle
  278. Windows, and CI runs the checks on Windows and macOS. The live After Effects
  279. test suite has so far been run on macOS; reports from Windows users are welcome.
  280. **Why CEP and not UXP?**
  281. After Effects 2026 ships UXP, but it hosts only Adobe's own plugins — there's no
  282. public AE DOM API through it yet. CEP with ExtendScript is the only route to the
  283. full object model today.
  284. **Is the panel signed?**
  285. No. The installer enables `PlayerDebugMode`, which is how unsigned extensions load
  286. during development. Distributing to non-developers would need ZXP signing.
  287. ---
  288. ## Status
  289. **v0.1 — working, and honest about its edges.** The read, view and edit loop is
  290. proven against real production projects. The authoring and render tools are
  291. built and wired but have had less mileage. No tests or CI yet.
  292. Contributions welcome, particularly Windows test reports and ZXP packaging.
  293. ## License
  294. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.