# MCP server: Your agent puts your brand on a template we designed.

One MCP server for the whole job: your agent finds the template that fits, writes your words, sets your logo, images and colors, looks at the result in each format and hands you a link where it plays live. The design is ours; the brand is yours.

Endpoint: `https://opusmotion.com/api/mcp` (Streamable HTTP · No key, no account · Tools, resources and prompts · Images back inside the answer).

See what an agent made: [a video an agent made over this server for a sample brand](https://opusmotion.com/editor/lovable-launch?demo=1), opened in the Pro editor.

## Connect your agent

The server lives at one URL and needs no key. Add it to your client, then ask your agent for a video.

**Claude Code.** In your terminal:

```
claude mcp add --transport http opus-motion https://opusmotion.com/api/mcp
```

**Codex.** In ~/.codex/config.toml:

```
[mcp_servers.opus-motion]
url = "https://opusmotion.com/api/mcp"
```

**Cursor.** In ~/.cursor/mcp.json:

```
{
  "mcpServers": {
    "opus-motion": {
      "url": "https://opusmotion.com/api/mcp"
    }
  }
}
```

**VS Code.** In .vscode/mcp.json:

```
{
  "servers": {
    "opus-motion": {
      "type": "http",
      "url": "https://opusmotion.com/api/mcp"
    }
  }
}
```

**Any client.** Add a remote (Streamable HTTP) server with this URL:

```
https://opusmotion.com/api/mcp
```

## How a video gets made

1. **Find** (`search_templates`, `list_pro_templates`): A catalog template takes fields; in a Pro template every text, image and color can change.
2. **Read** (`get_template`, `get_pro_template`): Its scenes or acts, every field or layer, what each is for and how long its text can be.
3. **Make** (`create_draft`, `create_pro_draft`): The person's words, images and colors. One call answers a draft and its edit key.
4. **Look** (`look_at_draft`, `look_at_pro_draft`): Stills or a contact sheet in each format, as images in the answer, with a layout check.
5. **Fix and hand over** (`update_draft`, `edit_pro_draft`): Change what reads badly, look again, then give the person the link. They export it.

## Every tool

What your agent can do, by area. Each tool describes its inputs to the agent; the same list is what tools/list answers.

### Find a template

Search the catalog of launch and promo templates and read everything one takes: its scenes, its fields and their limits.

- **`search_templates`** (reads): Search the Opus Motion catalog of promo and launch video templates. Returns each template's id, title, description, tier and price, length, formats and example brands. Use it to find a template for someone's launch, product or brand video. Pro templates (every layer editable) are listed by list_pro_templates. Inputs: `query`, `category`, `tier`, `format`.
- **`get_template`** (reads): Everything about one catalog template: description, tier and price, length, formats, its scenes (what each shows, when), every field it takes (texts with their limits, images with their shape, colors, choices, clips) and, when it has them, the safe adjustments (tweaks). With images: true, its timelapse (the whole video in one picture) comes back inside the answer. Inputs: `id`*, `images`.
- **`studio_link`** (reads): A link the person opens to see the template made with their brand: the studio reads their website (logo, colors, copy) and fills the template. Give it to the person; exporting needs their own account, and payment for premium templates. Inputs: `template`*, `site`, `format`.

### Make a draft from a template

Fill a catalog template with the person's texts, images, colors and clips. The person opens a link with the video playing live, and exports it there.

- **`join_studio_session`** (changes): The person has a template open in the Opus Motion studio and gave you its session code (OM-XXXX-XXXX). Join it first: you get the draft their studio shows, its editToken and the next steps. Then change it with update_draft: each change appears in their studio within seconds, and what they change there is in the draft when you read it. Never make a new draft for a session, and don't hand over a link: they have it open. Inputs: `code`*.
- **`create_draft`** (changes): Make a draft of a catalog template with the person's texts, images, colors and safe size adjustments. Returns a studioUrl the person opens to see the video playing live, an editToken to change it later (update_draft) and to look at it (look_at_draft), what is missing and the price to tell them. Nothing is rendered; the person exports it. Inputs: `template`*, `format`, `site`, `brand`, `values`, `tweaks`.
- **`update_draft`** (changes): Change a draft made with create_draft (the same link stays): send only what changes; null takes a field back to the template's. Inputs: `id`*, `editToken`*, `format`, `site`, `brand`, `values`, `tweaks`.
- **`get_draft`** (reads): What a draft holds: its template, format, values, what is missing, its studio link and its price. Inputs: `id`*.
- **`media_upload_command`** (reads): An image file (PNG, JPEG, WebP or SVG, up to 4 MB) or a clip (MP4 or MOV, up to 40 MB) is too big to send as a tool argument: this answers the exact HTTP request, and a curl command, that puts the file into one of the draft's image or clip fields, checked like any value. Run it from your shell with the file's path. Inputs: `id`*, `field`*, `file`, `editToken`.

### Put a brand on a Pro template

Pro templates are designed in two formats: change every text, image and color, and hide what the brand doesn't need. The layout, timing and motion stay as designed; the person can change them in the editor.

- **`list_pro_templates`** (reads): The Pro templates: designed videos in 16:9 and 9:16 whose every text, image and color an agent can change for a brand. Each lists its length and formats. Inputs: none.
- **`get_pro_template`** (reads): Everything to put a brand on a Pro template: its summary and acts, its palette by role (one recolor per role makes it the brand's), and every layer: what it is for and how long its text should be (note), when it shows, how it looks and moves, and its box and size in each format (read-only: the layout is the template's). Also what the person pays to export it (export.priceUsd, export.tellThePerson). Inputs: `id`*.
- **`create_pro_draft`** (changes): Make a draft of a Pro template with the brand's texts, images and colors: set (a layer's text, its image src and fit, its colors, or hidden), recolor (one palette color to another everywhere) and video (its background). The layout, timing and motion stay the template's: an operation that changes them is refused, and the person can change them in the editor. All are checked together: one that fails applies nothing and the answer lists every issue. Returns draftId, editToken (shown once), editorUrl (opens the Pro editor, where the person watches it, can change anything and exports it), warnings and export (its price, to tell the person). Inputs: `template`*, `ops`.
- **`edit_pro_draft`** (changes): Change a Pro draft's texts, images and colors (the same operations as create_pro_draft: set, recolor, video's background). Send revision to be sure nobody changed it since you read it (a stale one is refused). Returns the new revision and warnings. Inputs: `draftId`*, `editToken`*, `ops`*, `revision`.
- **`get_pro_draft`** (reads): A Pro draft as it is now: its revision, every layer (what differs per format) and both formats' docs. Inputs: `draftId`*.
- **`upload_pro_image`** (changes): Store an image (PNG, JPEG, WebP or SVG) in a Pro draft and get its src for an image layer ({"op":"set","layer":"hero","props":{"src":"<src>"}}). Send small images as data (base64 or a data URL, up to 3 MB); for a file on disk, leave data out and the answer is the curl command that uploads it. Inputs: `draftId`*, `editToken`*, `data`, `contentType`, `file`.

### See what you made

Stills or a contact sheet of any draft, in each format, with a layout check of those moments. The images come back inside the answer.

- **`look_at_pro_draft`** (changes): Render stills (or a contact sheet) of a Pro draft as it is now, in each format, and return them as images inside the answer, with a layout check of those moments by layer (text hidden under another layer, past its box, low contrast). Look before you hand the link over; change and look again. Inputs: `draftId`*, `editToken`*, `formats`, `times`, `sheet`, `wait`, `inline`.
- **`look_at_draft`** (changes): Render stills (or a contact sheet) of a catalog draft with its texts, images and adjustments, the way its export will, and return them as images inside the answer with a layout check of those moments. Inputs: `id`*, `editToken`*, `formats`, `times`, `sheet`, `wait`, `inline`.
- **`get_frames`** (reads): The images of a look that wasn't ready when it was asked (look_at_draft or look_at_pro_draft answered a jobId). Inputs: `draftId`*, `jobId`*, `wait`, `inline`.

## Resources

Guides and live objects the agent can read by URI: the guides, any template, any draft.

- `opusmotion://guide/agents`: Guide for coding agents. How to make a launch video draft for the project you are in: read the repo, pick a template, write the texts, hand over the link.
- `opusmotion://guide/pro`: Pro templates guide. Every operation, prop and animation of Pro templates, and how to make a good video with them.
- `opusmotion://guide/mcp`: This MCP server. The tools, resources and prompts of this server and how to connect it.
- `opusmotion://templates/{id}`: Catalog template. One catalog template: its scenes, fields and tweaks (the same as get_template).
- `opusmotion://pro-templates/{id}`: Pro template. One Pro template: its layers, palette, acts and export price (the same as get_pro_template).
- `opusmotion://drafts/{id}`: Catalog draft. A catalog draft as it is now (the same as get_draft).
- `opusmotion://pro-drafts/{id}`: Pro draft. A Pro draft as it is now (the same as get_pro_draft).
- `opusmotion://workflows/{name}`: Workflow. A prompt's steps as a document (launch_video, pro_brand_video, review_draft), for clients that don't show MCP prompts.

## Prompts

Ready workflows your client can offer as commands: the agent gets the steps, the person fills a sentence.

- **`launch_video`**: Pick a template for a product, fill it with the product's own words and images, look at it and hand over the link. Arguments: `product`*, `site`, `format`.
- **`pro_brand_video`**: Put a brand on a Pro template: its words, images and colors in both formats, checked with stills before handing it over. Arguments: `brand`*, `brief`, `template`.
- **`review_draft`**: Look at a draft in every format, list what reads badly (crowding, empty areas, small images, long texts) and fix it. Arguments: `draftId`*, `editToken`*, `kind`*.

## What stays with the person

- Exporting the MP4, from their own account (the link the agent hands over opens the video playing live, with an Export button).
- Payment for premium templates and Pro videos (priced by length, or covered by an Opus Motion Pass), and AI generation (images, music, animated clips), which runs on credits.
- Changing the design: the agent changes texts, images and colors; moving, retiming or re-animating anything is the person's, in the editor.
- Nothing the agent makes is published or charged: a draft is a link until the person exports it.

## Limits

- 60 calls a minute per network; making drafts and looking at them have their own smaller limits, and each answer says where you stand.
- A draft keeps its edit key: it is shown once, and every change and look needs it. Catalog drafts last 30 days.
- Small images can go as base64 inside the call; image files and clips go with the upload command a tool answers (media_upload_command, upload_pro_image), one curl from the agent's shell.
- A look takes about half a minute; the tool waits up to 55 seconds, then answers a jobId for get_frames.

## Prefer plain HTTP?

Everything here is also an HTTP API with the same rules: the guide for coding agents, the developer docs and the OpenAPI description.

- [Guide for coding agents](https://opusmotion.com/agents.md)
- [Developer docs](https://opusmotion.com/developers)
- [OpenAPI](https://opusmotion.com/openapi.json)
- [MCP manifest](https://opusmotion.com/.well-known/mcp/manifest.json)