Morpha MCP server

Morpha runs a Model Context Protocol server at https://morphareels.ai/mcp. Point any MCP client at it and the editor's full tool catalog appears as callable tools: create a project, add clips and text and shapes, animate them on a 30 fps keyframe timeline, caption a clip from its audio, then read the whole layer tree back.

The distinction that matters when you are choosing one: this is a video editor you drive, not a text-to-video generator. Nothing here invents footage. You compose layers, and every call mutates a real project that persists, so an agent can work on the same project across sessions and a person can open it in the browser at any point and carry on by hand. That also means a mistake is visible and fixable rather than a re-roll.

Connect

Claude Code, in one command:

claude mcp add --transport http morpha https://morphareels.ai/mcp

Any other client: point it at the same URL over HTTP. That is the whole configuration.

https://morphareels.ai/mcp

Every tool call needs a signed-in connection, so the next step is to sign the client in. A tool call that carries no key gets a 401 with the standard MCP authentication challenge:

WWW-Authenticate: Bearer resource_metadata="https://morphareels.ai/.well-known/oauth-protected-resource"

A client that follows that discovery flow has you sign in, or create a free account on the spot, and receives its own key, so you never see or paste one. In Claude Code you sign in from the /mcp menu, and you do it before the agent calls a tool: Claude Code answers the 401 by disconnecting the server until you sign in. You can also skip sign-in and give Claude Code a key you minted yourself:

claude mcp add --transport http morpha https://morphareels.ai/mcp --header "Authorization: Bearer mp_…"

An agent with no person to sign in creates an anonymous account over HTTP or the SDK instead, as the next section describes.

Authentication

Discovery needs no key. initialize and tools/list answer without credentials, so a client can show you the catalog before you commit to anything, and registries can index it. Both answers are the same whatever the request carries, so a client that lists the tools before it signs in holds the same catalog and instructions a signed-in connection gets.

Calling a tool needs an account. A signed-in client sends its key on every request:

Authorization: Bearer mp_…

Keys are free with any account and there is no paid tier gate on MCP access. There are three ways to get one:

A request with no account behind it answers 402 with a sign-in link rather than a bare refusal.

The loop

Read before you write. Two tools do the reading:

  1. list_projects() gives { id, name, editorUrl }. The id is what every other tool's projectId takes. Refer to a project by its name when you talk to a person; the ids are opaque and are never shown in the product.
  2. describe_video(projectId) gives the layer tree. Take every element id from there and never invent one. inspect_layers([elementId]) fills in detail for the few layers you are about to change.

Then mutate, and close the change with save_version(projectId, "short label") so there is a point to come back to.

End with the editor link. Every create_project, open_project and list_projects result carries an editorUrl. If the person signed in through your client, the project is already theirs: tell them to open that link and choose Share, then Download (Render MP4 on a phone), which is free, with no watermark and nothing to install, and that they can adjust anything by hand first. If you are working in an anonymous account, those results also carry a claimUrl. Give them that instead: they sign in or sign up, the project moves into their own account, and they choose Share, then Download (Render MP4 on a phone) there.

Two conventions that catch people out: coordinates are centre-anchored canvas pixels, not top-left, and time is frames at 30 fps, not seconds. Common mistakes covers the rest of the list.

What each tool says about itself

Every tool in tools/list carries a title and the MCP behaviour annotations: readOnlyHint (reads and never writes, so a client need not confirm it), destructiveHint (may overwrite or delete data that already exists, or spend credit as render_video does; false for tools that only add a layer, page, project or workspace, and for select_page), and openWorldHint (reaches hosts outside Morpha: the URL uploads, a custom font's URL, the server render, and the embed allowlist that decides which websites may load a project). add_keyframe, add_keyframes, add_color_keyframe and add_speed_keyframe are destructive although their names start with "add": each one replaces a keyframe already at the frame it is given. A client that confirms writes can use them to ask only when it matters; the app directories require them.

The server's connection instructions and every tool description fit in 2,048 characters, because Claude Code shows a model no more than that of either.

What is in the catalog

The same catalog the SDK and the HTTP API call, and the same one the editor's own prompt panel uses. Broadly:

The tool reference has every tool with its signature and a worked example; worked examples has end-to-end sessions.

What MCP cannot do

Four capabilities run on the caller's own machine, so they live in the npm SDK rather than on this server. Three need a real browser:

Exporting an MP4 is the exception, and it has a server route. client.renderVideo(projectId) still runs the encode in your own browser, free and at any length, on macOS or Windows. An agent that has no browser to drive can instead call `render_video` here, which renders on Morpha's own container and hands back a download link through `render_status`. That one is a subscription feature and is charged to the subscription's credits, because it spends Morpha's compute rather than yours.

The fourth, searching a public image pool (client.findPublicImage), needs no browser but runs on your side on purpose: the Openverse quota it spends is yours, not one shared by every Morpha user through the server. The editor's own prompt panel searches the same way, from the browser. From a chat connector, pass upload_image a direct image file URL, such as one the person has given you. An agent with a shell can also send a file from the caller's own disk: `create_upload_link` returns a signed link and the curl line that PUTs the file to it.

Every upload, over MCP or the SDK, returns { filename, name }. Morpha names each stored file itself: filename is an opaque id to pass to the layer tools exactly as returned and never show to the person, and name is what people see. Uploading under a name that was used before adds a second file rather than replacing the first.

Everything else is identical between the two. A common shape is an MCP client for the editing conversation and the SDK in a script for the render at the end.

When to use which surface

Morpha — AI video editor for short-form social video. Open the editor · Docs home