# Create an API key Source: https://docs.melius.com/api-reference/apikey/create-an-api-key /api/openapi.json post /api/v1/api-keys # List API keys Source: https://docs.melius.com/api-reference/apikey/list-api-keys /api/openapi.json get /api/v1/api-keys # Revoke an API key Source: https://docs.melius.com/api-reference/apikey/revoke-an-api-key /api/openapi.json delete /api/v1/api-keys/{keyId} # Get a run approval Source: https://docs.melius.com/api-reference/approval/get-a-run-approval /api/openapi.json get /api/v1/agent/approvals/{approvalId} # List team asset folders for the agent Source: https://docs.melius.com/api-reference/asset/list-team-asset-folders-for-the-agent /api/openapi.json get /api/v1/files/agent-folders # Place library assets onto a canvas Source: https://docs.melius.com/api-reference/asset/place-library-assets-onto-a-canvas /api/openapi.json post /api/v1/canvases/{canvasId}/library-assets/place # Search team assets for the agent Source: https://docs.melius.com/api-reference/asset/search-team-assets-for-the-agent /api/openapi.json get /api/v1/files/agent-search # List voices Source: https://docs.melius.com/api-reference/audio/list-voices /api/openapi.json get /api/v1/audio/voices # Create a canvas Source: https://docs.melius.com/api-reference/canvas/create-a-canvas /api/openapi.json post /api/v1/projects/{projectId}/canvases # Delete a canvas Source: https://docs.melius.com/api-reference/canvas/delete-a-canvas /api/openapi.json delete /api/v1/projects/{projectId}/canvases/{canvasId} # Get a canvas Source: https://docs.melius.com/api-reference/canvas/get-a-canvas /api/openapi.json get /api/v1/canvases/{canvasId} # Get canvas content Source: https://docs.melius.com/api-reference/canvas/get-canvas-content /api/openapi.json get /api/v1/canvases/{canvasId}/content # List all canvases Source: https://docs.melius.com/api-reference/canvas/list-all-canvases /api/openapi.json get /api/v1/canvases # List canvases in a project Source: https://docs.melius.com/api-reference/canvas/list-canvases-in-a-project /api/openapi.json get /api/v1/projects/{projectId}/canvases # Update a canvas Source: https://docs.melius.com/api-reference/canvas/update-a-canvas /api/openapi.json patch /api/v1/canvases/{canvasId} # Add a comment to a thread Source: https://docs.melius.com/api-reference/comment/add-a-comment-to-a-thread /api/openapi.json post /api/v1/comment-threads/{threadId}/comments # Create a comment thread Source: https://docs.melius.com/api-reference/comment/create-a-comment-thread /api/openapi.json post /api/v1/canvases/{canvasId}/comment-threads # List comment threads Source: https://docs.melius.com/api-reference/comment/list-comment-threads /api/openapi.json get /api/v1/canvases/{canvasId}/comment-threads # Update a comment thread Source: https://docs.melius.com/api-reference/comment/update-a-comment-thread /api/openapi.json patch /api/v1/comment-threads/{threadId} # Get a Ditto replacement Source: https://docs.melius.com/api-reference/ditto/get-a-ditto-replacement /api/openapi.json get /api/v1/ditto/replacements/{generationId} # List Ditto models Source: https://docs.melius.com/api-reference/ditto/list-ditto-models /api/openapi.json get /api/v1/ditto/models # Prepare a Ditto replacement Source: https://docs.melius.com/api-reference/ditto/prepare-a-ditto-replacement /api/openapi.json post /api/v1/ditto/replacements/prepare # Start a Ditto replacement Source: https://docs.melius.com/api-reference/ditto/start-a-ditto-replacement /api/openapi.json post /api/v1/ditto/replacements # Create an edge Source: https://docs.melius.com/api-reference/edge/create-an-edge /api/openapi.json post /api/v1/canvases/{canvasId}/direct/edges # Create edges in bulk Source: https://docs.melius.com/api-reference/edge/create-edges-in-bulk /api/openapi.json post /api/v1/canvases/{canvasId}/direct/edges/bulk # Delete an edge Source: https://docs.melius.com/api-reference/edge/delete-an-edge /api/openapi.json delete /api/v1/canvases/{canvasId}/direct/edges/{edgeId} # List custom fonts Source: https://docs.melius.com/api-reference/font/list-custom-fonts /api/openapi.json get /api/v1/custom-fonts # Get Auto model defaults Source: https://docs.melius.com/api-reference/model/get-auto-model-defaults /api/openapi.json get /api/v1/generation/auto-model-defaults # List generative models Source: https://docs.melius.com/api-reference/model/list-generative-models /api/openapi.json get /api/v1/generation/models # Create a node Source: https://docs.melius.com/api-reference/node/create-a-node /api/openapi.json post /api/v1/canvases/{canvasId}/direct/nodes # Create nodes in bulk Source: https://docs.melius.com/api-reference/node/create-nodes-in-bulk /api/openapi.json post /api/v1/canvases/{canvasId}/direct/nodes/bulk # Delete a node Source: https://docs.melius.com/api-reference/node/delete-a-node /api/openapi.json delete /api/v1/canvases/{canvasId}/direct/nodes/{nodeId} # Delete nodes in bulk Source: https://docs.melius.com/api-reference/node/delete-nodes-in-bulk /api/openapi.json post /api/v1/canvases/{canvasId}/direct/nodes/bulk-delete # Get a node Source: https://docs.melius.com/api-reference/node/get-a-node /api/openapi.json get /api/v1/nodes/{nodeId} # Set node text Source: https://docs.melius.com/api-reference/node/set-node-text /api/openapi.json put /api/v1/nodes/{nodeId}/custom-text # Set the active node version Source: https://docs.melius.com/api-reference/node/set-the-active-node-version /api/openapi.json post /api/v1/nodes/{nodeId}/set-version # Update a node Source: https://docs.melius.com/api-reference/node/update-a-node /api/openapi.json patch /api/v1/canvases/{canvasId}/direct/nodes/{nodeId} # Update nodes in bulk Source: https://docs.melius.com/api-reference/node/update-nodes-in-bulk /api/openapi.json patch /api/v1/canvases/{canvasId}/direct/nodes/bulk # Create a sticky note Source: https://docs.melius.com/api-reference/note/create-a-sticky-note /api/openapi.json post /api/v1/canvases/{canvasId}/direct/notes # Update a sticky note Source: https://docs.melius.com/api-reference/note/update-a-sticky-note /api/openapi.json patch /api/v1/canvases/{canvasId}/direct/notes/{noteId} # Set agent presence Source: https://docs.melius.com/api-reference/presence/set-agent-presence /api/openapi.json post /api/v1/canvases/{canvasId}/agent-presence # List presets Source: https://docs.melius.com/api-reference/preset/list-presets /api/openapi.json get /api/v1/presets # Get your profile Source: https://docs.melius.com/api-reference/profile/get-your-profile /api/openapi.json get /api/v1/profile/me # Create a project Source: https://docs.melius.com/api-reference/project/create-a-project /api/openapi.json post /api/v1/projects # Delete a project Source: https://docs.melius.com/api-reference/project/delete-a-project /api/openapi.json delete /api/v1/projects/{projectId} # Get a project Source: https://docs.melius.com/api-reference/project/get-a-project /api/openapi.json get /api/v1/projects/{projectId} # List projects Source: https://docs.melius.com/api-reference/project/list-projects /api/openapi.json get /api/v1/projects/all # Update a project Source: https://docs.melius.com/api-reference/project/update-a-project /api/openapi.json patch /api/v1/projects/{projectId} # Cancel a run Source: https://docs.melius.com/api-reference/run/cancel-a-run /api/openapi.json post /api/v1/node-runs/{nodeRunId}/cancel # Download a bulk run output Source: https://docs.melius.com/api-reference/run/download-a-bulk-run-output /api/openapi.json post /api/v1/bulk-node-runs/{bulkNodeRunId}/download # Download a run output Source: https://docs.melius.com/api-reference/run/download-a-run-output /api/openapi.json post /api/v1/node-runs/{nodeRunId}/download # Download all run outputs Source: https://docs.melius.com/api-reference/run/download-all-run-outputs /api/openapi.json post /api/v1/node-runs/download # Get a bulk run Source: https://docs.melius.com/api-reference/run/get-a-bulk-run /api/openapi.json get /api/v1/bulk-node-runs/{bulkNodeRunId} # Get a run Source: https://docs.melius.com/api-reference/run/get-a-run /api/openapi.json get /api/v1/node-runs/{nodeRunId} # Get the latest runs Source: https://docs.melius.com/api-reference/run/get-the-latest-runs /api/openapi.json get /api/v1/canvases/{canvasId}/node-runs/latest # Magic resize from an image Source: https://docs.melius.com/api-reference/run/magic-resize-from-an-image /api/openapi.json post /api/v1/canvases/{canvasId}/magic-resize # Run a node tool Source: https://docs.melius.com/api-reference/run/run-a-node-tool /api/openapi.json post /api/v1/nodes/{nodeId}/tool-runs # Start a bulk run Source: https://docs.melius.com/api-reference/run/start-a-bulk-run /api/openapi.json post /api/v1/canvases/{canvasId}/bulk-run # Start a run Source: https://docs.melius.com/api-reference/run/start-a-run /api/openapi.json post /api/v1/nodes/{nodeId}/runs # List your teams Source: https://docs.melius.com/api-reference/team/list-your-teams /api/openapi.json get /api/v1/teams # Complete a team skill image upload Source: https://docs.melius.com/api-reference/teamskill/complete-a-team-skill-image-upload /api/openapi.json post /api/v1/teams/{teamId}/agent-skills/{skillId}/assets/complete # Create a team skill Source: https://docs.melius.com/api-reference/teamskill/create-a-team-skill /api/openapi.json post /api/v1/teams/{teamId}/agent-skills # Delete a team skill Source: https://docs.melius.com/api-reference/teamskill/delete-a-team-skill /api/openapi.json delete /api/v1/teams/{teamId}/agent-skills/{skillId} # Get a team skill Source: https://docs.melius.com/api-reference/teamskill/get-a-team-skill /api/openapi.json get /api/v1/teams/{teamId}/agent-skills/{skillId} # List team skills Source: https://docs.melius.com/api-reference/teamskill/list-team-skills /api/openapi.json get /api/v1/teams/{teamId}/agent-skills # Remove a team skill image Source: https://docs.melius.com/api-reference/teamskill/remove-a-team-skill-image /api/openapi.json delete /api/v1/teams/{teamId}/agent-skills/{skillId}/assets/{assetId} # Sign a team skill image upload part Source: https://docs.melius.com/api-reference/teamskill/sign-a-team-skill-image-upload-part /api/openapi.json post /api/v1/teams/{teamId}/agent-skills/{skillId}/assets/sign-part # Start a team skill image upload Source: https://docs.melius.com/api-reference/teamskill/start-a-team-skill-image-upload /api/openapi.json post /api/v1/teams/{teamId}/agent-skills/{skillId}/assets/init # Update a team skill Source: https://docs.melius.com/api-reference/teamskill/update-a-team-skill /api/openapi.json patch /api/v1/teams/{teamId}/agent-skills/{skillId} # Update a team skill image Source: https://docs.melius.com/api-reference/teamskill/update-a-team-skill-image /api/openapi.json patch /api/v1/teams/{teamId}/agent-skills/{skillId}/assets/{assetId} # Apply a template Source: https://docs.melius.com/api-reference/template/apply-a-template /api/openapi.json post /api/v1/templates/apply # List templates Source: https://docs.melius.com/api-reference/template/list-templates /api/openapi.json get /api/v1/templates # Complete an upload Source: https://docs.melius.com/api-reference/upload/complete-an-upload /api/openapi.json post /api/v1/upload/complete # Sign an upload part Source: https://docs.melius.com/api-reference/upload/sign-an-upload-part /api/openapi.json post /api/v1/upload/sign-part # Start an upload Source: https://docs.melius.com/api-reference/upload/start-an-upload /api/openapi.json post /api/v1/upload/init # Authentication Source: https://docs.melius.com/api/authentication Authenticate API requests with a Melius API key and the x-team-id header. Every request authenticates with an API key passed as a bearer token, plus a header naming the team to act on. ```bash theme={null} Authorization: Bearer mel_... x-team-id: ``` ## Create an API key In the Melius app, go to **Team settings → Integrations** and create a key. Each key: * Is shown **once** at creation — copy it before closing the dialog. * Can be given an expiry, or set to never expire. * Can be revoked at any time from the same page — revocation takes effect immediately. > [!WARNING] > > Treat an API key like a password. Don't commit it to source control or > expose it in client-side code. Set it from an environment variable or a > secrets manager. ## Find your team id `x-team-id` selects which team a request acts on. List your teams — note that `/teams` returns your **memberships**, so the team id is under `.team.id`: ```bash theme={null} curl -s -H "Authorization: Bearer mel_..." https://api.melius.com/api/v1/teams \ | jq '.[] | {teamId: .team.id, name: .team.name, plan: .team.plan, role}' ``` If you omit `x-team-id`, requests default to the team the key was created in. ## How keys are scoped An API key acts **on behalf of the user who created it**. That has three consequences worth understanding: * **It spans that user's teams.** A key can act on any team its creator is a member of by passing that team's `x-team-id` — not just the team it was created in. It can never reach a team its creator doesn't belong to. * **It's capped at the creator's role in each team.** Permissions follow the user's role in the team being acted on, exactly like the app — the key never grants more than that role. Owner/admin-only actions (managing members, billing, team settings) require that role **in the acted-on team**; a viewer can only read. Selecting a different team with `x-team-id` never escalates access. * **It follows the creator's membership.** If the creating user leaves a team, the key loses access to that team. For a long-lived production integration, create the key from an account that will remain a member of the team — a dedicated service account rather than a personal login. ## Errors | Status | Meaning | | - | - | | `401` | Missing, invalid, expired, or revoked API key. | | `403` | The key's user isn't a member of the requested `x-team-id`, or their role there doesn't permit the action. | | `429` | Rate limited — retry after the `Retry-After` header. | | `400` | Invalid request — including not enough credits to run a generation. | ## Next steps > [card] [Quickstart](/api/quickstart) > > Run your first generation end to end. > [card] [API overview](/api/overview) > > The base URL, the async job model, and how generations work. # Ditto Source: https://docs.melius.com/api/ditto Replace characters, props and backgrounds in a video with Melius Ditto over the REST API. > [!NOTE] > > **Beta** — this feature is rolling out gradually. A team outside the beta > gets `403` with the code `DITTO_BETA_REQUIRED` from every Ditto endpoint, > and can join the waitlist from Ditto in the app. Ditto replaces characters, props and backgrounds in an existing video using reference images. One request can carry up to 30 replacements, and they are all applied together in a single generation with one price and one output video. Every Ditto endpoint lives under `/api/v1/ditto`: ``` GET /ditto/models → models you can use POST /ditto/replacements/prepare → check inputs and get a quote (free) POST /ditto/replacements → start the paid replacement GET /ditto/replacements/:generationId (poll) → preparing → rendering → finalizing → ready ``` ## 1. Upload the video and reference images Upload the source video (MP4 or MOV) and each reference image with the endpoints under **Uploads** in the API reference: `POST /upload/init`, `POST /upload/sign-part` and `POST /upload/complete`. Keep the `assetId` each upload returns. You can also reuse the asset IDs of files already in your team. ## 2. Prepare a quote Send the source video and an ordered `replacements` list. Each item has a `referenceAssetId`, a `targetKind` (`character`, `prop` or `background`) and an optional `targetDescription` naming what it replaces in the video. ```bash theme={null} curl -X POST https://api.melius.com/api/v1/ditto/replacements/prepare \ -H "Authorization: Bearer mel_..." \ -H "Content-Type: application/json" \ -d '{ "sourceAssetId": "", "replacements": [ { "referenceAssetId": "", "targetKind": "character" }, { "referenceAssetId": "", "targetKind": "prop", "targetDescription": "the mug on the desk" } ] }' ``` A `targetDescription` is optional for characters: Ditto picks the main person, or distinct people in reference order when there are several. It is required when two or more items replace props, or two or more replace backgrounds. Optional fields: * `sourceRange` — `{ "startMs": 0, "endMs": 5000 }` to use part of the video. The full video is used otherwise. * `modelId` and `resolution` — leave them out to use Ditto's default. * `audioMode` — `original` (default) keeps the video's audio; `mute` removes it. * `additionalInstructions` — extra direction that applies to every replacement. The response includes `quote` (`id`, `credits`, `expiresAt`) and `models`, which lists each model with whether it can run this request and why not. `quote` is `null` when no model can run it; fix the input using the reasons and prepare again. Preparing is free and starts no work. ## 3. Start the replacement Generate a UUID for the attempt, then send it with the same `input` that `prepare` returned and the quote ID. Starting a replacement needs an editor role on the team, and charges the quoted credits to the team. ```bash theme={null} curl -X POST https://api.melius.com/api/v1/ditto/replacements \ -H "Authorization: Bearer mel_..." \ -H "Content-Type: application/json" \ -d '{ "attemptId": "", "input": , "quoteId": "", "maxCredits": 500 }' ``` `maxCredits` is optional and rejects the request with `402` if the quote costs more. The response carries a `generationId`. Requests with the same `attemptId` and `input` return the same generation instead of charging again. If you lose the response, resend the identical request. A new `attemptId` always starts and charges a new generation. ## 4. Get the result Poll `GET /ditto/replacements/` until `status` is `ready` or `failed`. `preparing`, `rendering` and `finalizing` mean it is still working. When it is `ready`, `videoUrl` links to the finished video and `outputAssetId` is its asset in your team. A `failed` generation includes a `failureMessage`. When it also has `canRetryFinalization: true`, the video rendered but finishing failed. Retry only the finishing step, without paying for the render again: resend the start request with the same `generationId` as `attemptId`, the same `input`, `retryQuoteId` as `quoteId` and `"retryFinalization": true`. # API overview Source: https://docs.melius.com/api/overview Drive Melius canvases and generations programmatically over a REST API. The Melius REST API drives Melius canvases and generations from your own code — create projects and canvases, add nodes, wire edges, run generations across the latest image, video, audio, and language models, and read the results. It runs on the same backend as the Melius web app, CLI, and MCP server. > [!NOTE] > > You authenticate with an API key. Create one in the Melius app under **Team > settings → Integrations**. See [Authentication](/api/authentication). ## Base URL ``` https://api.melius.com/api/v1 ``` Every request needs a bearer API key. You can optionally select which team to act on with the `x-team-id` header — it defaults to the team your key belongs to: ```bash theme={null} Authorization: Bearer mel_... x-team-id: # optional ``` ## How generations work A generation in Melius **is a canvas node** — there's no separate "generate" path, so the API stays consistent with the app. You create a node, start a run, and poll the run until it finishes: ``` POST /projects → create a project POST /projects/:projectId/canvases → create a canvas POST /canvases/:canvasId/direct/nodes → add a node (prompt + optional model) POST /nodes/:nodeId/runs → start a run GET /node-runs/:nodeRunId (poll) → status: running → finished ``` Runs are **asynchronous jobs**. Starting a run returns immediately with a run id; the generation runs in the background across Melius's model providers. Poll the run until `status` is `finished` (or `failed`). Pass `seed` as a top-level field when starting a run. API-key requests preserve it even when the team's custom-seed UI setting is disabled. The value must be an integer from `0` to `2147483647`, inclusive. For image generation, call `GET /generation/models?category=image` and select a model whose chosen entry in `variants` has `supportsSeed: true`. ```http theme={null} POST /api/v1/nodes//runs Authorization: Bearer mel_... Content-Type: application/json { "canvasId": "", "seed": 42 } ``` The node's configured prompt and model are used. For repeatable requests, keep the model, prompt, inputs, settings, and seed identical. Providers may normalize seed values, and identical requests can still produce different pixels even when the provider honors the seed. API-key bulk runs also preserve seeds configured on their nodes. ## Post-process a node Node tools modify a finished asset in place. Use `remove-background` for image nodes and file nodes that contain images, or `topaz-upscale` to increase an image's resolution. `remove-background` runs Pixelcut. Topaz accepts provider settings through `toolConfig`, including `upscale_factor`. Both tools create and activate a new version on the same node. ```bash theme={null} curl -X POST https://api.melius.com/api/v1/nodes//tool-runs \ -H "Authorization: Bearer mel_..." \ -H "Content-Type: application/json" \ -d '{ "canvasId": "", "toolName": "remove-background" }' ``` To upscale an image, send `topaz-upscale` and its provider settings: ```bash theme={null} curl -X POST https://api.melius.com/api/v1/nodes//tool-runs \ -H "Authorization: Bearer mel_..." \ -H "Content-Type: application/json" \ -d '{ "canvasId": "", "toolName": "topaz-upscale", "toolConfig": { "upscale_factor": 2 } }' ``` The response is `{ "id": "" }`. Poll `GET /api/v1/node-runs/` until the run finishes, just like a generation run. ## Get the result When a run finishes, request a download with an empty JSON body (`{}`): ```bash theme={null} POST /api/v1/node-runs/:nodeRunId/download → { "url": "...", "filename": "...", "size": 1234 } ``` Fetch the returned URL directly, without your Melius authorization header. The download is a ZIP archive, including for a single image; extract it to read the generated or upscaled file. ## Rate limits and credits * **Credits.** Generations consume credits from the team you act on, exactly like the app. Image model costs are shown in `GET /generation/models?category=image`; use `category=image_tool` for image tools such as Topaz. * **Rate limits.** There is no monthly request quota on any plan. Requests can still return `429` with a `Retry-After` header — wait the number of seconds it gives you, then retry. For a temporary `429`, use a bounded retry loop: wait at least `Retry-After` seconds, add a small random delay, and retry the rejected request. The JSON body's `retryAfterSeconds` is a fallback if your client cannot read the header. Keep retries within the same concurrency limit. If requests keep returning `429`, stop the burst and retry later; this is not a monthly quota error. Only apply that retry policy to an explicit `429`. A timeout or `5xx` response can leave the outcome of a mutation uncertain; check the canvas or run state before resubmitting to avoid duplicate work. If a canvas's saved state exceeds the 48 MiB API loading limit, the operation returns `400` with code `CANVAS_TOO_LARGE`. Use a smaller canvas or create a new canvas. Retrying the same operation will not help. ## Next steps > [card] [Quickstart](/api/quickstart) > > Create a key and run your first generation end to end. > [card] [Authentication](/api/authentication) > > API keys, the `x-team-id` header, and how keys are scoped. Browse every endpoint under **API reference** in the sidebar — each has a live **try it** playground and code samples in cURL, Python, TypeScript, PHP, Go, and Ruby. # Quickstart Source: https://docs.melius.com/api/quickstart Generate your first image with the Melius API in a few minutes. ## 1. Get an API key In the Melius app, go to **Team settings → Integrations**, create a key, and copy it — it's shown once. See [Authentication](/api/authentication) for details. ## 2. Make your first request Paste your key into the snippet below and run it. It creates a project and canvas, adds an image node with your prompt, runs it, waits for the generation to finish, and prints the URL of the generated image. ```bash cURL theme={null} KEY="mel_..." BASE="https://api.melius.com/api/v1" AUTH=(-H "Authorization: Bearer $KEY" -H "Content-Type: application/json") PROJECT=$(curl -s "${AUTH[@]}" -d '{"title":"My first project"}' $BASE/projects | jq -r .id) CANVAS=$(curl -s "${AUTH[@]}" -d '{"title":"My first canvas"}' $BASE/projects/$PROJECT/canvases | jq -r .id) NODE=$(uuidgen | tr 'A-Z' 'a-z') curl -s "${AUTH[@]}" -d "{\"id\":\"$NODE\",\"nodeType\":\"image\",\"geometry\":{\"x\":0,\"y\":0,\"w\":380,\"h\":632},\"textPrompt\":\"a golden retriever puppy in a field\"}" $BASE/canvases/$CANVAS/direct/nodes > /dev/null RUN=$(curl -s "${AUTH[@]}" -d "{\"canvasId\":\"$CANVAS\"}" $BASE/nodes/$NODE/runs | jq -r .id) while true; do STATUS=$(curl -s "${AUTH[@]}" $BASE/node-runs/$RUN | jq -r .status) [ "$STATUS" = "finished" ] && break [ "$STATUS" = "failed" ] && { echo "generation failed"; exit 1; } sleep 2 done curl -s "${AUTH[@]}" -d '{}' $BASE/node-runs/$RUN/download | jq -r .url ``` ```python Python theme={null} import time, uuid, requests KEY = "mel_..." BASE = "https://api.melius.com/api/v1" auth = {"Authorization": f"Bearer {KEY}"} project = requests.post(f"{BASE}/projects", headers=auth, json={"title": "My first project"}).json() canvas = requests.post(f"{BASE}/projects/{project['id']}/canvases", headers=auth, json={"title": "My first canvas"}).json() node_id = str(uuid.uuid4()) requests.post(f"{BASE}/canvases/{canvas['id']}/direct/nodes", headers=auth, json={ "id": node_id, "nodeType": "image", "geometry": {"x": 0, "y": 0, "w": 380, "h": 632}, "textPrompt": "a golden retriever puppy in a field", }) run = requests.post(f"{BASE}/nodes/{node_id}/runs", headers=auth, json={"canvasId": canvas["id"]}).json() while True: status = requests.get(f"{BASE}/node-runs/{run['id']}", headers=auth).json()["status"] if status in ("finished", "failed"): break time.sleep(2) result = requests.post(f"{BASE}/node-runs/{run['id']}/download", headers=auth, json={}).json() print(result["url"]) ``` ```typescript TypeScript theme={null} const KEY = "mel_..."; const BASE = "https://api.melius.com/api/v1"; const headers = { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json", }; const post = (path: string, body: unknown): Promise => fetch(`${BASE}${path}`, { method: "POST", headers, body: JSON.stringify(body), }).then((r) => r.json()); const get = (path: string): Promise => fetch(`${BASE}${path}`, { headers }).then((r) => r.json()); async function main() { const project = await post<{ id: string }>("/projects", { title: "My first project", }); const canvas = await post<{ id: string }>( `/projects/${project.id}/canvases`, { title: "My first canvas" }, ); const nodeId = crypto.randomUUID(); await post(`/canvases/${canvas.id}/direct/nodes`, { id: nodeId, nodeType: "image", geometry: { x: 0, y: 0, w: 380, h: 632 }, textPrompt: "a golden retriever puppy in a field", }); const run = await post<{ id: string }>(`/nodes/${nodeId}/runs`, { canvasId: canvas.id, }); let status: string; do { await new Promise((r) => setTimeout(r, 2000)); ({ status } = await get<{ status: string }>(`/node-runs/${run.id}`)); } while (status !== "finished" && status !== "failed"); const result = await post<{ url: string }>( `/node-runs/${run.id}/download`, {}, ); console.log(result.url); } main(); ``` ```php PHP theme={null} true, CURLOPT_CUSTOMREQUEST => $method, CURLOPT_HTTPHEADER => ["Authorization: Bearer $KEY", "Content-Type: application/json"], CURLOPT_POSTFIELDS => $body === null ? null : json_encode($body), ]); return json_decode(curl_exec($ch), true); } function uuidv4() { $d = random_bytes(16); $d[6] = chr(ord($d[6]) & 0x0f | 0x40); $d[8] = chr(ord($d[8]) & 0x3f | 0x80); return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($d), 4)); } $project = call("POST", "/projects", ["title" => "My first project"]); $canvas = call("POST", "/projects/{$project['id']}/canvases", ["title" => "My first canvas"]); $nodeId = uuidv4(); call("POST", "/canvases/{$canvas['id']}/direct/nodes", [ "id" => $nodeId, "nodeType" => "image", "geometry" => ["x" => 0, "y" => 0, "w" => 380, "h" => 632], "textPrompt" => "a golden retriever puppy in a field", ]); $run = call("POST", "/nodes/$nodeId/runs", ["canvasId" => $canvas["id"]]); do { sleep(2); $status = call("GET", "/node-runs/{$run['id']}")["status"]; } while ($status !== "finished" && $status !== "failed"); $result = call("POST", "/node-runs/{$run['id']}/download", new stdClass()); echo $result["url"] . "\n"; ``` ```go Go theme={null} package main import ( "bytes" "crypto/rand" "encoding/json" "fmt" "io" "net/http" "time" ) const key = "mel_..." const base = "https://api.melius.com/api/v1" func call(method, path string, body any) map[string]any { var buf io.Reader if body != nil { b, _ := json.Marshal(body) buf = bytes.NewReader(b) } req, _ := http.NewRequest(method, base+path, buf) req.Header.Set("Authorization", "Bearer "+key) req.Header.Set("Content-Type", "application/json") resp, _ := http.DefaultClient.Do(req) defer resp.Body.Close() data, _ := io.ReadAll(resp.Body) var out map[string]any json.Unmarshal(data, &out) return out } func uuidv4() string { b := make([]byte, 16) rand.Read(b) b[6] = (b[6] & 0x0f) | 0x40 b[8] = (b[8] & 0x3f) | 0x80 return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) } func main() { project := call("POST", "/projects", map[string]any{"title": "My first project"}) canvas := call("POST", fmt.Sprintf("/projects/%s/canvases", project["id"]), map[string]any{"title": "My first canvas"}) nodeID := uuidv4() call("POST", fmt.Sprintf("/canvases/%s/direct/nodes", canvas["id"]), map[string]any{ "id": nodeID, "nodeType": "image", "geometry": map[string]any{"x": 0, "y": 0, "w": 380, "h": 632}, "textPrompt": "a golden retriever puppy in a field", }) run := call("POST", fmt.Sprintf("/nodes/%s/runs", nodeID), map[string]any{"canvasId": canvas["id"]}) status := "" for status != "finished" && status != "failed" { time.Sleep(2 * time.Second) status, _ = call("GET", fmt.Sprintf("/node-runs/%s", run["id"]), nil)["status"].(string) } result := call("POST", fmt.Sprintf("/node-runs/%s/download", run["id"]), map[string]any{}) fmt.Println(result["url"]) } ``` ```ruby Ruby theme={null} require "net/http" require "json" require "securerandom" KEY = "mel_..." BASE = "https://api.melius.com/api/v1" def call(method, path, body = nil) uri = URI("#{BASE}#{path}") req = (method == "GET" ? Net::HTTP::Get : Net::HTTP::Post).new(uri) req["Authorization"] = "Bearer #{KEY}" req["Content-Type"] = "application/json" req.body = body.to_json if body res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) } JSON.parse(res.body) end project = call("POST", "/projects", { title: "My first project" }) canvas = call("POST", "/projects/#{project['id']}/canvases", { title: "My first canvas" }) node_id = SecureRandom.uuid call("POST", "/canvases/#{canvas['id']}/direct/nodes", { id: node_id, nodeType: "image", geometry: { x: 0, y: 0, w: 380, h: 632 }, textPrompt: "a golden retriever puppy in a field", }) run = call("POST", "/nodes/#{node_id}/runs", { canvasId: canvas["id"] }) status = nil until ["finished", "failed"].include?(status) sleep 2 status = call("GET", "/node-runs/#{run['id']}")["status"] end result = call("POST", "/node-runs/#{run['id']}/download", {}) puts result["url"] ``` No model is specified, so Melius picks one for you. To choose a specific model, add a `modelConfig` to the node from [List generative models](/api/overview). The `x-team-id` header is optional — requests default to the team your key belongs to. ## Next steps > [card] [Authentication](/api/authentication) > > Keys, the `x-team-id` header, and how keys are scoped. > [card] [API overview](/api/overview) > > The base URL, how generations work, rate limits, and credits. # Payment methods Source: https://docs.melius.com/billing/payment Manage cards and invoicing details. Payment methods are managed at the team level. Add, replace, or remove cards from **Team settings → Plans & billing → Payment methods**. ## Adding a card Click **Add payment method** and complete the card-entry flow. The card is verified via a zero-dollar authorization before being saved. ## Default card The default card is charged for monthly subscription renewals and any manual top-ups. If you have multiple cards, mark one as default — the rest are kept as backups. ## Invoices Every charge generates an invoice you can download as a PDF. Invoices include your team's billing address — keep it up to date in the same screen. # Plans & billing Source: https://docs.melius.com/billing/plans Subscription tiers, credits, top-ups, and checking refunds in generation history. Melius plans are metered in **credits**: every generation across text, image, and video models consumes credits from the team you're acting on. Each model shows its per-run cost before you generate. Nano Banana and Veo generations use their displayed credit prices. Cast and Ditto runs using Seedance 2.0 or 2.5 receive a standard credit discount of one sixth (about 16.7%), including runs submitted through MCP or the API. The discount applies to Cast and Ditto runs, not general canvas generations using the same models. Separate team discounts still apply. ## Current plans and pricing Plans, monthly credit allowances, and top-up options change over time, so we keep the numbers in one place instead of duplicating them here. * **Compare plans and prices:** [melius.com/pricing](https://melius.com/pricing) * **Choose a plan in the app:** [Pricing plans](https://app.melius.com/pricing-plans) * **See your plan, balance, and usage:** **Team settings → Plans & billing** in the app Pricing plans opens over the page you're on. Select the close button at the top right to return to it. The image and video counts on plan cards are estimates using specific models and settings. Hover, focus, or tap either count to see the model and settings it was calculated on. A video count represents clips of the duration shown in the explanation. The two counts are alternative ways to spend the same allowance; generating revisions or additional images and text uses credits too. Free teams can open pricing plans from **Upgrade plan** at the bottom of the sidebar. If your team doesn't have enough credits for a generation in Playground, Explore, or Cast, pricing plans opens so you can upgrade. The Team plan covers **2 to 10 seats**, and Enterprise seat counts are set in your contract. ## Team plan The Team plan covers **2 to 10 paid seats**. Each seat adds credits to a shared team balance. Owners and admins manage the subscription and invitations. ### Buy Team in the app 1. Open [Team pricing](https://app.melius.com/pricing-plans?audience=team). 2. Choose monthly or annual billing and enough seats for your members and pending invitations. 3. Review the total and confirm your purchase. If you're changing plans, the confirmation shows whether the change happens now or at renewal. If your members and pending invitations already exceed 10 seats, Team pricing shows **Send request** instead. We'll review your request and email you within 24 hours. Monthly billing charges for your chosen seat count each month. Annual billing charges for the year upfront. **Credits refresh monthly on both billing intervals**; annual billing does not give you the whole year's credits at once. See [current per-seat prices](https://melius.com/pricing). ### Invite members and reuse seats On a self-serve Team subscription, open **Settings → Members** to invite someone by email. Each pending invitation reserves one paid seat. * If you have an available paid seat, the invitation uses it without an extra charge. * If every paid seat is occupied or reserved, review and approve the additional seat charge before sending the invitation. Monthly plans charge only for the time remaining in the billing month; annual plans charge only for the time remaining in the paid year. After payment succeeds, the new seat adds credits proportional to the time until the next monthly credit refresh. Later refreshes include the full 70,000 credits per paid seat. Your renewal date stays the same. * Each invitation link can be used once. The person opening it can claim the seat even if they sign in with a different email. Share it only with the intended teammate. * Accepting an invitation does not charge again. Pending invitations hold their seats until accepted or revoked. * If an invitation would take your team past 10 seats, it isn't sent. Our team is notified and will reach out over email about a larger plan. If an invitation email fails to send, the error tells you to retry. Send the same email address again to reuse its invitation and reserved seat without paying again. Removing a member or revoking an invitation frees the seat for reuse through the end of the paid term. It does not refund the current charge. The next renewal adjusts to members plus pending invitations, with a minimum of two seats, unless you've scheduled a change to another plan. ### Reduce seats or switch to an individual plan Use **Team settings → Plans & billing** to review your current seats and scheduled changes. Seat reductions take effect at renewal, so you keep the seats you've already paid for until then. Members and pending invitations must fit the scheduled Team seat count. Inviting someone **keeps an existing scheduled downgrade in place**. If you're changing to an individual plan, any additional seat charge covers the current Team term. If you've explicitly scheduled a lower Team seat count, invitations cannot exceed that count; change the scheduled count before inviting more people. If you've scheduled a switch from an individual plan to Team, members and pending invitations must also fit the future Team seat count. An admin must increase the scheduled count before you can invite or add more people. You are not charged for Team seats before the scheduled switch. A downgrade to an individual plan takes effect at renewal. Members, pending invitations, and work stay with the team. Team member credit limits stop applying when the new plan starts; the saved limits return if you move back to Team. ## Discount codes A discount code takes a percent off the list price of a set number of consecutive monthly payments, from 1 to 12, on the plans it names. Pricing shows how many payments your code covers. Open the link you were given, or enter your code during signup. An available team discount appears in the sidebar for owners and admins; select **View plans** to open pricing. If the Melius team gives you a discount for a particular plan size, **Settings → Plans & billing → Your current plan** shows the discounted payment, the usual price, and the deadline to switch. Select the **See** link to view that size in pricing, then review and confirm the upgrade. The discount applies only to that size, and the offer disappears after you use it. A discount on your existing size instead shows your next payment price until that payment bills. When you start a subscription with a discount already included for the selected plan, choosing that plan takes you straight to Stripe to review the total and confirm payment, including when your team has a saved card. Otherwise, with a saved card, a review of the amount due and renewal price opens first; select **Confirm purchase** to charge that card. Without one, choosing a plan takes you to Stripe. While a first-month offer is active, a new code is refused with “Your existing offer is already applied.” A code applied before the offer stays available for a later eligible purchase. Use it before it expires; if the price changes, review the updated total before confirming. If you enter a discount code during signup, you’ll see pricing after your account is set up. Close pricing to return to the page where you started. * **Free plan:** the discount starts with your first payment when you buy one of those plans with monthly billing. * **Monthly paid plan:** the discount applies when you upgrade to one of those plans, either a higher plan or more monthly credits on your current plan. Moving to fewer credits or a lower plan does not use the code. The prorated upgrade charge is at the full price, and the discount starts with your next monthly renewal. Renewals after the code's last discounted payment use the standard price. If a code still has discounted payments left when you upgrade your monthly plan, the remaining payments keep the same dollar discount. Downgrading or switching to annual billing ends the code's discount. Codes apply to monthly billing on Creator, Growth, and Professional. Annual prices are not discounted by these codes. If you apply one while reviewing an annual purchase, it is saved for a later monthly purchase. Team owners, admins and editors can apply a code, and a team can use each code once. You can apply each code to one team. A newer code replaces one already applied. Codes work in any mix of upper and lower case. ## Search with AI > [!NOTE] > > Available on **Professional**, **Team**, and **Enterprise** plans Find uploads and generated assets by describing their content with **Search with AI**. See [Assets and references](/help-center/marketers/assets) for more on finding and reusing assets. ## Managing your subscription Open your account menu at the bottom of the sidebar to see your team's credit balance. The compact balance rounds down: 903,995 credits appears as **903k**, while amounts below 1,000 stay unabridged. For a recurring allowance, the meter shows the percentage remaining and when credits next reset or refill. One-time credit grants keep a full bar while credits remain. Hover or focus the balance for the exact amount and refresh time, or select it to open **Usage**. Owners and admins can select **Save 20% by upgrading** on a free plan or **Manage plan** on a paid plan to view plan options and billing. Scheduled cancellations show when the plan ends; overdue subscriptions show **Payment overdue**. Enterprise trials show their end date. Everything below happens in **Team settings → Plans & billing**: * **Upgrade or downgrade** — pick a new plan; upgrades take effect immediately. * **Top up** — buy additional credits when your balance runs low. Topped-up credits don't expire. Enterprise contracts can include a discounted rate on top-ups, so the same amount buys more credits; when yours does, the billing page quotes it and **View terms** shows the rate. * **Cancel or reactivate** — cancellation takes effect at the end of the current billing cycle; you keep access and your remaining balance until then. Unused plan credits expire when the plan ends; topped-up credits don't expire. Upgrading a cancelled plan applies right away and keeps the subscription renewing. See [Cancel your subscription](#cancel-your-subscription). * **Credit history** — see subscription credits, top-ups, and other credits added to your team. Generation refunds appear in **Usage → Generation history**. See also [Payment methods](/billing/payment). ### Cancel your subscription Team owners and admins can cancel: 1. Open **Settings** from the sidebar, then **Plans & billing** under **Team**. 2. Click **Manage plan**. 3. On your current plan's card, click **Cancel subscription**, then confirm. Your plan stays active until the end of the billing period, then your team moves to the Free plan. To keep your plan, click **Reactivate** on the same card before then. ### Cast usage In **Usage → Generation history**, each Cast video is one row named **Melius Cast**, with a **Fast** badge when you selected **Melius Cast Fast**. The row's credits add up every charge the video made, including its voice, setting images, video parts and subtitles. While a video is still generating, its row has a **Generating** badge and shows the price Generate showed; once it finishes, the row shows what it was charged. Creating an avatar or a background is one row too, named **Cast avatar** or **Cast background**, with the credits of every rendering it made and a **Generating** badge while it renders. Creating an avatar in Cast is free on every plan. Credits refunded for a failed video part or rendering appear as a second row with the same name and the **Refunded** badge as soon as the refund posts, including while the rest is still generating. CSV exports list the same rows, with **Melius Cast** in the Model column and `fast` in the Tier column for Fast generations. ### Credits returned for failed generations Check whether a refund has been recorded in **Team settings → Usage → Generation history**: 1. Open [Usage](https://app.melius.com/home?settings=usage) for the team that ran the generation. Select **Generation history** if you see tabs; other members land on the history directly. 2. Choose the period and project that include the attempt. Find its model and time in the table. 3. Look for the **Refunded** badge beside the model name and a crossed-out credit amount. These indicate a recorded refund. A failed or blocked status alone does not confirm that a refund has posted. If a recent failed attempt has no **Refunded** badge, refresh after a short wait. If it is still missing, contact support with the project, model, and approximate time. Owners and admins can see team history; other members see their own generations. Refunds are per generation, not per output. A generation that delivered any output is charged in full and is not refunded, even if the result isn't what you wanted: if one of four images in a generation fails, nothing is refunded, because three were delivered. A generation that delivered nothing is refunded automatically. A Cast video is refunded as a whole: if it doesn't finish, every charge it made is refunded, including its voice, setting images and any parts that did finish. To try for a different result, run it again with another model. For questions about a charge, email [support@melius.com](mailto:support@melius.com). Refunded credits return to the grants that paid for the generation and keep their original expiry rules. If a grant has already expired when the refund arrives, that portion of the refund expires immediately. Refunding a generation does not extend the life of its credits. For text generation, credits reserved before expiry can still pay the final generation cost. Any unused reserved credits are returned under the original grant's expiry rules. ## Usage insights > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. Open **Team settings → Usage** to explore **Generations**, **Model usage**, and **Project spend**. **Generations** shows activity over time, broken down by content type. The project and period filters apply to the charts and the table. Owners and admins see team usage; other members see their own activity. **Net credits used** subtracts refunds recorded during the selected period. A refund for an earlier generation can make a model's or project's net spend negative. Generation counts follow charged operations, including operations that were later refunded. Charts use billing activity timestamps in UTC and automatically group longer periods into months. ### Member credit limits > [!NOTE] > > Per-member credit limits are available on **Team** and **Enterprise** plans. > [Compare plans](/billing/plans). In **Settings → Members** or the **Credit usage** table, select a member's **No limit** dropdown. Enter a credit amount or a percentage of the team's current billing-period budget, then select **Apply limit**. The saved limit appears as a progress bar; select it to edit the limit. The bar always shows the current refill period, even when the usage table is filtered to a different period or project. Select **Apply to all members** to replace every member's limit with the amount you entered. A limit of **0** pauses that member's credit spending. To restore unrestricted access to the team's available credits, select **Remove limit**. The limit is removed immediately without a confirmation dialog. # Brand kits Source: https://docs.melius.com/brand-kit/overview Save each brand's logos, colors, fonts, and voice once so Mel stays on brand in every chat. A brand kit is one brand's summary, voice, colors, typefaces, logos, and reference media in one place. Melius builds it from the brand's website, its guidelines PDF, or both. Your team can keep a kit for each brand it works with, shared by every member. One kit is your team's default: Mel uses it on every canvas and in every new chat. You can switch any chat to another kit. Open your kits from **Brand kits** in the sidebar, under **Library**, or go to `/brand-kit`. The page shows every kit as a card, newest first, with **Default** on the default kit. ## Build a brand kit **1. Add a source** On the **Brand kits** page, click **New brand kit**. Enter the brand's **Website** (for example `yourbrand.com`), upload a PDF, or both. A PDF can be brand guidelines, a pitch deck, or a style sheet, up to 250 MB. **2. Click Build brand kit** Melius reads your sources and fills in the **Summary**, **Colors**, **Type**, **Logos**, and **Media** sections. This usually takes a few minutes. You can leave the page; a card in the sidebar tells you when the kit is ready. **3. Review each section** Fix anything that doesn't match your brand. See [Edit a brand kit](#edit-a-brand-kit). **4. Click Publish brand kit** Mel starts using the kit from your next prompt. Your team's first kit becomes its default. When you sign up with a work email, Melius starts reading your company's website for you during onboarding. If a reading fails, the message says why, for example a website that blocks reading or a PDF with no colors or fonts. Fix the source, or upload your guidelines PDF instead, and click **Build brand kit** again. ## Edit a brand kit Changes to colors, type, logos, and media save as you make them. Mel uses them from the next prompt. | Section | What Mel uses it for | How to edit | | - | - | - | | **Summary** | The tone and story behind every prompt | Hover the section and click **Edit** to change the summary, personality, audience, voice, and taglines | | **Colors** | Palettes in generated images and layouts | Add up to 6 colors by name and hex code. Drag to reorder | | **Type** | Headlines, body copy, and labels in designs | Search the Melius font library or click **Upload font** (`.woff2`, `.woff`, `.ttf`, `.otf`) | | **Logos** | Ads, social posts, and product shots | Add images from Files or upload new ones | | **Media** | References that keep products accurate in generations | Add images or videos from Files or upload new ones. Give each a clear **Name**, and add **Notes for Mel** to say what it's for, for example *"Halloween campaign ad"*. Mel reads both | To rename a kit, click its name at the top of its page, or choose **Rename** from its card's menu on the **Brand kits** page. ## Use brand kits with Mel Every new chat starts with your default brand kit, shown above the chat box. Mel follows its guidelines in every prompt in that chat. * **Use another kit in one chat.** Click the brand kit above the chat box and pick another published kit. The chat keeps that kit when you come back to it. New chats and new canvases still start with the default. * **Leave brand kits out of one chat.** Click the brand kit above the chat box and choose **No brand kit**, or turn off **Attach brand kit** in the chat's **+** menu. * **Add it back.** Turn on **Attach brand kit** in the chat's **+** menu. * **Put your logo on the canvas.** Ask Mel, for example *"Add our logo and two product shots from the brand kit."* Mel places up to 5 brand kit files per message. * **Try a kit on a new canvas.** In the brand kit's menu, choose **Try on canvas**. A new project opens with the kit loaded and starters such as **Create ads** and **Make graphics**. **Change the default.** On the **Brand kits** page, choose **Set as default** from a kit's menu. To stop new chats from starting with the default kit, turn off **Use brand kit in Mel by default** in **Settings → Agent → Brand kit**. You can still add it to any chat with **Attach brand kit** in the chat's **+** menu. ## Update or archive a brand kit **Update.** When your brand changes, choose **Update brand kit** from the menu. You can add a guidelines PDF to a kit read from a website, or point it at a new source. Mel keeps using the published kit until you click **Review update** and publish the changes. Each website can be read once a day. **Archive.** Choose **Archive brand kit** from the kit's menu. Mel stops using it, and it moves to the **Archive** tab on the **Brand kits** page for everyone on the team. Chats that used it go back to the default. Archiving the default kit makes your most recently published kit the default. Open an archived kit to view it, and click **Unarchive** to use it again. ## Who can change brand kits Owners, admins, and editors can build, edit, publish, update, archive, and unarchive brand kits, and choose the default. Viewers can see them. Members limited to selected projects can't use **Try on canvas**, because it creates a new project. See [Members & roles](/collaboration/members). ## Tips * **Upload your guidelines PDF if you have one.** The PDF decides your colors and typefaces. Add your website as well and Melius also collects logos and photography from it. * **Keep only the colors you use.** Six is the maximum. Remove accent colors you rarely use, since Mel treats every color in the palette as part of your brand. * **Add product shots to Media.** Clear, well-lit photos of each product keep generated products accurate. Name each one for what it shows, for example *"Hero bottle, front"*. * **Upload licensed fonts.** If a typeface is marked **Licensed font**, choose **Upload font file** from its menu so your designs use the real font. * **Write the summary as a brief.** Describe your voice and add a few taglines in your own words. Mel follows them in prompts, node titles, and copy. * **Put rules in Context.** For do's and don'ts such as *"Never show the product in direct sunlight"*, add them to [Context](/settings/agent#context) in **Settings → Agent**. Mel applies them alongside the brand kit. # Aspect ratios, durations, and resolutions Source: https://docs.melius.com/canvas/dimensions Output-shape settings per node. Generative nodes expose shape settings that get passed to the underlying model. ## Aspect ratios Supported aspect ratios across image and video models: `21:9` · `20:9` · `19.5:9` · `2:1` · `16:9` · `3:2` · `4:3` · `5:4` · `1:1` · `4:5` · `3:4` · `2:3` · `9:16` · `1:2` · `9:19.5` · `9:20` · `9:21` Not every model supports every ratio. The node UI hides ratios the selected model can't produce. Switching a node to another model keeps its aspect ratio when the new model supports it. Otherwise the node moves to the closest ratio the new model offers, so a `4:5` node moved to a model without `4:5` becomes `3:4`, not `16:9`. ### Set an aspect ratio on multiple nodes Select two or more image nodes, or two or more video nodes, and choose **Aspect ratio** in the **Generation settings** panel. The change applies to every selected node while preserving each node's model choice, including **Auto**. The dropdown offers ratios supported by all selected nodes, using their models and connected inputs. It stays disabled when the selection has no shared ratio. The setting applies to the next generation; existing outputs keep their original dimensions. ## Variations Select a generation node and choose **Variations** at the bottom of the top-right **Generation settings** panel. Choose 1–10 variations for image, video, or text nodes, or 1–4 for audio nodes. The count stays in sync with the variation stepper on the node and applies to its next run. To set the count for several nodes at once, select two or more generation nodes of the same type. **Variations** appears at the bottom of their shared **Generation settings** panel and applies to each selected node. The control shows **Mixed** when the selected nodes have different counts. Choosing a number gives them all that count while preserving their other settings. Nodes without their own count use the canvas default. ## Image resolutions | Tier | Notes | | - | - | | `0.5K` | Fastest, lowest cost. | | `1K` | Fast and cheap — good for drafting. | | `2K` | High detail. | | `4K` | Highest tier. Slower and more expensive. | ## Video resolutions | Tier | Notes | | - | - | | `360p` | Fastest, lowest cost. | | `480p` | Low cost. | | `540p` | Low cost. | | `580p` | Low cost. | | `720p` | Fast, good for drafts. | | `768p` | Between 720p and 1080p on some models. | | `1080p` | Default. | | `1440p` | High detail. | | `2K` | High detail on supported models. | | `2160p` | 4K UHD on supported models. | | `4k` | Highest tier. Slower and more expensive. | ## Durations Video nodes accept a clip duration in seconds, bounded by what the chosen model supports. Each video model has its own min/max — the node UI clamps your selection to that range. ## Set the defaults for new nodes Each model carries its own starting resolution, so a new node inherits whatever the selected model prefers — for most image models that's `2K`. Override it once and every node your team creates afterwards starts there instead: 1. Open the hamburger menu in the canvas menu bar, click **Settings**, then go to **Team** > **Preferences** 2. In the **Generation preferences** card, pick **Image** or **Video** 3. Pick a **Resolution** The same card sets the default **Model**, **Aspect ratio**, **Variations**, and — for video — **Duration**. Text and audio have their own tabs. **Model** opens the same model picker as a node's toolbar, with search and the **Auto** switch. Individual nodes still override their own settings from the node toolbar, so a team defaulting to `1K` for drafting can hold a `4K` node for the final render. These are your team's defaults, and they apply to every canvas in the team. Owners, admins, and editors can change them; viewers see them read-only. Pinning a model in a node's model picker or bookmarking a font in the Better Fonts picker also changes them for the whole team. ### Your own defaults To start your own nodes differently from the team, open **Settings**, go to **Account** > **Preferences**, and change any setting in **Generation preferences**. Each menu starts on the team's value, listed as **Team default**. A setting you change applies only to the nodes you create, on every team you belong to, including nodes Mel creates for you. Settings you leave on **Team default** keep following the team. Choosing your own model also starts that model's aspect ratio, resolution, duration, and voice from the model's own defaults, since the team's choices may not suit it. Variations still follow the team. # Edges & data flow Source: https://docs.melius.com/canvas/edges How outputs from one node feed into another. An **edge** is a directed wire from one node to another. The downstream node receives the upstream node's output as part of its prompt context. Think of it like attaching an image or file to a message in an AI chat — when you connect one node to another, Melius appends the upstream node's data (its text, image, video, or audio) to the end of the downstream node's input. The downstream model sees your prompt *plus* whatever the upstream node produced. ## Edge data types Edges are typed. The type matches the upstream output: * `text` — written output from a text node or the literal content of a `custom_text` node. * `image` — a generated or uploaded image. * `video` — a generated or uploaded video clip. * `audio` — a generated or uploaded audio clip. * `file` — an uploaded image asset. Downstream nodes accept the input types supported by their selected model. A text-to-image model accepts a text prompt; using an image reference requires a model with image inputs. When you switch an image or video node's model, its prompt reference strip shows connections to inputs the selected model accepts. Other connections stay saved and reappear when you switch back to a compatible model. Saved `@mentions` remain in your prompt, with a warning when the model skips their inputs. You can still run the node with its supported inputs. ## Creating edges * **By dragging** — drag from a source node's output handle to a target node's input handle. * **By @-mention** — type `@` inside a prompt and pick a node. Melius creates an input edge automatically. * **Programmatically** — see [`edge_create`](/mcp/tools#edges). ### Connect one source to several nodes 1. Hold `Shift` and click each destination node to select it. 2. Drag the source node's output to a matching input on any selected destination. 3. Check the preview wires, then release to connect all compatible selected destinations. For example, select your image and video nodes, then drag a text node's output to one selected node's **Text** input. Every compatible selected node receives the shared text alongside its own prompt. You can mix destination types and select individual nodes inside groups. Unselected siblings are not connected. Destinations that cannot accept the input are labeled in the preview, and existing connections are skipped. One undo removes the connections created by the gesture. Dropping onto an unselected node creates a single connection. Dragging from an input back to an output keeps the existing behavior for that direction. To feed the same set of inputs to many nodes and keep adding to it later, wire the inputs into a [Router](/canvas/nodes#routing-inputs-to-several-nodes) instead. ### Connect several sources at once 1. Hold `Shift` and click each source node to select it. 2. Drag the output of any selected source to the destination input. 3. Check that a preview wire leaves every selected source, then release. The selected sources must all produce the same type of output, such as images and uploaded image files. This includes nodes inside a group, whether you select them one by one or drag a selection box around the group. If any selected source produces a different output, only the node you dragged from connects. ## Removing edges Click an edge to select it, then press `Delete`. Removing the edge does not affect either node's existing versions — only the next run will reflect the change. To cut several edges, press `X` for the **Scissor** tool, then click an edge or drag across edges to cut every one the stroke crosses. Press `X` again or `Esc` to go back to **Select**. # Nodes Source: https://docs.melius.com/canvas/nodes The building blocks of a canvas. A node is a single unit on the canvas. Every node has a type that determines what it produces. ## Node types | Type | What it does | | - | - | | `text` | Runs a language model and produces text. | | `image` | Runs an image model and produces an image. | | `video` | Runs a video model and produces a video clip. | | `audio` | Runs an audio model and produces sound — speech, music, or sound effects. | | `file` | Holds a file you uploaded: an image, video, audio file, or PDF. No generation runs on this node. | | `custom_text` | A static block of text with Raw and Markdown views. Use it for reusable prompt fragments or a `.md` file. | | `router` | Collects inputs of one type and passes them to every node it feeds. No generation runs on this node. | | `group` | A visual container that holds other nodes. | ## Anatomy Every generative node has: * A **prompt** — the user-authored instructions. * A **model** — the AI model that will run. * **Settings** specific to its type (aspect ratio, resolution, duration, etc.). * **Input handles** — where edges come in. * **Output handles** — where edges go out. * **Versions** — one per run. ## Creating nodes You can create nodes by: * Clicking the canvas toolbar. * Pressing `/` and typing the node type. * Dragging from the output handle of an existing node (Melius will offer to create a matching downstream node). * Calling [`node_create`](/mcp/tools#nodes) from the MCP server. ## Comparing images and videos Select two or more nodes with image or video outputs, then click **Compare** in the selection toolbar. Compare opens a temporary dialog. Use the **Left** and **Right** dropdowns to choose a pair, even when only two nodes are selected. Choose **@ Mention image or video** in either dropdown to pick another image or video output from anywhere on the canvas. Text and audio are excluded. Drag the divider to compare the outputs, or choose **Side by side**. Use **Swap sides** to reverse the pair. **Fit** shows the full image; **Fill** crops the right output to the left output's frame when their shapes differ. Videos start paused and muted. Play, pause, and seek both clips together; the shorter clip shows when it has ended while the longer clip continues. Press **Escape** or click the close button to leave Compare. Comparing does not create a node, change connections, or use credits. ## Markdown files and custom text > [!NOTE] > > **Beta** — Markdown previews are rolling out gradually. Reach out to support > if you'd like access. Drag a `.md` file onto the canvas, choose it with **Upload**, or copy it and paste it on the canvas with `Cmd+V` (`Ctrl+V` on Windows) to turn it into a `custom_text` node named after the file. Drop or upload several files at once and they land together in a group. A `.md` file you paste or attach in Mel's chat becomes a custom text node too when you send the message. Each file can be up to 1 MB. Select a custom text node and use **View** in its floating toolbar to choose **Raw** or **Markdown**. Existing nodes start in Raw; imported Markdown files start in Markdown when previews are available. Markdown shows headings, lists, checklists, tables, quotes, and code blocks. Fullscreen shows it formatted too. A very long document shows its beginning on the canvas, with **Open fullscreen to read the rest** below it. Links open in a new tab, and images show their alt text. In Raw, click the text to edit. In Markdown, click once to select and scroll, then click again or press Enter on the focused preview to edit the source. Click away to return to your selected view. Switching views preserves the original text sent to connected nodes. ## Routing inputs to several nodes A **Router** collects inputs in one place and passes them to every node it feeds. Wire your reference images into a router once, then connect the router to as many nodes as you need. Each node it feeds runs, and quotes credits, as if every input were wired to it directly. ### Add a router * Select a node and press `R`. The new router is wired to the selected node's output. * Open the add-node menu or right-click the canvas, then choose **Router**. With the add-node menu open, you can also press `R`. * Drag a wire from a port to empty canvas and choose **Router**. To branch the router into a new node, select the router and press `I`, `V`, `T`, or `A`. Melius adds an image, video, text, or audio node and connects it to the router when the node accepts what the router carries. ### What a router carries A router carries one type of input: text, image, video, or audio. The first wire you connect sets the type, and the router refuses wires of any other type. A router takes any number of inputs. The nodes it feeds check their own input limits when they run. A router can feed text, image, video, and audio nodes, and other routers. A node receives a router's inputs in the order you connected them to the router. Each port shows how many wires it holds. Select a router to see what it carries in the details panel, such as "Routing 2 images", with the name of each input node. ### Rename a router Every router is named **Router** until you rename it. Double-click the name, press `Cmd+E` (`Ctrl+E` on Windows), or edit the name in the details panel. A router doesn't generate anything, so it has no versions and can't be resized. ## Copying between browser and desktop Select nodes and copy with `Cmd+C` (`Ctrl+C` on Windows). Open the destination canvas in your browser or the Melius desktop app and paste with `Cmd+V` (`Ctrl+V`). Connections within the selection, prompts, settings, and sticky notes travel with the copied nodes. Use Undo to remove a pasted selection. To paste at a specific spot, right-click empty canvas there and choose **Paste**. **With edges** keeps the copy's connections to the nodes that fed the originals. **Without edges** pastes the copy with nothing connected to it, which you can also do with `Cmd+Shift+V` (`Ctrl+Shift+V`). To move nodes instead, cut them with `Cmd+X` (`Ctrl+X`) and paste with `Cmd+V`. Cut copies the selection and removes it from the canvas, and the pasted nodes stay connected to the nodes you left in place. Undo puts a cut selection back. New sticky notes, including pasted or duplicated notes and notes in copied canvases or projects, are at least 240 pixels wide and 120–960 pixels tall. Wide notes can span a section of your canvas, including widths of 1500 pixels. Copies of older notes outside those limits are resized to fit; the original notes keep their saved dimensions. ## Downloading several outputs Select several nodes and click **Download** in the selection toolbar, or right-click the selection and choose **Download**. You get one ZIP with the current output of every selected image, video, audio, file, Stitch, and Studio node, including nodes inside selected groups. Nodes without an output are left out. ## Copying workflows between teams > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. Select a workflow and copy it with `Cmd+C` (`Ctrl+C` on Windows). Open a canvas in another team and paste with `Cmd+V` (`Ctrl+V`). You need access to the source team and editing access to the destination team. You can also paste between browser tabs and the desktop app. Paste copies image, video, audio, file, and text nodes, Studio edits, Stitch and Magic Resize nodes, routers, ordinary groups, and sticky notes. Editable layers, clip trims, audio placements, and generated resize images travel with the workflow. It preserves prompts, settings, layout, connections within the selection, and the selected output of each node. Media copies belong to the destination team; the original workflow and generation history stay in the source team. Wait for the copying message to finish before using the pasted workflow. If the copy fails, your canvas stays unchanged and you can retry. Undo removes the pasted selection. Select workflows that use standard media and Google fonts. Copy Elements, template instances, PDF extraction, custom voices, and LoRAs separately within their team. ## Comparing queued generations Press **Run** on an image or video node to add a generating thumbnail immediately. You can change the model, prompt, or settings and start another run while earlier runs continue. Select a generating thumbnail to view that run. **Prev** and **Next** move between runs. Viewing a queued run keeps the controls for your next run unchanged. When a generation finishes, its output appears while your next-run settings stay as you left them. Selecting a completed version explicitly restores that version's settings. ## Resizing text nodes Select a text node and hover near an edge to see the resize cursor. Drag the left or right edge to change its width, or the top or bottom edge to change its height independently. You can start the drag just outside the border. The corner handle also lets you resize the node, with a larger grab area around it that stays easy to target when zoomed out. Text scrolls inside the resized area. A node holding long text can be dragged taller until all of it shows. To fit the node to its text in one step, double-click the top or bottom edge or a corner. Your chosen height is saved with the canvas and retained when you duplicate the node. ## Resizing the prompt box on image and video nodes Long prompts scroll inside the box under an image or video. To see more of a prompt at once, select the node and drag its bottom edge down. The media keeps its size, and the box grows a line at a time. Drag up to shrink it again, down to four lines. The height is saved with the canvas, so everyone on the canvas sees the same layout. Double-click the bottom edge to return the box to sizing itself to its text. ## Reading PDFs fullscreen Select a PDF node and click **Fullscreen** in its toolbar, or press **F**. Press **Escape** or click **Close** to return to the canvas. The PDF reader shows the original document with page navigation and zoom controls, alongside its summary when available. You can download the PDF from the reader. Clicking an extracted image on the canvas still adds that image to the canvas. ## Reviewing magic resize results A magic resize node produces one image per aspect ratio you picked. Double-click any result to open it fullscreen; double-click the node anywhere else to open its first result. The view opens on the ratio you double-clicked, with every ratio from the run listed down the left — select one there, or press **←** and **→**, to move between them. Each ratio is a separate file, so its details and comments follow the one on screen. Select **Comment** (or press **C**), then click the spot on the image you want to talk about and write your note beside it, or write a general comment in the box at the bottom of the panel. Press **Esc** to leave comment mode. Download the ratio you are viewing from the button beside the image; on the canvas, hovering a result gives it a **Download** button, and the node's toolbar downloads the whole set. ## Groups Group nodes are containers. Select multiple nodes and choose **Group** to wrap them. Groups are useful for keeping a multi-step pipeline visually tidy. ### Browse a group fullscreen Open any image, video, or text node inside a group fullscreen (double-click it, or select it and press **F**). To start from the top of the group, select the group and click **Fullscreen** in its toolbar, or press **F**. The left column, titled with the group's name, lists every image, video, and text node in the group with its versions. Nodes are listed in the order your workflow runs: nodes that feed others come first, then the nodes they feed. Each node's versions sit under a heading with its name, which you can click to collapse. Click any version to show it. The list scrolls to keep the version you are viewing in the middle. Press **↑** and **↓** to step through versions, including from one node into the next. To rename an output, select its version first, then click its name in the selected row. Clicking the name of another node or version switches to it without opening the name editor. Renaming is available to members with editing access. To rearrange the nodes inside a group, drag-select the group and its contents, then `Cmd`-click (`Ctrl`-click on Windows) the group's label. That drops the group frame from the selection and leaves the nodes inside it selected, so dragging one moves them all without moving the frame. `Shift`-clicking the label drops the group and everything inside it. ### Create a template from a group Select a group and click **Convert to template** in its toolbar, or right-click the group and choose **Convert to template**. The review dialog includes the nodes inside nested groups and lets you configure the template's inputs and outputs. The original group stays intact. The group needs at least two content nodes. Groups containing an existing template instance are ineligible because templates cannot nest. ### View a template's outputs fullscreen On a template instance's **Output** tab, click **View fullscreen** or double-click the preview. Every version of the output is listed down the left, including each variation from a multi-variation run — select one there, or press **↑** and **↓**, to switch between them. Press **←** and **→** to move between the template's outputs. ### Find a template on the canvas The canvas **Templates** panel lists every template your team made and the Melius templates built for canvas workflows. Some Melius templates, such as trend looks, are on **Explore** instead; run those from Explore. ### Edit or remove a team template Team owners, admins, and editors can manage templates assigned to their team, including templates created by another member. In the canvas **Templates** panel, open the template's **More** menu and choose **Edit** or **Remove**. To edit the template behind a box already on the canvas, select the box and click **Edit** at the top of its details panel, or right-click the box and choose **Edit template**. In the editor, click a node in the workflow to change its model or prompt. Editing a template shared across teams updates the shared template for all of them. Choose **Duplicate** to make a separate copy for your team before editing. Removing a template only unassigns it from your team; other assigned teams keep access. When no teams remain, the saved template is hidden rather than deleted. You can create a new template with the same name after removing the old one. Existing canvas instances keep their saved workflow. If your team loses access to a template, its existing canvas instances and generated outputs stay on the canvas, but you cannot start another run. Hover over the disabled **Run template** button to see why. Reassigning the original template restores the ability to run it; a new template with the same name does not. Runs already in progress can finish. ## Previewing a stitch Before a Stitch node has a finished video, its card plays a preview of the connected clips in order. The preview is not the final video. Each clip that hasn't been generated yet plays as a short placeholder saying which clip it is, and a label on the preview counts how many clips are still missing. Generate those clips to see them in the preview. ## Opening stitch nodes fullscreen Double-click a Stitch node's body or video preview to open it fullscreen. Before the node has a finished video, this opens the stitch editor. Once the video is ready, it opens the video player. Press **Esc** to return to the canvas. ## Cropping a clip in the stitch editor Select a video or image clip in the stitch editor to show its handles on the preview. Drag the handle in the middle of any side to crop the clip from that side, to any shape. The rest of the clip stays where it is. Drag a side back out to restore what you cropped, up to the clip's original edge. The exported video uses the same crop. When the clip fills the whole frame, cropping it crops the whole video: the output takes the cropped shape instead of showing black around the clip. The new shape appears in the aspect ratio menu. Choose a preset ratio from that menu to switch back. ## Tools in fullscreen Open an image or video node in fullscreen, generated or uploaded, then click the **Tools** icon in the bottom bar to see its tools. The menu matches the node's image or video tools, including their settings. Tools become available once the node has output and is not generating. Every tool runs inside the fullscreen view. **Inpaint**, **Remove object**, and **Outpaint** draw over the fullscreen image, with their brush bar and prompt field anchored at the bottom of the view, floating over the image so it stays put; **Trim** and **Extract frame** open their scrubber above the bottom bar, below the video, and preview on the fullscreen player; **Edit image** opens the editor on top of the viewer. On the **Trim** bar, a line follows the video as it plays; hover the bar to preview any moment, and click or drag along it to move the video there. Press **Esc** or use the tool's exit button to return to the viewer. The same tools remain available from the node's toolbar on the canvas. The **Outpaint** prompt takes up to 500 characters. In **Edit image**, select a text box and press `Cmd+C`, then `Cmd+V` (`Ctrl+C` and `Ctrl+V` on Windows) to copy and paste it within the open editor. The copy keeps its text, formatting, and size, appears slightly offset, and is selected so you can move it. Each paste can be undone with `Cmd+Z` (`Ctrl+Z` on Windows). While typing inside a text box or field, these shortcuts copy and paste the text itself. While a generation or tool run is in progress, the versions list stays available: select any earlier version to view it, and select the **Generating** row to return to the run. When the run finishes, the viewer shows the new version. # Video node handles Source: https://docs.melius.com/canvas/video Wiring frames, references, and clips into a video node. A video node shows only the handles its selected model can use, so the ports change when you switch models or variants. Which handle you wire to decides how the upstream asset is used. ## Compare videos on the canvas Click **Play** on each video you want to compare. Videos keep playing when you start another clip or select a different node. You can pause or scrub each clip independently, including uploaded videos and stitch previews. Videos start muted. Click **Enable sound** on a clip to hear it; the other clips keep playing silently. While sound is enabled, starting another clip transfers sound to that clip. Opening fullscreen mutes the canvas previews behind it. ## Duration Set **Duration** in the node toolbar or the right-hand **Generation settings** panel. Both controls show the duration used for generation. When you have not selected a duration, the model's configured default applies; otherwise it starts at the shortest supported duration. Seedance 2.5 starts at 4 seconds. Choosing a longer duration in either control updates the next generation. Models driven by an input clip or audio track use that input's duration instead. For **Seedance 2.5** with exactly one video input and no image or audio references, **Duration** shows **Auto** and cannot be edited. The model chooses the output length. The credit quote and upfront charge use the source clip's duration, rounded up to whole seconds, plus the input-video charge. If the source duration is unavailable, the quote uses the model's default duration. Adding another reference restores the manual duration control. ### Input video limits **Duration** controls the generated output. Input videos have separate limits that depend on the selected model and mode. For example, Wan 3.0 can generate up to 30 seconds, but accepts at most 15 seconds of reference video in total. If an input clip is too long or too short, the error names the model, its input-duration limit, and your clip's length. Trim the connected input video or use a longer clip as directed; changing the output **Duration** does not change the input limit. Video-count errors also tell you how many clips the model accepts. Some models also cap the total length of all connected clips. When the clips run over that cap, the last clip is trimmed to fit. If that trim can't fit them, the run doesn't start and the error names the cap and your clips' total. Trim or remove a clip, then run again. When you run several nodes with **Run selected**, every connected clip is checked before anything runs. If a clip is too long or too short for its model, nothing runs and the node shows the model's limit. Trim the clip with its **Trim** tool, or connect a different clip, then run again. ## Input handles | Handle | Label | What it does | | - | - | - | | `text` | Text | Prompt context from a text or `custom_text` node. | | `starting_image` | Starting frame | The image the clip starts on (image-to-video). | | `end_image` | Last frame | The image the clip should end on. The model interpolates from the starting frame to it. | | `image` | Image | The generic image input. On a model with a reference-to-video endpoint it is treated as a reference image; otherwise it acts as the starting frame. | | `reference_image` | Reference image | An image the model matches for subject, character, or style across the whole clip. It does not pin any particular frame. | | `video` | Video | The **full clip** from an upstream video or video file node — used as the source for video-to-video, extend, and lipsync models. | | `audio` | Audio | An audio clip that drives the generation, for lipsync and other audio-driven models. | On **Flux 3 Keyframes**, the image input is labeled **Keyframes**. Connect the images you want the video to move through to this port. ### Pairing rules * A last frame only works alongside a starting frame. Connect the first frame to **Starting frame** and the last frame to **Last frame**. A reference image can't be the starting frame. * Frames and reference images are mutually exclusive unless the model accepts both — for example the reference-to-video variants of Kling 3.0 Omni and MiniMax H3 Max. When a run is rejected for combining them, disconnect the reference images to animate between your frames, or disconnect the frames to generate from the reference images. * Each model caps how many image and reference-image inputs it accepts. Wiring more than the cap is rejected. ## Output handles | Handle | Label | What it does | | - | - | - | | `video` | Video | The generated clip. | | `last_frame` | Last frame | The final frame of the clip, as an image. Video file nodes expose this too. | | `audio` | Audio | The generated audio track. Only models that produce sound expose this handle. | ## Shot chaining To produce a multi-shot sequence: 1. Create your first video node and run it. 2. Add a second video node downstream. 3. Drag from the first node's **Last frame** output to the second node's **Starting frame** input. 4. Prompt the second node with how the action should continue. Each shot picks up exactly from the previous shot's last frame, so motion and composition stay consistent. To carry a character or style across shots instead of an exact frame, wire the same image into every node's **Reference image** handle. ## Playback of oversized uploads > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. Uploaded videos wider or taller than 4096 pixels are harder for phones and many laptops to decode, so playback can stutter. For those uploads, Melius prepares a processed H.264 MP4 that fits within 3840 × 2160 (or 2160 × 3840 for portrait video) and plays it in the canvas fullscreen viewer, the Files viewer, public asset links and files opened from a public folder link. The original file is kept unchanged. A freshly uploaded oversized video shows a loading spinner labelled **Preparing** until the copy is ready; the viewer updates on its own. If preparation fails, the viewer plays the original file instead. Smaller uploads and generated videos play as before. ## Download oversized uploads > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. For uploaded videos wider or taller than 4096 pixels, **Download** hands back the original file until the processed copy is ready. Once it is, **Download** selects the **Optimized** MP4 by default: an H.264 file that keeps the aspect ratio, fits within 3840 × 2160 (or 2160 × 3840 for portrait video), runs at up to 30 frames per second and carries stereo AAC audio, so it plays smoothly on more devices. Open **Download options** beside the button, or the **Download** submenu in a file's menu, to pick **Original** whenever you need the source's full resolution, frame rate, colour and audio for editing. The original is always available and never changes. The menu shows each file's dimensions and size, and marks the **Optimized** row **Preparing** while the copy is still being made. Choosing **Optimized** before it has been prepared, or after a failed preparation, starts the preparation and downloads the file when it is ready; keep the page open. This choice appears in Files, canvas viewers, Playground, Cast, public asset links and public folder links. Smaller videos keep their existing download action, and bulk ZIP downloads plus API, CLI and MCP downloads always include original files. # Using mel from an agent Source: https://docs.melius.com/cli/agents Drive Melius from an AI agent with headless auth, JSON output, and deterministic exit codes. `mel` is built **agents-first**: an AI agent with shell access can create canvases and run generations without any human in the loop. Three properties make it reliable to automate. * **JSON on stdout, always.** Success is structured JSON; there are no prompts, spinners, or color codes to parse around. * **Deterministic exit codes.** Branch on the [exit code](/cli/commands#exit-codes-and-errors) alone — `0` success, `3` auth, `4` timeout — without reading text. * **Structured errors with fixes.** Every error is JSON on stderr with a `code` and a `suggestion` naming the command to recover. ## Headless authentication Set the key as an environment variable — nothing is written to disk and no `mel auth login` step is needed: ```bash theme={null} export MEL_API_KEY=mel_... export MEL_BASE_URL=https://api.melius.com # optional; the default ``` The key's own team is used automatically. To act on a different team the user is a member of, set `MEL_TEAM_ID` — your role is scoped per team, just like the app. In a sandbox, allow network egress to `api.melius.com` (or `*.melius.com`). ## Parsing output Capture ids with `--fields --text`, or pipe full JSON through `jq`: ```bash theme={null} # Just the id, for a shell variable CANVAS=$(mel canvas create "$PROJECT" --title "Ad set" --fields id --text) # Full object → jq mel canvas content "$CANVAS" | jq '.nodes[] | {id, type: .nodeType, status}' ``` ## Branching on exit codes ```bash theme={null} mel run wait "$RUN" case $? in 0) mel run download "$RUN" ;; # finished → get the output 4) echo "still running, will re-check" ;; # timeout → poll again later *) mel run get "$RUN" ;; # failed → inspect the error esac ``` ## CLI or MCP? Both let an agent drive Melius, over the same backend and API keys — choose by how your agent runs: | Use the... | When your agent... | | - | - | | **CLI** (`mel`) | Has shell access — a coding agent, a CI job, or a sandbox with a terminal. It chains commands and parses JSON. | | **[MCP server](/mcp/overview)** | Runs in a chat client that speaks MCP (Claude, ChatGPT desktop, Codex) and calls tools directly, with no shell. | If your agent already has a terminal, `mel` is usually the simplest path — one install, `MEL_API_KEY`, and it's driving the canvas. ## Next steps > [card] [Command reference](/cli/commands) > > Every command, flag, exit code, and error shape. > [card] [MCP server](/mcp/overview) > > Connect a chat-based agent over the Model Context Protocol. # Command reference Source: https://docs.melius.com/cli/commands Every mel command, grouped by resource, plus global flags and exit codes. Run `mel --help` or `mel --help` at any time for the same reference in your terminal. Every command that creates a resource auto-generates a UUID if you don't pass `--id`, and returns the created object as JSON. ## Authentication | Command | Description | | - | - | | `mel auth login --api-key ` | Store and validate an API key in `~/.mel/config.json` | | `mel auth logout` | Clear stored credentials | | `mel auth whoami` | Show the current user (id, name, email) | | `mel auth create-key --name ` | Create a new API key (raw key shown once) | | `mel auth list-keys` | List keys for the current team | | `mel auth revoke-key --key-id ` | Revoke an API key (takes effect immediately) | ## Teams | Command | Description | | - | - | | `mel team list` | List the teams your key can act on (find a `teamId` here) | | `mel team current` | Show the active team | | `mel team switch ` | Set the active team | ## Projects | Command | Description | | - | - | | `mel project list` | List projects in the current team | | `mel project get ` | Get a project by id | | `mel project create --title ` | Create a new project | ## Canvases | Command | Description | | - | - | | `mel canvas create ` | Create a canvas (returns the `id` used by every later command and the `canvasUrl` to open it) | | `mel canvas list ` | List canvases in a project | | `mel canvas get ` | Get canvas metadata | | `mel canvas content ` | **Primary read** — live canvas state; add `--node-id` and `--include-all-versions` to inspect one node plus its edges | | `mel canvas plan-layout ` | Compute positions for planned nodes (read-only) | | `mel canvas delete ` | Delete a canvas and all its content | `mel canvas content --node-id ` also returns `canvasUrl` to open the node or group in Melius. The link uses existing canvas permissions. If the extra canvas metadata lookup fails, the successful content result is returned without this optional field. ## Nodes Node mutations write directly to the live canvas — changes sync to connected browser clients in real time. | Command | Description | | - | - | | `mel node create --type ` | Add a node, including `custom_text`, `text`, `image`, `video`, `file`, or `group` | | `mel node bulk-create --json -` | Create multiple nodes **and** edges in one call | | `mel node update ` | Update fields (prompt, title, geometry, model) | | `mel node bulk-update --nodes -` | Update up to 200 nodes in one call | | `mel node delete ` | Remove a node and its orphaned edges | | `mel node get ` | Read a persisted node (prefer `mel canvas content` for live state) | | `mel node set-version --version-id ` | Switch the active output version | | `mel node set-text --text ` | Replace a custom text node's content; accepts stdin when `--text` is omitted | | `mel node group --node-ids ` | Group existing nodes (computes the bounding box) | | `mel node ungroup ` | Ungroup and delete the group | **`mel node create` options:** ``` --type REQUIRED. Includes custom_text, text, image, video, file, group --id Auto-generated if omitted --title Defaults to the type name ("Image", "Text", …) --prompt <text> Text prompt --content <text> Literal content for custom_text nodes --text-view <view> raw or markdown for custom_text nodes --model <m> Model name (requires --variant) --variant <v> Model variant (requires --model) --quality <q> Image quality ID (requires --model and --variant) --aspect-ratio <r> 21:9, 16:9, 4:3, 3:2, 1:1, 2:3, 3:4, 9:16, 9:21 --duration <n> Output duration in seconds (video only) --x --y --w --h Geometry (sensible defaults per type) --z-index <n> Stacking order --group-id <uuid> Parent group ``` `mel node update` takes the same options (all optional); geometry must be updated as a full set (`--x --y --w --h` together). Use `mel model list --category image` to find each variant's `qualityOptions` and `defaultQuality`. Pass an option ID with `--quality` on node creation, node updates, or `mel run start`; bulk-create JSON accepts `quality` on each node. Quality affects the credit price. Omitting it from an explicit model selection uses that variant's default. To color a group, pass `--color` to `mel node group` or `--group-color` to `mel node update`. Colors: `default`, `amber`, `blue`, `purple`, `olive`, `red`, `pink`, `green`, `yellow`. ### Choose a custom text view > [!NOTE] > > **Beta** — Markdown presentation is rolling out gradually. Reach out to > support if you'd like access. Use `--text-view raw` or `--text-view markdown` when creating, updating, or replacing a custom text node's content: ```bash theme={null} mel node create <canvasId> --type custom_text --content "# Brief" --text-view markdown mel node update <canvasId> <nodeId> --text-view raw mel node set-text <nodeId> --text "# Revised brief" --text-view markdown ``` Omitting the option uses Raw for new nodes and preserves the saved view on updates and text replacements. Changing only the view keeps the source text and downstream inputs intact. Canvases without Markdown access show Raw while retaining the saved choice. Bulk-create and bulk-update JSON accept `textView: "raw"` or `textView: "markdown"` on each node. ### Switch a node back to Auto Clear a saved model with: ```bash theme={null} mel node update <canvasId> <nodeId> --auto ``` Omitting model options preserves the saved choice. `--auto` cannot be combined with `--model`, `--variant`, `--tier`, or `--quality`. ### Replace a shot in a stitch `mel stitch get <canvasId> <stitchNodeId>` returns the saved edit's revision and each shot's list index or timeline clip ID. Pass that revision and exactly one shot to `mel stitch clip-replace`: ```bash theme={null} mel stitch clip-replace <canvasId> <stitchNodeId> --revision <revision> --source <oldNodeId> --replacement <newNodeId> --index 2 mel stitch clip-replace <canvasId> <stitchNodeId> --revision <revision> --source <oldNodeId> --replacement <newNodeId> --clip-id <clipId> --on-duplicate ``` The new take must be the same media kind and cover the shot's duration. Other shots, effects and audio tracks stay as saved, and the previous edit is kept as a connected stitch copy. The edit is saved but not rendered: run the returned `nodeId` to render it. ## Edges | Command | Description | | - | - | | `mel edge create <canvasId> --src <id> --dst <id> --type <t>` | Connect two nodes. Types: `text`, `image`, `video`, `file` | | `mel edge bulk-create <canvasId> --json -` | Create multiple edges at once | | `mel edge delete <canvasId> <edgeId>` | Remove an edge | Edge type determines data flow — an `image` edge passes the source node's image output to the destination. ## Runs A run generates or post-processes the output for a single node. | Command | Description | | - | - | | `mel run start <nodeId> --canvas-id <canvasId>` | Start a generation. Returns `{ id }` | | `mel run tool <nodeId> --canvas-id <canvasId> --tool remove-background` | Remove a finished image's background in place. Returns `{ id }` | | `mel run get <runId>` | Status: `pending`, `running`, `finished`, `failed` | | `mel run wait <runId>` | **Block until done.** Exit `0` = finished, `1` = failed, `4` = timeout | | `mel run latest <canvasId>` | Latest run status for every node on a canvas | | `mel run download <runId>` | Presigned URL for a finished run's output | | `mel run magic-resize <sourceNodeId> --canvas-id <id> --ratios <list>` | Resize a finished image into up to 5 aspect ratios in one call | **Auto-model resolution.** When `--model`/`--variant` are omitted, `mel run start` resolves the right model from platform defaults — including picking image-to-image when the node has an incoming image edge. `--canvas-id` is required so the CLI can verify the node and do edge-aware detection. ```bash theme={null} mel run start <nodeId> --canvas-id <canvasId> # auto mel run start <nodeId> --canvas-id <canvasId> --model flux-pro --variant text-to-image mel run start <videoNodeId> --canvas-id <canvasId> --post-process video-gif # convert the finished clip to a GIF ``` **Node tools.** `mel run tool` post-processes a node's finished asset and creates a new active version on the same node. The currently supported tool is `remove-background` for image nodes and file nodes that contain images. It runs Pixelcut (20 credits). ```bash theme={null} RUN=$(mel run tool <imageNodeId> --canvas-id <canvasId> --tool remove-background --fields id --text) mel run wait "$RUN" mel canvas content <canvasId> --node-id <imageNodeId> --include-all-versions ``` ## Bulk runs Run an entire canvas in dependency order. | Command | Description | | - | - | | `mel bulk-run start <canvasId>` | Run all nodes tier by tier. Add `--wait` to block, `--node-ids <ids>` to scope, `--post-process video-gif` to convert the final clip to a GIF, `--match-clip-length-to-audio <ids>` to size clips that play their audio as recorded to that audio, and `--start-clips-together` to start clips fed by chained script nodes at once after the scripts finish | | `mel bulk-run get <bulkRunId>` | Status and per-node progress | | `mel bulk-run wait <bulkRunId>` | Block until done. Exit `0` = finished, `1` = failed, `4` = timeout | | `mel bulk-run download <bulkRunId>` | ZIP of leaf-node outputs → `{ url, filename, size }` | Downstream nodes wait for their inputs; if a node fails, its dependents are skipped while independent branches continue. ZIPs from `mel run download`, `mel bulk-run download` and `mel canvas download` include a `manifest.json` that maps each file to its asset, node, version and run. The [MCP tool reference](/mcp/tools#downloads) lists its fields. ## Presets Presets are pre-built canvas layouts (nodes, edges, and groups) expanded onto the canvas so you can see and edit every node. | Command | Description | | - | - | | `mel preset list` | List available presets | | `mel preset apply <canvasId> <presetId>` | Create all of a preset's nodes, edges, and groups with proper layout | ## Templates Templates are opaque, reusable canvas workflows. Applying one drops a single collapsed box onto the canvas that exposes only its public input/output ports — the internal workflow stays private. When you set a team with `mel team switch <teamId>` or `MEL_TEAM_ID`, `mel template list` puts templates targeted at that team before global templates. Apply the returned `id` to use that team's current workflow. | Command | Description | | - | - | | `mel template list` | List available templates with their `id`, title, declared `inputPorts`/`outputPorts`, and `estimatedCreditCost` | | `mel template apply <canvasId> <templateId>` | Apply a template as one collapsed box — returns its `instanceId` and `groupId` | **`mel template apply` options:** ``` --center-x <n> X center for the box (auto-placed if omitted) --center-y <n> Y center for the box (auto-placed if omitted) --inputs <json> JSON array of text, library-asset, or media-URL inputs targeting port IDs ``` Each input targets a `portId` from `mel template list` and is one of: * **Text** — `{ "kind": "text", "portId": "<id>", "text": "…" }` * **Library asset** — `{ "kind": "asset", "portId": "<id>", "assetId": "<id>", "mediaType": "image|video|audio|pdf" }` — an asset already in your library (find one with `mel asset search`) * **Media URL** — `{ "kind": "assetUrl", "portId": "<id>", "url": "https://…", "mediaType": "image|video|audio|pdf" }` — Melius fetches the URL and stores it as an asset, so you can use an image or video already hosted elsewhere without uploading it first > [!NOTE] > > **Beta** — media-URL (`assetUrl`) inputs are rolling out gradually. Reach > out to support if you'd like access. After applying, run the box with `mel bulk-run start <canvasId> --node-ids <groupId> --wait`: ```bash theme={null} mel template list # Wire an image already hosted on your site straight into a template port mel template apply <canvasId> <templateId> \ --inputs '[{"kind":"assetUrl","portId":"image","url":"https://example.com/photo.jpg","mediaType":"image"}]' mel bulk-run start <canvasId> --node-ids <groupId> --wait ``` ## Models | Command | Description | | - | - | | `mel model list --category <text\|image\|video>` | Discover models, modes, aspect ratios, and credit costs | | `mel model defaults` | Show the auto-model defaults per node type | ## Audio & fonts | Command | Description | | - | - | | `mel audio voice list` | List available ElevenLabs voices for text-to-speech and audio-to-audio nodes; page with `--cursor <nextCursor>` | | `mel font list` | List the team's uploaded custom fonts (for the `better-font-32b` image model) | ## Comments | Command | Description | | - | - | | `mel comment list <canvasId>` | List comment threads | | `mel comment create <canvasId> --body <text> --x <n> --y <n>` | Start a thread at a canvas position | | `mel comment reply <threadId> --body <text>` | Reply to a thread | | `mel comment resolve <threadId>` | Mark a thread resolved | ## Presence Show the agent's live "working here" region on a canvas — visible in real time to everyone with the canvas open. | Command | Description | | - | - | | `mel presence claim <canvasId>` | Claim a region — `--node-ids <ids>` for existing nodes, `--bounds <x,y,w,h>` for empty space | | `mel presence release <canvasId>` | Release the claim (the overlay disappears for all viewers) | Pass `--agent-name <name>` to `mel presence claim` to name the agent shown on the claim overlay. Pass the same `--presence-id <uuid>` to `mel presence claim` and `mel presence release` to keep your overlay separate from other agents working on the same canvas. `mel presence release` prints `removed: false` when no overlay with that ID was showing. A claim you never release disappears on its own five minutes after your last request to Melius. ## Assets Search your team's **Files library** (past uploads and generations) and place existing assets onto a canvas by reference — no re-upload, no duplicate. Requires a **Pro or Enterprise** plan. | Command | Description | | - | - | | `mel asset search [query]` | Semantic search of the team library, exact filename/title matches first. Returns up to 20 matches per page, each with `assetId`, `filename`, `displayName`, `fileType`, `contentType`, and preview URLs | | `mel asset folders` | List the team's Files folders (`id`, `name`, `path`, `fileCount`) — resolve a folder name to an `id` for `--folder-id` | | `mel asset place <canvasId> <assetIds...>` | Place existing assets onto a canvas by `assetId` (up to 10) — references the original asset and returns the created file `nodeId`s | **`mel asset search` options:** ``` --limit <n> Max results per page, 1–20 (default 20) --offset <n> Skip the first N matches to page deeper (default 0) --cursor <cursor> Continue from a previous result's nextCursor (same query and filters) --file-type <type> Filter by media type: image, video, audio, pdf, text --source <source> Filter by asset source: upload or generated --canvas-id <id> Scope to one canvas's assets (filename match within it) --folder-id <id> Scope to one folder and its subfolders (from mel asset folders) --tags <names> Filter to assets carrying ALL of these tags (comma-separated) ``` The query is **optional** when you pass `--folder-id` or `--tags` — omit it to bring in a whole folder or every tagged asset. Every filter applies together. The response is `{ query, total, results, hasMore, nextCursor }`; while `hasMore` is true, pass `nextCursor` to `--cursor` with the same query and filters for the next page. `mel asset search` returns `assetId`s — feed them straight into `mel asset place`, then wire the resulting nodes into generations with `mel edge create`: ```bash theme={null} mel asset search "black jacket shot" --file-type image mel asset folders # find a folder id mel asset search --folder-id <folderId> # bring in a whole folder mel asset place <canvasId> <assetId1> <assetId2> ``` ## Uploads Upload adds a **new** local file; [`mel asset search`](#assets) reuses one already in the team library. | Command | Description | | - | - | | `mel upload <filePath>` | Upload a local image → `{ assetId, url, … }` | | `mel upload <filePath> --node-id <id>` | Upload and link to an existing node | | `mel upload <filePath> --canvas-id <id>` | Upload and associate with a canvas | | `mel upload <filePath> --tags <a,b>` | Upload and tag the file in **Assets** | `--tags` takes comma-separated names. Each matches one of your team's tags ignoring case, and a new name creates the tag. Find tagged files with `mel asset search --tags`. Supported formats: PNG, JPEG, GIF, WebP, AVIF, SVG, HEIC, and HEIF. To use your own video, audio file, or PDF, drop it onto a canvas in the Melius app. ## Configuration | Command | Description | | - | - | | `mel config get [key]` | Show all config, or one key | | `mel config set <key> <value>` | Set `apiKey`, `baseUrl`, or `teamId` | | `mel config path` | Print the config file path (`~/.mel/config.json`) | ## Shell completion | Command | Description | | - | - | | `mel completion bash` | Print a bash completion script | | `mel completion zsh` | Print a zsh completion script | | `mel completion fish` | Print a fish completion script | Generated from the live command tree, so completions never drift. See [Installation → Shell completion](/cli/installation#shell-completion) for one-line setup per shell. ## Global flags Available on every command: ``` --json JSON output (default) --text Tab-separated plain text --fields <csv> Select specific fields, e.g. --fields id,title,status --quiet Suppress output, exit code only --verbose Log request/response metadata to stderr (never your key) ``` ## Exit codes and errors `mel` uses deterministic exit codes so scripts and agents can branch on the result without parsing text: | Code | Meaning | What to do | | - | - | - | | `0` | Success | Parse stdout | | `1` | API error (4xx/5xx) | Read the error message | | `2` | Usage error (bad args) | Fix the command | | `3` | Auth error (401/403) | Re-authenticate or check the team | | `4` | Timeout | Retry or raise `--timeout` | | `5` | Network error | Check connectivity | Errors are structured JSON on **stderr**: ```json theme={null} { "error": { "code": "UNAUTHORIZED", "message": "Invalid or expired API key", "status": 401, "suggestion": "Run: mel auth login --api-key <key>" } } ``` Every error carries a machine-readable `code`, a human-readable `message`, and usually a `suggestion` with the exact command to fix it. ## Rate limiting There is no monthly request quota on any plan, but a burst of requests can still be rate limited. On a `429`, `mel` prints `Rate limited — waiting Ns…` to **stderr**, honors the `Retry-After` header (or backs off exponentially), and retries — so polling commands like `mel run wait` ride through a limit. stdout stays clean. After repeated `429`s it gives up with a `RATE_LIMITED` error (exit `1`). ## Sticky notes `mel canvas content <canvasId>` includes a `notes` array with note text, color, geometry and group membership. Use `--note-id <noteId>` to inspect one note, or `--note-offset 0` to read notes in pages of 50; continue with `nextNoteOffset` until it is null. Positions are relative to the parent group when `groupId` is set. ```bash theme={null} mel note create <canvasId> --body "Alex" --color blue --x 0 --y -120 --width 1500 --height 120 mel note update <canvasId> <noteId> --color purple mel note update <canvasId> <noteId> --body "Alex — character sheets" --height 320 mel canvas content <canvasId> --note-id <noteId> mel note delete <canvasId> <noteId> ``` Set `--width` to at least 240 and `--height` from 120 to 960. Widths such as 1500 are supported. Values below the minimum or above the height limit are clamped, and a short wide note works as a label bar. Text stays at its chosen size when the note is resized. Long text scrolls inside the note. A side stored outside its range keeps its size until you change it. Create and update return the saved note, including its color. Choose `--color yellow|pink|blue|green|purple`; new notes default to yellow, and updates preserve omitted fields. Delete returns `{ "message": "Deleted", "noteId": "<note-id>" }`. All three write commands require editor access. # Installation Source: https://docs.melius.com/cli/installation Install the mel CLI and authenticate with a Melius API key. ## Install Install `mel` with npm or Homebrew: ```bash npm theme={null} npm install -g @melius-ai/cli ``` ```bash Homebrew theme={null} brew install melius-ai/tap/mel ``` npm requires **Node.js 20 or later**; Homebrew (macOS and Linux) pulls Node in for you. Verify either way: ```bash theme={null} mel --version ``` ## Update Check your installed version with `mel --version`, then upgrade with the **same tool you installed with**: ```bash npm theme={null} npm install -g @melius-ai/cli@latest ``` ```bash Homebrew theme={null} brew update && brew upgrade mel ``` > [!NOTE] > > On Homebrew, always run `brew update` first — it refreshes the tap so > Homebrew sees the newest formula. A bare `brew upgrade mel` can report > "already installed" because your local copy of the tap is stale. `mel` also nudges you when a newer version is published: after a command finishes, a one-line notice prints to `stderr` (never in JSON output, and never for agents or piped/non-interactive output). Silence it with `MEL_NO_UPDATE_NOTIFIER=1`. Releases follow [semantic versioning](https://semver.org) — a major bump (for example `1.x` → `2.x`) can include breaking changes, so review what changed before upgrading across one. ## Get an API key `mel` authenticates with a Melius API key. Create one in the Melius app under **Team settings → Integrations** — give it a name, then copy it when it's shown (you only see it once). See [API authentication](/api/authentication) for how keys are scoped. > [!WARNING] > > Treat an API key like a password. Don't commit it to source control or paste > it into client-side code. Set it from an environment variable or a secrets > manager. ## Authenticate There are two ways to give `mel` your key — pick one. > [tab] Interactive (log in once) > > Store the key in `~/.mel/config.json` so every command picks it up automatically: > > ```bash theme={null} > mel auth login --api-key mel_... > ``` > > Confirm it worked: > > ```bash theme={null} > mel auth whoami > ``` > > This returns your user (id, name, email). Clear stored credentials any time with `mel auth logout`. > [tab] Environment variables (CI & agents) > > For CI, containers, or an agent sandbox, set env vars instead — nothing is written to disk: > > ```bash theme={null} > export MEL_API_KEY=mel_... > export MEL_BASE_URL=https://api.melius.com # optional; this is the default > ``` > > Every command reads `MEL_API_KEY` on each run. This is the recommended setup for [driving `mel` from an agent](/cli/agents). ## Configuration `mel` resolves settings in this order — **environment variables → config file → defaults**: | Setting | Env var | Config key | Default | | - | - | - | - | | API key | `MEL_API_KEY` | `apiKey` | — | | Base URL | `MEL_BASE_URL` | `baseUrl` | `https://api.melius.com` | | Team | `MEL_TEAM_ID` | `teamId` | the key's team | Inspect or change the config file: ```bash theme={null} mel config get # show all config mel config set teamId <teamId> mel config path # → ~/.mel/config.json ``` ## Choosing a team An API key acts as the user who created it, and can act on **any team that user is a member of**. Requests default to the team the key was created in; to act on another, set a team id: ```bash theme={null} mel team list # teams your key can act on mel team switch <teamId> # or export MEL_TEAM_ID=<teamId> ``` Your permissions are scoped **per team, exactly like the app** — a key never grants more than your own role in the team you're acting on. If you're an owner in the team where you made the key but only an editor in another, switching to that team lets you create and edit content there, but **not** owner/admin-only actions (managing members, billing, or team settings); a viewer can only read. Switching teams never escalates what you can do. ## Shell completion `mel` generates tab-completion scripts for bash, zsh, and fish. They're built from the live command tree, so they never drift from the commands you have installed. ```bash bash theme={null} echo 'eval "$(mel completion bash)"' >> ~/.bashrc ``` ```bash zsh theme={null} echo 'eval "$(mel completion zsh)"' >> ~/.zshrc ``` ```bash fish theme={null} mel completion fish > ~/.config/fish/completions/mel.fish ``` Open a new shell (or re-source your rc file), then press Tab after `mel` to complete command groups and their subcommands. ## Next steps > [card] [Quickstart](/cli/quickstart) > > Run your first generation end to end. > [card] [Command reference](/cli/commands) > > Every command, flag, and exit code. # CLI overview Source: https://docs.melius.com/cli/overview Drive Melius canvases and generations from your terminal with the mel CLI. `mel` is the Melius command-line interface — create projects and canvases, add nodes, wire edges, run generations across the latest image, video, audio, and language models, and download the results, all from your terminal or a script. > [!NOTE] > > You authenticate with an API key. Create one in the Melius app under **Team > settings → Integrations**. See [Installation](/cli/installation). ## Built for agents, great for humans `mel` is designed **agents-first** — every command returns structured JSON, uses deterministic exit codes, and needs zero interactive input, so an AI agent in a sandbox can drive it reliably. The same qualities make it pleasant in a terminal or a shell script: predictable output you can pipe through `jq`, and clear errors that tell you the exact command to fix them. ```bash theme={null} npm install -g @melius-ai/cli mel auth login --api-key mel_... mel project list mel node create <canvasId> --type image --prompt "a sunset over the ocean" ``` ## How generations work A generation in Melius **is a canvas node** — you create a node, start a run, and wait for it to finish: ``` mel canvas create <projectId> → a canvas mel node create <canvasId> --type image → a node (prompt + optional model) mel run start <nodeId> --canvas-id <id> → start a run mel run wait <runId> → block until finished mel run download <runId> → a presigned URL for the output ``` Runs are **asynchronous** — `mel run start` returns a run id immediately and the generation happens in the background. `mel run wait` blocks until it's `finished` (or `failed`). To run an entire canvas in dependency order, use `mel bulk-run start <canvasId> --wait`. ## The output contract Every command follows the same shape, which is what makes `mel` scriptable: * **Success** → structured JSON on `stdout`, exit code `0` * **Errors** → structured JSON on `stderr`, a [deterministic exit code](/cli/commands#exit-codes-and-errors) Add `--text` for tab-separated human output, `--fields id,title` to project specific fields, or `--quiet` for exit-code-only. See [Global flags](/cli/commands#global-flags). ## Rate limits and credits * **Credits.** Generations consume credits from the team you act on, exactly like the app. See each model's cost in `mel model list`. * **Rate limits.** There is no monthly request quota on any plan. On a `429`, `mel` prints a notice to stderr and automatically backs off and retries, so polling commands ride through a limit instead of failing. ## Next steps > [card] [Installation](/cli/installation) > > Install `mel`, create a key, and authenticate. > [card] [Quickstart](/cli/quickstart) > > Run your first generation end to end. > [card] [Command reference](/cli/commands) > > Every command, flag, exit code, and error shape. > [card] [Using mel from an agent](/cli/agents) > > JSON parsing, exit-code branching, and headless auth. # Quickstart Source: https://docs.melius.com/cli/quickstart Generate your first image with the mel CLI in a few minutes. ## 1. Install and authenticate ```bash theme={null} npm install -g @melius-ai/cli mel auth login --api-key mel_... ``` Don't have a key yet? Create one in the app under **Team settings → Integrations**. See [Installation](/cli/installation) for details. ## 2. Generate your first image These commands create a project and canvas, add an image node with your prompt, run it, wait for the generation to finish, and print the URL of the result. ```bash theme={null} # Create a project and a canvas PROJECT=$(mel project create --title "My first project" --fields id --text) CANVAS=$(mel canvas create "$PROJECT" --title "My first canvas" --fields id --text) # Add an image node NODE=$(mel node create "$CANVAS" --type image \ --prompt "a golden retriever puppy in a field" \ --aspect-ratio 1:1 --fields id --text) # Run it and block until it's done RUN=$(mel run start "$NODE" --canvas-id "$CANVAS" --fields id --text) mel run wait "$RUN" # Get the URL of the generated image mel run download "$RUN" ``` No model is specified, so Melius picks one for you. To choose one, add `--model <name> --variant <variant>` (discover options with `mel model list --category image`). > [!TIP] > > Every create command returns the created object as JSON. `--fields id --text` prints just the `id` so you can capture it in a shell variable — > drop those flags to see the full object. ## 3. Or build a whole pipeline in one call `mel node bulk-create` creates multiple nodes and the edges between them at once — ideal for a text-to-image pipeline: ```bash theme={null} mel node bulk-create "$CANVAS" --json - <<'EOF' { "nodes": [ { "id": "brief", "type": "text", "prompt": "Describe a premium product photo" }, { "id": "hero", "type": "image", "prompt": "Professional product shot", "aspectRatio": "1:1" } ], "edges": [ { "src": "brief", "dst": "hero", "type": "text" } ] } EOF # Run every node on the canvas in dependency order, and wait mel bulk-run start "$CANVAS" --wait ``` `mel bulk-run` executes nodes tier by tier — downstream nodes wait for their inputs to finish. ## Generate video, too Everything works the same for video — use `--type video` and a `--duration` in seconds: ```bash theme={null} VIDEO=$(mel node create "$CANVAS" --type video \ --prompt "a slow timelapse of clouds over a city skyline" \ --duration 5 --aspect-ratio 16:9 --fields id --text) RUN=$(mel run start "$VIDEO" --canvas-id "$CANVAS" --fields id --text) mel run wait "$RUN" mel run download "$RUN" ``` Discover video models and their options with `mel model list --category video`. ## 4. Read the result ```bash theme={null} mel canvas content "$CANVAS" --node-id "$NODE" --include-all-versions ``` `mel canvas content` is the primary read command — it returns the live canvas state (nodes, edges, and generated outputs). ## Next steps > [card] [Command reference](/cli/commands) > > Every command, flag, exit code, and error shape. > [card] [Using mel from an agent](/cli/agents) > > JSON parsing, exit-code branching, and headless auth. # Custom fonts Source: https://docs.melius.com/collaboration/fonts Upload custom fonts for use on the canvas. Teams can upload custom font files for use in text-heavy nodes and canvas annotations. ## Upload a font From **Team settings → Custom fonts**, click **Upload**. Accepted formats: `.woff2`, `.ttf`. Once uploaded, the font is available to all members of the team and can be selected in any project under that team. # Members & roles Source: https://docs.melius.com/collaboration/members Invite collaborators and assign roles. Melius is organized around teams. Every project belongs to a team, and every member of the team gets access according to their role. ## Inviting members From **Team settings → Members**, enter an email address and pick a role. Invited users get an email with a sign-up link. Once they accept, they appear in the team. If you can invite teammates, searching for a full email address with no matching member shows **Invite them**. Select it to open the invitation form with that email already filled in. Review the role and select **Invite** to send it. ## Roles | Role | Can do | | - | - | | `owner` | Everything, including billing and deleting the team. | | `admin` | Manage members, projects, billing, and team settings. Cannot delete the team or change owner. | | `member` | Create and edit projects. Cannot manage other members or billing. | Every team has exactly one owner. To transfer ownership, the current owner promotes another member. ## Removing members Owners and admins can remove members from **Team settings → Members**. Removed members lose access to all team projects immediately. ## Limiting a member to selected projects > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. > [!NOTE] > > Limiting members to selected projects is available on **Team** and > **Enterprise** plans. [Compare plans](/billing/plans). Give a freelancer or agency partner only the client work they're on. A limited member opens the projects you choose and works inside them: they can add canvases, but they can't create new projects. Projects you didn't choose stay hidden, along with their canvases and the files, generations, and approvals made in them. In Files, they see what they uploaded or generated themselves and the files used in their projects. They don't see the team's folders: their projects and files each appear in one list, and they can't create folders or move things between them. Playground, Cast, and the [brand kit](/brand-kit/overview) work as usual. Home chat and the brand kit's **Try on canvas** each start a new project, so they're for members with access to every project. Owners and admins always have access to every project, so only other members can be limited. Promoting a limited member to admin gives them every project. ### Invite someone to selected projects 1. In **Team settings → Members**, click **Invite teammates**. 2. Enter their email address, pick a role, and click **Invite**. 3. Open **Project access**, open **Selected projects**, check the projects they should open in the list beside it, then click **Send invite**. Every invite asks which projects it opens, starting from **All projects**. Admins always have every project, so inviting an admin skips this step. The shared invite link always opens every project. ### Change a member's projects In **Team settings → Members**, the **Project access** column shows what each member can open. Open a member's project access and choose **All projects**, or open **Selected projects** to check projects in the list beside it. **All projects** also covers projects created later. Search narrows the list. The change saves when the menu closes. # Sharing projects, assets, and folders Source: https://docs.melius.com/collaboration/sharing Public share links, folder reviews, asset comments, and embedded canvas previews. ## Public share links From a project's **Share** menu, generate a public share link. Anyone with the link can view the project read-only — they don't need a Melius account. * Links are **revocable** — disable the link and existing visitors lose access on next refresh. * Shared projects are **read-only** — viewers see nodes, edges, and active versions but cannot run or edit. Read-only canvases use condensed image and video nodes. Hover over or select a node to read its prompt over the media, keeping the surrounding layout tidy. Your node appearance preference still applies when editing a canvas. ## Links to canvas groups and selections Select a node, group, or several nodes, then right-click and choose **Copy link**. The link opens the canvas fitted around that selection. Group links follow the group's current contents. These links keep the canvas's existing access settings. Team members with access can open them; visitors can view them when the project is already publicly shared. Otherwise, recipients sign in with an account that has access. The address keeps the target until you pan, zoom, or change the selection. Refreshing before that interaction returns to the same target. If some linked nodes were deleted, the remaining nodes are shown; if all were deleted, the canvas opens normally. A single node or group uses `/projects/<projectId>/canvas/<canvasId>?node=<nodeId>`. Several nodes use `?nodes=<id1>,<id2>`, with a maximum of 100 distinct nodes. **Copy link** builds the address for you. ## Playground result links Open a result with **Fullscreen** to get its `/create/playground/results/:nodeId` address. **Share → Copy link** copies the same address and preserves the selected variation. Copying a link keeps the result's current access settings. Team members can open private results. Choose **Share → Enable public access** to let anyone with the link view the result, prompt, and references. Visitors without access can sign in with an account on the owning team. Older `/g/:nodeId` links continue to open the same result. ## Embedded canvas previews The same share infrastructure powers **remote previews** — embeddable, read-only canvas thumbnails you can drop into another site or doc. The embedded preview renders the live canvas state and updates as the underlying project changes. ## Gallery > [!NOTE] > > **Coming soon** — not yet available. The **Gallery** is a curated public space for showcasing projects to the broader Melius community. When it launches, you'll be able to publish a project from the **Share** menu and have it featured alongside work from other teams — great for inspiration, attribution, and discovery. ## Share an asset Click **Share** on an asset to make it available to anyone with the link and copy its `/assets/{id}` address. The success message confirms that anyone with the link can view and comment without signing in. The same address works for your team, people on other teams, and people without an account. On a canvas, select a node with an asset and click **Share asset** in its floating toolbar or the right-hand details panel. You can also right-click the node and choose **Share asset**. The link opens the version displayed on the node. Sharing becomes available once the asset has loaded and requires edit access to the canvas and access to Assets. The viewer shows the file's details beside the media (filename, source, dimensions, file size, length, when it was added, and the member who created it), the same rows members see in Assets. Switch between **Details** and **Comments** in the sidebar; each tab keeps its place and any comment draft. Drag the sidebar edge to resize it. Anyone with the link can download the file. **Versions** lists the file you opened. For generated assets it also lists outputs from the same generation that are already shared publicly; select one to open its own link, details, and comments. On mobile, open the **Versions** tab. Assets stay restricted to their team until a member shares them. Copying the browser address alone does not enable public access. Older `/a/{id}` links redirect to the same asset address and preserve the selected version. ## Share a folder Open the three-dot menu on a folder card or beside the open folder’s name, then choose **Share** to save public access and copy its `/assets/folders/{id}` link. Until a team member shares it, the folder stays restricted to its team. The success message confirms that anyone with the link can view and comment without signing in. Anyone with the link can browse its subfolders, preview or download its files, and comment on an asset they open — including people without an account or on another team. Guests use the same first-and-last-name flow described below. The link keeps the shared root folder in its address as you browse. It grants access within that folder, rather than publishing each asset's separate link. Files moved out of the shared folder lose that access. Turning off folder sharing blocks further public reads, comments, and attachment uploads through that link. Older `/f/{id}` links redirect to the same folder address and preserve the open subfolder or asset. ## Asset link previews Public asset links include the filename and an image preview or video thumbnail when pasted into apps that support link previews, such as Slack. Assets without a thumbnail show Melius branding. Version links preview the exact shared asset. Asset links show a preview when the asset is shared with **Anyone with the link**. Restricted assets show generic Melius branding. After a link is disabled, new preview requests use the generic card; other apps may retain previews they already cached. ## Comment on a shared asset Open a public asset link to read its comments, replies, resolved discussions, and attached files. Everyone with the link can see the discussion for that asset. On mobile, public asset links use the same full-width **Preview**, **Details**, and **Comments** panels as Assets. Open **Details** for file information or **Comments** for the discussion. Selecting **Add comment** or an anchored discussion returns to **Preview**; switching panels keeps your draft. Select **Sign up for free** at the bottom of **Details** or **Comments** to create an account and return to the same link. 1. On an image or video, select **Add comment** (or the **Comment** button under the media), then tap or click the spot you want to talk about. A composer opens beside your point; video comments also capture the playback time. Tap **Cancel** on mobile, or press **Esc** on desktop, to leave comment mode without closing the asset. To comment on the whole file instead, use the comment box at the bottom of **Comments**. 2. Write your comment, or choose **Reply** under an existing comment. Use **Attach files** to include images, videos, audio, or PDFs. 3. Select **Comment** or **Reply** to post. The first time, enter your **First name** and **Last name** and select **Post comment**. No account or email is required, and this browser remembers your name for future comments. Your name appears beside each post without a guest badge. This browser reuses your name for later comments and shows **Commenting as** only while you are composing a comment or reply. You cannot edit, delete, or resolve guest comments after posting, including in the same browser. Guests do not receive email notifications. If you belong to the asset's team, comments use your team account, even when another team is selected in the app. Team viewers can read but cannot post. A Melius account on another team follows the same first-and-last-name flow as a guest. Team editors can edit or delete their own account comments and resolve discussions. Hover over a specific comment to reveal its edit and delete controls; these controls stay available on touch screens. Team owners and admins can also delete anyone's comments; deleting the first comment removes the entire thread and its replies. Turning off the public asset link blocks further public reads, posts, and uploads. Existing comments remain available to the asset's team. # Core concepts Source: https://docs.melius.com/getting-started/concepts The objects that make up Melius. ## Home Desktop Home gives you shortcuts to your creative tools. **Discover** features Cast alongside Playground, featured models, and Melius MCP. Cast opens its studio. **Playground** opens the prompt box without opening a project. When Explore is available, browse its catalog below Discover or choose **View more** to open the full **Explore** page. Keep scrolling to discover more ideas. The catalog is a gallery of looks you apply to your own subject, with Melius's staff picks first, followed by the rest of the catalog. Search finds looks by what their images show. Your team's saved **Favorites** stay available in their own list. You can also open **Templates** under **Library** and **Academy** under **Learn** in the sidebar. ## Search Press **Cmd+K** on Mac or **Ctrl+K** on Windows and Linux to open **Search** from any signed-in page, including the canvas editor. On desktop, you can also click the search icon beside the collapse control at the top of the expanded sidebar. Hover over it to see the keyboard shortcut. Search jumps to features such as **Cast** and **Explore**, or finds projects, canvases, assets, and folders by name in your current team. Use the arrow keys to choose a result, **Enter** to open it, and **Esc** to close search. Results include up to eight of each that you can access; keep typing to narrow your search. A project opens the last canvas you viewed in it, or its first canvas if you haven't opened one yet. In the desktop app, a project or canvas you open from Search opens in a new tab and keeps the page you searched from. On web, it opens in the current tab. An asset or folder opens on the **Assets** page in the current tab. Search finds the files listed on the Assets page, including files in folders, and shows the folder each result is in. In the canvas editor, Search opens on the open canvas's nodes, under **Nodes**, and narrows them by title as you type. Matching features and pages appear below them under **Navigation**. As you move through nodes with the arrow keys, the canvas moves to each one. **Enter** keeps the node you're on, and **Esc** puts the view and your selection back where they were. On a canvas, **Cmd+F** on Mac or **Ctrl+F** on Windows and Linux also opens Search. ## Projects A **project** is the top-level container. It belongs to a team and holds one or more canvases, plus project-level settings (members, sharing, fonts). A project you start without a name, such as one started from a prompt on Home, takes its name from your first message to Mel. If another project in your team already has that name, a number is added, such as "Tiger jungle walk (1)". A name you give the project yourself stays as you typed it. To keep your project list open, right-click a project card or row and choose **Open in new tab**. The same action is available in the project's three-dot menu, including recently viewed projects on Home. It opens the last canvas you viewed in that project, or the first canvas if you haven't opened one yet. Select a single project to use this action. ## Canvases A **canvas** is an infinite 2D surface inside a project. Most projects start with a single canvas, but you can add more — for example, one canvas per scene, ad concept, or experiment. To move between canvases, click the canvas name next to the project name at the top of the canvas. When a project has more than five canvases, type in the search box to find one by name, and press **Enter** to open the highlighted one. **Recent** lists the canvases you opened most recently, on any device, above the full list. ## Nodes A **node** is a single unit on the canvas — text, image, video, audio, file, custom text, or group. See [Nodes](/canvas/nodes) for types, anatomy, and how to create them. ## Edges An **edge** is a directed wire from one node's output to another node's input. See [Edges & data flow](/canvas/edges) for types and creation. ## Runs A **run** is one execution of a node against its model. Every run produces a new **version** on that node. Older versions are kept — switch between them with the version selector. ## Versions Each run on a node creates a new version. You can: * Select which version is the "active" version (the one that downstream edges read). * Compare versions side by side. * Delete versions you no longer want. ## @ mentions Type `@` in any prompt to reference another node. Melius treats the mention as an **input edge** — the referenced node's output is wired into the prompt automatically. This is the fastest way to compose nodes without dragging wires. ## Sticky notes vs. comments Two ways to annotate the canvas: * **Sticky notes** are lightweight yellow notes you drop anywhere on the canvas. Click to edit the text inline, drag to move them around, @-mention teammates inside the body. Drag a corner or an edge to resize one, from a short label bar to a large card. Choose Small, Medium, Large or XL text from the note toolbar. A new note starts in Large text, or in the text size and color you last picked. Resizing adds room without changing text size, and longer text scrolls inside the note, including in shared views. Short notes use tighter vertical spacing to keep one line and its author visible. Only the author of a sticky note can edit or delete it — everyone else on the canvas sees it but can't change it. No threads, no resolution. * **Comments** are threaded discussions pinned to a point on the canvas or a specific node. They support replies, resolution, and @-mentions of teammates. Use them for review, feedback, and decisions you want to track. Rule of thumb: sticky notes are for *organizing the canvas*; comments are for *talking about the canvas*. ### Finding a canvas comment Pick the **Comment** tool in the bottom toolbar and a **Comments** panel opens on the right, listing every comment on the canvas newest first. Type in **Search** to narrow the list by comment text or author name. Select a comment to move the canvas to its pin and open the thread, and hover a comment you wrote to delete it. Switching to another tool closes the panel. ### Editing asset comments In an asset's **Comments** sidebar, hover over your comment or reply and click **Edit** (the pencil). Update the text, then click **Save** or press Enter. Use Shift+Enter for a new line, or **Cancel** or Escape to discard your edit. You can edit your own comments while you have editor, admin, or owner access to the team. Saved changes show an **(edited)** label and keep the original timestamp, position, attachments, and replies. Editing a comment does not send another notification. ## Real-time collaboration Every canvas is real-time and collaborative by default. Edits, runs, comments, and cursors sync instantly across every participant, including AI agents driving the canvas through the MCP server. You don't enable collaboration or share a "session"; the canvas itself is the shared surface. This powers: * **Presence** — see who (or what) is on the canvas right now. * **Live edits** — node moves, prompt changes, and new runs propagate as they happen. * **Comments and sticky notes** — annotations show up for everyone immediately. * **Agent coordination** — agents claim a region of the canvas while they work, so humans and other agents can stay out of the way. ## Presence Both human collaborators and AI agents appear on the canvas as cursors. When an AI agent is working, a highlighted area shows which part of the canvas it's focused on, so you can see what it's doing in real time. # Quickstart Source: https://docs.melius.com/getting-started/quickstart From sign-up to your first generation in a few minutes. ## Navigate your workspace The sidebar starts with **New**, which opens Home, followed by **Explore**, **Inbox** (when your team has Inbox access), and **Academy**. **Create** groups Playground and Templates; **Library** groups Projects, Brand kits, and Assets. Each available link has its own icon. Click a section's name, such as **Library**, to fold it away; click it again to open it. The sidebar remembers which sections you folded in this browser. Once you have opened a project, **Recents** under Library lists the five projects you opened most recently; click one to open it. While you work in a project, its canvases are listed beneath it in **Recents**, in the project's order; click one to switch to it. A long list scrolls on its own and opens at the canvas you're on. **Create** and **Library** are section labels. Click a link beneath them to open a page. When you collapse the sidebar to icons, every page keeps its own icon, so each one is still a single click away. Your team, its plan, and **Settings** sit at the bottom of the sidebar. On web, the canvas sidebar starts collapsed to icons. If you open or close it, Melius remembers that choice for future canvas visits in this browser, separately from your Home sidebar preference. ## Guides and announcements > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. When you dismiss a guide or announcement while signed in, Melius remembers it for your account across teams, browsers, and devices. This includes the Home, node toolbar, Magic resize, and Templates introductions, plus offer and launch banners. Choosing **Don't show again** in the Build-template introduction also follows your account. When you return using a browser with older guide or announcement dismissals, Melius imports those preferences into your account. Preferences that were shared by everyone using that browser are assigned to the first account that signs in after rollout. Once imported, they follow that account across devices. Dismissing an offer banner does not change your eligibility for the offer. ## 1. Create a project Open [melius.com](https://melius.com) and sign in. Open **Projects** in the sidebar and click **New project**. A project is a workspace that holds one or more canvases. In the desktop app, creating a project opens its canvas in a new tab without a sidebar. Use the Home tab to return to your workspace. On web, the canvas opens in the current tab, and the sidebar provides workspace navigation. Right-click a project in **Recently viewed** on Home or on the **Projects** page to open its actions. The same actions are available from the project's three-dot menu, including **Open in new tab**, **Copy link**, and any editing actions your permissions allow. ## 2. Open the canvas Every new project starts with a blank canvas. The canvas is an infinite 2D surface — pan with space-drag, zoom with the trackpad or scroll wheel. ## 3. Drop your first node Use the toolbar (or hit `/`) to add a node: * **Text node** — runs a text model and produces a written output. * **Image node** — runs an image model and produces an image. * **Video node** — runs a video model and produces a video clip. * **Audio node** — runs an audio model and produces speech, music, or sound effects. * **File node** — upload an image, video, audio file, or PDF you already have. * **Custom text** — a static text block you can reference from other nodes. Type a prompt into the node. ## 4. Run a generation Click **Run** on the node (or press `⌘ + Enter`). Melius queues the generation against the model selected on that node. You'll see the result appear inline when it's ready. Each run produces a new **version**. You can flip between versions on a node without losing earlier outputs. ## 5. Wire nodes together Drag from a node's output handle to another node's input handle to create an **edge**. The downstream node will receive the upstream output (text, image, video, or audio) as part of its prompt context. You can also **@-mention** another node directly in a prompt — Melius will wire it up as an input edge automatically. ## 6. Share or keep iterating * Invite teammates from the project settings. * Generate a **public share link** for read-only viewing. * Connect [the MCP server](/mcp/overview) and let an agent drive the canvas for you. Next: read [Core concepts](/getting-started/concepts) for the mental model. # Video tutorials Source: https://docs.melius.com/getting-started/videos Short walkthroughs to get you up and running on Melius. New to Melius? These guided walkthroughs cover the essentials — the canvas, Mel agents, and the templates, tools, and utilities that speed up your work. They are also in the app: open **Academy** in the sidebar. Academy holds three kinds of thing, in this order: **courses**, each a set of short chapters that build one project end to end; **tutorials**, the single videos below; and **articles**, which are pages of these docs. The Melius cheat sheet opens on its own Academy page, with a link to the original PDF. You can browse [Academy](https://app.melius.com/academy), watch tutorials, and read articles without an account. To suggest a topic, select **Request a tutorial** and sign in. After signing in, you return to Academy, where you can submit your request. ## Melius 101: Crash course A tour of the fundamentals to get you started. [Melius 101: Crash course](https://www.youtube-nocookie.com/embed/HfaA3Xy1N0M?rel=0) ## How Mel agents expedite your workflow See how [Mel agents](/settings/agent) take on canvas work for you. [How Mel agents expedite your workflow](https://www.youtube-nocookie.com/embed/Vj_m1RnqHzk?rel=0) ## Templates, tools, and utilities A walkthrough of templates, tools, and utilities for common tasks. [Templates, tools, utilities](https://www.youtube-nocookie.com/embed/wQnfcUPA7aw?rel=0) ## Courses Each course is a set of short chapters you watch in order, and every chapter opens the canvas it was recorded on so you can follow along. ### On-model fashion shots Turn flat-lays or garment photos into believable on-model imagery, across seven chapters — from garment references through editorial shots to a reusable set-up. [Start the course](https://app.melius.com/academy/on-model-fashion-shots). ### UGC ads in an afternoon Build the handheld, unpolished look on purpose, in four chapters: a character sheet, your product in the shot, video and voiceover, then branding and the final cut. [Start the course](https://app.melius.com/academy/ugc-ads-in-an-afternoon). ### A marketing campaign, start to finish Take a campaign from strategy to a stitched final video across seven chapters, covering static ads, video frames, audio, and the final edit. [Start the course](https://app.melius.com/academy/a-marketing-campaign-start-to-finish). # Agent vs node edits Source: https://docs.melius.com/help-center/marketers/agent-vs-node When to brief the agent vs when to edit a node directly — a practical framework, with examples. Both the agent chat and direct node editing get the same canvas the same place. The choice is about leverage: which one gets you to the right output faster for this specific task? A rough rule, which holds about 90% of the time: * **Use the agent** for big-picture tasks, anything where you want the model selection and prompt writing done for you, and any bulk operation across many nodes. * **Use the node directly** for fine-tuning, A/B comparison, and any change to a single specific output. ## Use the agent when... ### You want to ask Mel directly on the canvas Right-click empty canvas space or a node and choose **Ask Mel** to open a prompt at your cursor. You can also press `/` while working on the canvas. Selected nodes are included as references. Type your request and press **Enter** to send, or **Esc** to dismiss the prompt. ### You're starting from a brief, not a finished canvas The agent is at its best when you give it a brief and a goal. *"Build me five UGC video ads for this product."* It picks models, writes prompts, creates the right node types, and connects them up. You watch and steer rather than wire by hand. ### You want a bulk change across many nodes *"Update every video node on this canvas to use Seedance 2.0 instead of Veo 3.1."* *"Re-generate every output node with the brand anchor connected as context."* *"Add a CTA overlay to all the static ad variants in the winners group."* These are slow to do by hand. The agent handles them in one pass. ### You're using a template you don't know cold Templates pre-configure a workflow (Image Style Analysis, Product Swapper, etc.), but they have parts you need to wire up. If you're not sure which input goes where, just brief the agent: *"Use the Image Style Analysis template with my reference images and output a style description I can use for new variants."* The agent will set it up correctly. ### You want clarifying questions before generation starts The agent will ask follow-up questions when the brief is ambiguous — what aspect ratio, what audience, what tone. When you type your own answer, `@` lets you point at a node on the canvas ("use @Logo for the intro") the same way you would in a prompt. If you appreciate the safety net, use the agent in **ask permission** mode. ### You're working asynchronously Briefing from your phone, in a meeting, between tasks — the agent works without you watching. Set it to auto-run, come back when it's done. ## Use the node directly when... ### You're fine-tuning a single output You've got one image that's 90% there. You don't want to redo the canvas. Click into the node, edit the prompt — *"keep everything, but change the camera angle to slightly higher"* — and re-run. The original prompt is preserved as a previous version, so you can compare. This is the single most common edit pattern after the agent's first pass. ### You're A/B testing prompt variations Two prompts, same model, see which lands better. Two nodes, two slightly different prompts, run both. The agent is overkill for this; doing it directly is faster. ### You're learning what a model can do When you're new to a model — its style biases, its failure modes, what kinds of prompts it follows literally vs creatively — write a few prompts directly and inspect the results. You'll build intuition faster than if the agent is between you and the model. ### You want exact control over the prompt Sometimes you know exactly what you want to say to the model, and you don't want the agent to "improve" your prompt. Open the node, write the prompt yourself, run. ## A worked example Brief: *"Generate 10 hero shots for a new product launch, in our brand style, sized for Instagram feed."* **Agent pass (auto-run):** the agent reads your brand anchor, runs an Image Style Analysis on your existing campaign references, generates 10 image nodes at 4x5 ratio with consistent style anchoring, hands you a canvas with results. **Your pass (direct nodes):** six of the ten are usable; four have issues. Edits, one node at a time: * *Node 3 — product is slightly too small in frame.* Edit prompt: add *"product fills 40% of frame width."* Re-run. * *Node 5 — color drift toward green, should be warmer.* Edit prompt: add *"warm color grade, slight terracotta in the highlights."* Re-run. * *Node 7 — typography on the product label is illegible.* Switch model from Nano Banana Pro to GPT Image 2 (High). Re-run. * *Node 9 — composition is fine but lighting is too flat.* Edit prompt: add *"strong directional side lighting from camera-left, golden hour quality."* Re-run. All four fixes take about three minutes total. The agent could do them too, but typing the fix into the node is faster than describing it in chat. **Back to the agent (bulk change):** *"Run Magic Resize on all 10 image nodes: 1x1, 9x16, and 21x9."* The agent queues 30 resize operations in parallel. You don't want to do that one node at a time. ## A small but important habit When you edit a node directly, the agent doesn't automatically know about your edit. If you later ask the agent *"do that thing again across the canvas,"* it might revert to its original approach. Two ways to handle this: * **Edit the brand anchor or a shared context node** rather than a specific output. Changes there propagate to every node connected to it on the next run. * **Tell the agent what you changed.** *"I edited @node-7's prompt to add 'warm color grade.' Apply that to the other warm-toned variants too."* Either is fine — pick whichever fits the flow. ## Push the agent further than you think it can go Worth keeping in mind across both modes: most marketers undershoot what the agent can actually do. The instinct is to break a job into small briefs because that feels safe — describe the first piece, run, see the output, describe the next piece. That's fine, but it leaves a lot on the table. The better instinct: brief the agent with the *whole* job, not just the next step. *"Take these three reference ads, generate 10 angle variations across two products, resize each into 1x1 and 9x16, and run a brand-check pass against @brand-anchor."* If the agent can't handle the full task, you'll find out — and that's useful information about where the current limit is. If it can, you've saved yourself an hour of orchestration. The cost of asking for too much is small (a re-brief). The cost of asking for too little, over and over, is your whole afternoon. ## Common pitfalls * **Re-prompting the agent to fix one image.** Slower than just editing the node. Use the node. * **Editing the same node 20 times before realizing you're solving the wrong problem.** If you're past your fifth tweak, step back and re-brief the agent with what you actually want. The agent has full canvas context and might unstick you. * **Treating the agent like ChatGPT.** It's not a chat. It builds canvases. Brief it like you'd brief a designer — concrete goal, references, constraints — not like you're conversational. * **Undershooting the brief.** Ask for more than you think the agent can do; let it tell you where the limit is. # Assets and references Source: https://docs.melius.com/help-center/marketers/assets Logos, fonts, pack shots, mood boards — how to get them into Melius and reference them in generations. The agent can produce on-brand work with just a written anchor, but generations get sharper the moment you give it actual brand assets to reference. This page covers what's worth bringing in and how to wire each one up. ## Your asset library **Assets** is available on every plan. Browse and upload files, organize folders and tags, import from Google Drive, and search by name. You can also browse workspace assets from the canvas Assets panel. You can select multiple HEIC or HEIF photos in one upload. Melius keeps the original files for download and creates JPEG previews for display and image generations. HEIC photos support up to 64 MB and 100 megapixels per file. If a photo cannot be converted, it is skipped without stopping the other photos; export that photo as JPEG or PNG and try again. ### Search with AI > [!NOTE] > > Find assets by describing their content with **Search with AI**, available > on **Professional** and **Enterprise** [plans](/billing/plans). Other plans search by name. Upgrading unlocks search by what an asset contains, without changing your files or folders. ## Find assets from a project > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you’d like access. On the **Assets page**, open **Filter & sort**. **Project** starts on **All projects**. The **Canvas** picker is disabled until you choose a project, then starts on **All canvases**. Choose an individual canvas to narrow the results further. Canvas options load in pages as you scroll. Changing the project resets Canvas to **All canvases**. Open **Assets** from the canvas toolbar. **Filter & sort** starts on **All assets**. Choose a project and canvas to narrow it, **All canvases** to browse a project, or **All assets** to browse the workspace, including unassigned uploads. The panel remembers your project, canvas, file type, tags and sorting for each team in this browser, so it reopens the way you left it. You can search project names inside the Project picker. Search, file type, tags, sorting, and category counts follow the selection. The canvas panel shares the Assets page’s controls; fonts and approval queues remain separate. ## Open an asset from Inbox On **Enterprise**, open an asset from **Inbox** to review it in fullscreen. The address bar identifies the asset and its submitted version, so you can copy the URL or refresh the page and return to the same review. Anyone opening the link still needs access to the asset. Close the viewer or use your browser’s **Back** button to return to the Inbox tab you opened it from. **Request changes** opens the same asset view with the comment tool ready. Within an asset folder, project and canvas filters narrow that folder. Choosing a project or canvas does not assign uploads to it. A project includes eligible assets originating or used on its live canvases, so a reused asset can appear in more than one project. **Favorites** follows the selected project or canvas. Click or drag an asset to place it on the canvas you currently have open; selecting another canvas does not change that destination. Uploads in the panel are available when the current canvas is selected. **Reset filter & sort** stays pinned at the bottom of the menu while its fields scroll. It clears type and tags and restores newest-first ordering. The button is disabled when filters and sorting are already at their defaults. On the Assets page it returns to **All projects**. In the canvas panel it returns to **All assets**. ## Upload files and folders Choose **Upload** on the Assets page to pick files or a whole folder, or drag them from your computer onto the page. Uploads land in the folder you are viewing. While you are browsing folders, in the **All** or **Uploads** view with no project selected, a folder keeps its structure: its subfolders are recreated underneath, and each file goes into the matching one. Images, videos, audio, and fonts are accepted; other file types are skipped and reported. ## Find assets in your library > [!NOTE] > > **Beta** — refreshed asset pagination is rolling out gradually. Reach out > to support if you'd like access. > > If a search expires while you browse, the files already loaded stay visible. > Choose **Refresh results** to start the search again. The refreshed results > can change as files are added or updated. Searching by name filters both files and folders in the current folder. Folder names match regardless of capitalization. Clear the search to show all folders again. ## Navigate folders The breadcrumb at the top left shows your current folder. Choose **All assets** to return to the library. When the path is crowded, choose **Parent folders** (the three dots within the path) to open an ancestor folder. Long names are shortened in the header; hover over a shortened name to read it in full. The separate three-dot menu after the current name contains that folder's actions. To move files or folders to an ancestor, drag them over **Parent folders** to open the list, then drop them on the destination folder. To find where an open asset is filed, choose its **Folder** under **Details**. The row shows the folder's full path and opens it in Assets. It appears when the asset is in a folder, including when you open the asset from a canvas. ## Delete a folder Choose **Delete folder** from a folder card's menu or the three-dot menu beside the open folder's name. The dialog counts the files and subfolders inside it, then asks what happens to them. **Delete folder only** moves its files and subfolders into its parent folder. **Delete folder and contents** deletes the folder together with every file and subfolder in it. Neither can be undone. A folder that holds nothing is deleted with a single confirmation. Project folders on the Projects page offer the same two choices; deleting a project folder's contents needs you to be the creator of every project in it, or a team admin. ## Move or delete several items Select files and folders with their checkboxes, or drag a box around them, to open the selection bar. **Move** puts everything selected into the folder you choose; a folder cannot go inside itself or one of its subfolders. **Delete** removes the selection, and when it includes folders that hold anything, asks the same **Delete folders only** or **Delete folders and contents** question as deleting one folder. **Tag** applies to the selected files. Open **Filter & sort** on the Assets page to organize the grid or list. Choose **Name** under **Sort by** for alphabetical ordering. Select the **Ascending** or **Descending** sort icon beside it (A–Z / Z–A for names). The selected direction stays highlighted. **Date added** defaults to descending, showing newest first. Name sorting uses the name shown on each asset, including generated asset titles and renamed files, across all pages. When searching, selecting **Name** orders the matching results alphabetically. Use **File type** to show images, videos, audio, or fonts. For media assets, select tags to narrow the results further: an asset must have every selected tag to match. You can search tags and, if you have permission, create, rename, or delete them from the same panel. Fonts support name and date sorting; tag filters apply to media assets only. Choose **Reset filter & sort** to return to all types, clear selected tags, and restore newest-first ordering. ## Select several assets Check the box on an asset to select it, in the grid or the list. Hold **Shift** and click another asset to select everything between the two. Press `Cmd+A` (`Ctrl+A` on Windows) to select every loaded asset and folder. Press `Esc` to clear the selection. Move, tag, download, or delete the selection from the toolbar. ## Download several files Select files or folders and choose **Download** to save them as one ZIP. Canvas selections and Magic Resize ZIPs use the same download flow. On the canvas, select up to 2,000 cards and choose **Download**. The ZIP includes each selected image, video, file, Stitch, or Studio card's active version. Melius prepares the ZIP in the background, then your browser saves it. Large selections can take several minutes. Keep Melius open until the download starts. Follow progress or cancel in your browser's download manager. If downloads are busy, wait briefly before trying again. If the selection is too large, download smaller batches. ## Follow a download Every download you start in Melius shows in the download queue at the bottom right, whether it's one file or a ZIP, from Assets, the canvas, Playground, or Cast. The **Download** button you pressed shows a spinner until your browser takes over. If a download fails, select the retry button on its row in the queue. ## Browse assets on mobile Tap an asset to open a full-width **Preview**. Use **Details** to read its metadata, comments, and approval status. When an asset has version history, open **Versions** and choose a version to return to its preview. Use **Close viewer** to return to the library. To comment, tap **Comment**, then tap the image or video. Tap **Cancel** in the placement hint to leave comment mode while keeping the asset open. On phones, list view keeps the filename and file actions within the screen. Open the asset’s **Details** for the remaining metadata. File actions and selection checkboxes are visible on touch devices. ### Save images and videos to your photo library 1. Open an image or video in **Assets**. The file prepares while the preview is open. 2. Tap the download icon, labeled **Save to Photos**, to open your phone’s share sheet. 3. Choose **Save Image** or **Save Video** if your phone offers it. This saves the version you are previewing. Available destinations depend on your phone and the file format. On touch devices whose browser supports file sharing, **Save to Photos** replaces **Download** in the preview toolbar. Browsers and files that do not support photo-library saving use the regular **Download** action. ## Link to an asset version > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you’d like access. Open an asset on the **Assets page** to see its current version. Once its versions load, the address includes both IDs: `/assets/<asset-id>/version/<version-id>`. Choosing another version updates that address. Copy the URL to reopen that version or share it with someone who already has access to the asset. Reloading keeps the version in the URL selected. Your browser’s Back and Forward buttons move between the versions you visited. An older asset link without a version ID opens the current version and updates its address. To share publicly, select a version and click **Share**. The copied link uses `/a/<asset-id>/version/<version-id>` and opens that version’s shared media without signing in. The asset ID identifies the media you selected, so it can differ from the asset ID in your address bar. Older public links without a version ID still work. Assets without a version keep that shorter link format. A public version link shows an unavailable message if its version is deleted, does not belong to that asset, or the asset is no longer shared publicly. ## Logos The single most common cause of off-brand outputs is the model trying to recreate a logo from scratch. Don't make it guess. **1. Drag your logo file onto the canvas** PNG or SVG both work. Transparent backgrounds preferred. The file appears as an image node on the canvas. **2. Connect it to the image generations that need it** Drag an edge from the logo node into your output image node, or use `@logo` (or whatever you've named it) inside a prompt. **3. Tell the agent to use it** In the prompt: *"Place the @logo in the bottom-right corner. Do not redraw it — use the reference exactly."* > [!WARNING] > > Native AI/EPS file support isn't there yet — only SVG and PNG for vectors. > If you need an editable working file, export to SVG from your vector tool > first. We're tracking the request and may add AI/EPS support in a future > release. ## Fonts Two paths depending on how strict you need to be: **Path A: Brand guidelines paste-in.** If you have a one-pager showing your fonts in use (H1 / H2 / body / display, all visible), paste an image of it onto the canvas and connect it to your image nodes. GPT Image 2 is good at recognizing fonts in a reference image and replicating them in output. Not pixel-perfect, but usually close enough to read as on-brand. **Path B: Studio node for exact typography.** When the type has to be exact (legal copy, headline that uses your custom font), generate the background without text, then use a Studio node to overlay the text layer. The Studio node is a layered editing surface where you can add layers, drop in text, and position elements precisely. You can upload a custom font file (.otf or .ttf) and use it directly in the layer panel. The Studio node also handles other "last mile" edits: positioning a logo precisely, adding a CTA button, dropping in a price tag. Most marketers end up using it for the final polish step without leaving the canvas. ## Pack shots and product photos If your product has a specific shape, color, or detail that the model keeps getting wrong, a pack shot is the fastest fix. * Drop one or more clean product photos onto the canvas. * Connect them to your image nodes as image-to-image references. * In the prompt: *"Use this exact product. Don't restyle, recolor, or modify it — only change the surrounding scene."* If you have multiple angles, **unified groups** save you a step: **1. Select all the product photos** Click and drag a selection box, or shift-click each one. **2. Group them as a unified group** `Cmd+G` for a normal group, or right-click → "Unified group". A unified group exposes a single output port — so you drag one edge instead of one per image. **3. Connect the group to your image node** The agent now sees all the angles as a single reference, which is closer to how a human designer would use a product reference sheet. > [!TIP] > > The reference limit depends on the model — 16 on GPT Image 2, 14 on Nano > Banana 2, 10 on Seedream. Beyond that, drop the weaker references — more > isn't always better, and noisy references can pull the output off course. ## Mood boards and style references Got a Pinterest board, a competitor ad, or an existing campaign whose look you want to mirror? Use the **Image Style Analysis** template. **1. Drag your mood images onto the canvas** Two to ten images that share the look you want. **2. Group them as a unified group** Same as above — one output port for the whole set. **3. Add the Image Style Analysis template** From the templates menu, pick "Image style analysis". It drops onto the canvas as a pre-configured text node. Connect the unified group to it. **4. Run the text node** The template analyzes the images and outputs a detailed style description — palette, lighting, composition, mood, shot type. **5. Use that output as context** Connect the style analysis node to your image generation nodes via an edge. The detailed style description gets appended to every prompt automatically. > [!WARNING] > > Easy to miss: after you connect images into the Image Style Analysis > template, you have to **run the text node** before its output is usable. If > you connect a downstream image node before running the analysis, the > analysis text will be empty and the image node won't have any style > guidance. Click into the text node and hit run. ## Product detail pages (PDPs) You don't have to download every product photo manually. Paste a PDP URL into the agent chat and the agent will scrape the page — pulling product dimensions, materials, colors, copy, and reference imagery — into a text node you can reuse. Example brief: ``` Pull the PDP details from [URL] and focus on the materials, dimensions, and color options. Save the result as a text node I can reference in image generations. ``` This is especially useful for product fidelity — if the model keeps getting your product's size or shape wrong, feeding it the PDP-scraped dimensions usually fixes it. See [Product photography & swaps](/help-center/marketers/recipes/product-swap). ## What to leave off the canvas Not everything needs to be a reference. Some asset types are noise more than signal: * **Past ads that don't represent the new direction.** If you're refreshing the look, old assets will pull the agent back toward the look you're trying to leave. * **Generic stock imagery.** Unless it specifically matches your brand, it dilutes the reference. * **Low-resolution or compressed JPGs.** The model struggles to extract style from heavily compressed images. Use the highest-quality source you have. If in doubt, generate with fewer references first. You can always add more later. ## Image editing tools on the canvas Once you have a generated image, you don't always need to start over to make a change. A few tools live directly on each image node: * **Edit Image** — open the image in a quick editing surface for small tweaks. * **Inpaint** — draw a mask over an area, then describe what should fill it. Useful for removing or replacing a specific element without re-running the whole generation. * **Remove Background** — exactly what it sounds like. Outputs a transparent PNG. * **Upscale** — increase resolution after generation if you started at 1K and want to ship at 2K or 4K. * **Studio node** — for layered editing with text overlays, see the Fonts section above. > [!NOTE] > > Inpaint is improving but isn't always the right tool. For things like > "remove the text from this image," an image-to-image regeneration with a > prompt like *"recreate this exactly, but remove all text apart from the > @logo"* often produces cleaner results than masking. Try the image-to-image > route first; reach for Inpaint when you need to keep most of the image > untouched but change one specific region. # Brand anchor Source: https://docs.melius.com/help-center/marketers/brand-anchor Get your brand voice, palette, type, and rules onto the canvas once — then reuse it across every workflow. A brand anchor is a single text block — usually a few hundred to a couple thousand words — that captures your brand voice, palette, typography, product details, and any "do/don't" rules. Drop it onto a canvas as a **text node**, connect it to your image or video nodes via edges, and the agent will use it as context for every generation. This is the single biggest thing you can do to make Melius outputs consistent. Done well, it's the difference between "this looks AI-generated" and "this looks like my brand." > [!TIP] > > Your [brand kit](/brand-kit/overview) gives Mel your colors, fonts, logos, > and voice in every chat, on every canvas. Use a brand anchor for detail the > kit doesn't hold, like product specs or campaign rules. ## What goes in a brand anchor The format doesn't need to be exotic — a Markdown document is fine. The point is to compress everything a freelance designer would need into something the agent can ingest in one read. Useful sections: * **Brand voice and tone.** A paragraph on how the brand sounds. Adjectives, but also examples — phrases the brand would say and phrases it wouldn't. * **Color palette.** Hex codes for primary and secondary colors, with notes on when each gets used. * **Typography.** Names of the actual fonts, plus notes on hierarchy (when serif, when sans, when display). * **Photography rules.** What kind of imagery the brand uses. Studio vs lifestyle, warm vs cool, modeled vs product-only, depth of field, lighting. * **Shape language and visual motifs.** Any recurring design elements — rounded corners, geometric shapes, gradients, textures. * **Do's and don'ts.** Explicit rules. "Never show the product in direct sunlight." "Always include the logo bottom-right." "Don't use gradients on text." * **Audience and context.** A line or two on who the work is for and where it'll appear. ## How to generate one in five minutes If you don't have a brand anchor written up yet, the easiest path is to have an LLM generate one from existing assets. **1. Open Claude or ChatGPT** Paste in: your website URL, two or three existing campaign images, your brand guidelines PDF if you have one, and any high-performing past ads. Ask the model to synthesize a brand brief covering voice, palette, typography, photography rules, shape language, and do's-and-don'ts. **2. Review and edit** The output will be a solid 80% — read it, fix the parts that don't match how you actually think about the brand, add anything obvious that's missing. **3. Save it as `brand.md`** Keep this file somewhere persistent (a Claude project, a shared Google Doc, your team Notion). You'll paste from it into every Melius canvas. > [!TIP] > > If you're using the Claude MCP integration, you can skip this whole flow — > Claude reads your brand docs from a project and writes them directly into > the canvas as context. See [Drive Melius from > Claude](/help-center/marketers/mcp). ## How to use it on a canvas **1. Drop a text node** Right-click on the canvas → New node → Text. (Or ask the agent: *"create a text node with my brand brief"* and paste the content in chat.) **2. Paste your brand anchor in** The whole document goes into the node. Don't worry about length — text nodes handle long context well. **3. Connect it to your image/video nodes** Drag an edge from the brand anchor node into each image node you want it to influence. Or use `@` inside a prompt to reference it: *"Help me create a hero banner using @brand-anchor as style guidance."* **4. Add a referencing line to your prompts** Inside the prompt for each image node, add a line like *"Use the brand guidelines below"*. The agent will append the brand anchor's content to the model call automatically because of the edge. ## Carrying it across canvases A brand anchor doesn't automatically follow you from one canvas to the next — context lives at the canvas level. Two ways around this: * **Copy/paste.** Open the brand anchor node on canvas A, copy it (`Cmd+C`), paste it on canvas B (`Cmd+V`). It's instant and works perfectly. * **MCP route.** If you drive Melius from Claude with the MCP set up, point Claude at a `brand.md` file in your project. Claude will inject the brand context into every canvas it builds for you. See [Drive Melius from Claude](/help-center/marketers/mcp). > [!NOTE] > > Text nodes are also the right home for one-off context that doesn't belong > in your main brand anchor — campaign-specific copy, a guest creative > director's notes, a one-time promo blurb. Stack as many text nodes as you > need; the agent will use whichever you connect to a given image node. # Drive from Claude Source: https://docs.melius.com/help-center/marketers/mcp Connect Melius to Claude via MCP, brief Claude in natural language, and have it build out canvases for you — character sheets, variants, brand-checked statics, the whole workflow. The Melius MCP integration lets Claude (and other agentic AI tools) build canvases for you. Instead of opening Melius and clicking around, you brief Claude in natural language — referencing your project files, brand docs, and product details — and Claude assembles the canvas, writes the prompts, chooses the models, and kicks off generations. For marketers doing creative ops at scale, this is the single biggest productivity unlock on the platform. It also runs asynchronously: brief Claude from your phone during a meeting, get a Melius link back when the canvas is built. ## What you can do with Melius + Claude A few patterns we see across customers: * **Daily/weekly briefs.** Drop a brief into Claude every Monday morning — Claude builds the canvas, generates the variants, pings you when it's done. * **End-to-end campaign builds.** Brief Claude with the campaign concept; Claude reads your brand docs, builds the canvas with character sheets + clip nodes + voiceover + stitch, and hands you a finished video draft. * **Brand-consistent automation.** Claude reads your brand anchor on every run, so the outputs stay on-brand without you re-pasting context. * **Cross-canvas reuse.** Claude can find existing projects and canvases by name, reuse references, and link work across canvases. ## Setup You'll need: a Melius team account and Claude (or another MCP-capable client). **1. Open Claude and add a custom connector** In **Claude.ai**: Settings → Connectors → Add custom connector. In **Claude Desktop**: Customize → Connectors → Add (+) → Custom. Name it **Melius**. **2. Paste the Melius connector URL** `https://mcp.melius.com/mcp` Hit Add. **3. Sign in with Melius** Claude opens a Melius login page. Sign in (or use your existing session), pick the team you want Claude to work in, and click Authorize. Melius creates a connector key for Claude on your behalf — no API key to create or paste. Claude is connected immediately. **4. Open a new Claude chat and confirm the connection** You should see Melius listed in Claude's available tools. Try a quick brief: *"Show me the projects in my Melius account."* If Claude returns your project list, you're connected. > [!WARNING] > > The connection is scoped to the team you picked during sign-in. If you want > Claude to work in a different team, add a second Melius connector and pick > that team during authorize. To disconnect at any time, go to **Team settings > → Integrations** in Melius — find the `claude-…-mcp` key Melius created > during authorize and delete it. Already connected via `api.melius.com/mcp` with an API key? That still works — see the [MCP server docs](/mcp/overview) for both paths. ## How to brief Claude The general pattern: tell Claude what you're working on, point it at your reference material, and tell it where to build. Claude handles model selection, prompt writing, and canvas assembly. A working brief looks like: ``` I'm working on a new performance video for [brand]. Use the [Creative Brief PDF] and the [brand.md] from this project to understand the brand voice, persona, and visual style. In Melius, on the [Brand] project, create a new canvas called "Live Demo". On that canvas: 1. Create a character sheet for the persona using GPT Image 2 (Medium), based on the attached reference image. 2. Generate 3 UGC video clips (9x16, 720p, Seedance 2.0) — opening, body, close — using the character sheet as the reference image for each. 3. Reference the brand brief and creative brief in every clip's prompt. ``` Claude reads the briefs, pulls the brand voice, finds the existing Melius project, creates the canvas, builds out the nodes with prompts written from the brief, and kicks off the generations. You can watch it work in Claude's terminal-style output, or come back when it's done. ## How to structure your Claude projects This part matters for team workflows. Claude has two surfaces — **Claude Chat projects** and **Claude Cowork** — and they have different sharing properties: * **Claude Chat projects.** Shareable across team members. Project files (your brand anchor, your creative briefs) are visible to everyone on the project. Use this when multiple people brief Claude on the same brand or campaign. * **Claude Cowork.** Solo, not shareable. Good for individual workflows, deep research, longer-running tasks. Not the right home for shared brand docs. The pattern most agencies use: **one Claude Chat project per client**, with the brand anchor (`brand.md`) and creative guidelines as project files. The whole team briefs Claude on that project, and Claude has the brand context every time without you re-pasting it. Inside Melius: **one Melius project per client** matches the Claude project. The team folder structure aligns: Claude project "\[Brand]" → Melius project "\[Brand]" → all canvases live there. ## Skills (advanced) Claude Skills (the Markdown-based skill files in Claude Chat) can encode repeatable workflows — "build a UGC ad in Melius," "produce static variants for a launch," etc. We don't currently bundle Melius-specific skills, but customers have built their own that work well. If you build a useful skill — for an agency-internal workflow, a specific campaign type, a brand template — we'd love to see it. Send it in the Slack channel and we'll feature good ones. ## What asynchronous looks like in practice The MCP path is built for async work. Some patterns we see: * **Phone-to-laptop handoff.** Brief Claude from your phone in an Uber. Claude builds the canvas in the background while you're in your next meeting. Come back to your desk, open the Melius link, review and ship. * **Slack-as-brief.** Some teams brief Claude through a Slack workflow — `/brief` triggers a Claude run that drops a Melius link in the channel when it's done. * **Scheduled runs (cron).** Set Claude up to run a creative production task on a schedule — e.g. every Monday morning, build the weekly variant batch and ping the design lead with the canvas link. The common thread: the work moves to where the work happens — your phone, your Slack, your inbox — instead of requiring you to open Melius first. ## Common pitfalls * **Re-pasting brand context every time.** If you're doing this, you haven't set up a Claude project with your brand docs as project files. Set it up once; every future brief inherits it. * **One Claude project for everything.** Hard to manage, brand context bleeds across clients. One project per client. * **API key from the wrong team.** If Claude can't find your projects, you probably generated the API key while a different team was active in Melius. Re-generate from the right team. * **Asking Claude to do the whole thing in one prompt with no context.** Even with the MCP, Claude works best when you point it at specific reference material. Drop your brief and reference images in the chat the same way you would on the Melius canvas. > [!TIP] > > Once your MCP setup is solid, you'll find yourself opening the Melius web > app less — most briefing happens in Claude, and you only open Melius to > review and tweak. That's the intended end state. # Canvas mental model Source: https://docs.melius.com/help-center/marketers/mental-model Five minutes on how Melius is structured — nodes, edges, the agent, and the four-beat workflow. Melius is a canvas, not a chat. That distinction matters because it changes how you work with the AI. In a chat interface, you describe what you want, the model responds, and the reasoning is hidden. If the result is wrong, you start over with a new prompt. In Melius, the agent's work is laid out visually — every model call is a node, every input that feeds into it is an edge, and every prompt is exposed and editable. If the result is wrong, you find the node where it went off and fix that one thing. ## The four-beat workflow Almost everything in Melius follows the same shape: **1. Brief** Tell the agent what you want, in plain language. Paste in references, product links, brand assets — whatever helps. The more context you give, the better the output. **2. Watch** The agent assembles a canvas: picks models, writes prompts, routes outputs between nodes. You can see what it's doing in real time, with each node's reasoning visible. **3. Tweak** The agent will land you 85–95% of the way there. Step in at the node level — edit a prompt, swap a model, change a reference image, branch a new version — until the output is exactly right. **4. Output** Download production-ready files, or hand the canvas off to a teammate. Multiplayer means designers, marketers, and the agent can all be on the same canvas at once. ## The building blocks Three things make the canvas work: **nodes**, **edges**, and **the agent**. ### Nodes A node is one AI model call. The main types you'll use: * **Text node** — a language model (GPT, Claude, Gemini). Treat it like ChatGPT inside a node: prompt in, text out. Useful for ideation, prompt-writing, brand analysis, and as a place to paste a brand brief. * **Image node** — an image model (Nano Banana, GPT Image 2, etc.). Generates from text, an image-to-image reference, or both. * **Video node** — a video model (Veo, Seedance, Kling). Takes text, a starting frame, or a reference image as input. * **Audio node** — voice generation, currently powered by ElevenLabs. * **Studio node** — a layered editing canvas inside a node. Add layers, drop in text overlays, position elements precisely. The right tool for last-mile composition edits without leaving Melius. * **Stitch node** — concatenates video clips into a longer sequence. There's a full reference at [Pick the right model](/help-center/marketers/picking-models). For now: every node has a model picker, an aspect ratio picker, a resolution picker, and a prompt field. ### Edges An edge is the line connecting one node to another. What an edge actually does on the backend is route context: the output of the source node becomes part of the input for the destination node. Two ways to create edges: * **Drag the circle.** Each node has a small circle on its border. Drag from the source node's circle into the body of the destination node. * **Use `@` in a prompt.** Type `@` inside a prompt field and a list of nearby nodes appears. Select one, hit enter, and the edge appears automatically — the same way `@` works in Slack. Whichever way you create it, the destination node will pull in whatever the source produced (an image, a text block, a video) when you run it. ### The agent The agent (Mel) sits in a chat panel on the canvas. It has access to every tool on the canvas — it can create nodes, connect edges, write prompts, choose models, run generations, and check its own work. Two modes: * **Auto-run.** The agent decides what to build and runs it without asking. Best for "I trust you, just make me 10 variants." * **Ask permission.** The agent asks clarifying questions before each major step. Best for high-stakes work where you want to inspect each decision. While the agent is working, you'll see a small cyan indicator on the canvas — that's the agent's presence marker, showing you where it's currently building. Same idea as a multiplayer cursor, just for the AI. You don't have to use the agent. Marketers who know exactly what they want sometimes drop the nodes themselves. But for most jobs, briefing the agent and steering at the node level is faster. ## What the canvas is *not* It's a production canvas, not a layout tool. Other design surfaces are built for laying out a known design; Melius is for producing the design in the first place. For last-mile composition work, the Studio node lives on-canvas so you don't have to leave Melius. It's not a hand-wired node canvas either. Earlier node-based generative canvases were built before agents existed and assume a human wires up every node by hand. Melius was built agent-first — the canvas exists so you can *see* and *steer* the agent's work, not perform every step yourself. # Model guide Source: https://docs.melius.com/help-center/marketers/picking-models A quick reference for choosing the right image, video, and text model for the job. There's no single "best" generative model. Each one is good at a different thing, and the right pick depends on what you're making. This page is a cheat sheet for the model picker dropdowns — what each is good at, and when to reach for it. The agent will usually pick a reasonable default. This page is for when you want to override it, or when you're working directly on a node and want to make the call yourself. ## Image models ### Nano Banana Pro **Best for:** style adherence, lifestyle photography, product-in-context shots, anything where matching a reference look is the priority. **Strengths:** unmatched at following a style brief. If you've run an Image Style Analysis and the description is detailed (lighting, palette, composition), Nano Banana Pro will hew to it closely. Also strong at natural materials, fabric, food, skin tone, and editorial lighting. **Weaknesses:** struggles with legible typography, especially small text. If your output has visible copy on it, lean GPT Image 2 instead — or generate the background in Nano Banana Pro and use a Studio node to add type. **Default this for:** static ads, product photography, lifestyle imagery, anything fashion or editorial. ### GPT Image 2 (Low / Medium / High) **Best for:** anything with visible typography, packaging shots with legible labels, ads with on-image copy. **Strengths:** dramatically better at rendering text than any other current image model. Will produce sharp, legible copy in the output, including on packaging, signage, and product labels. Reasonable at style adherence too, but Nano Banana Pro is better for pure aesthetic. **Weaknesses:** slower than Nano Banana, especially at "High." Style adherence is solid but not as tight as Nano Banana Pro. **Default this for:** product shots where the label or packaging text needs to be legible, ads with overlaid copy that needs to be sharp, mockups of branded packaging. **Medium vs High:** Medium is faster and good for exploration. High is sharper, slower, and worth the extra time for production output. Don't burn budget on High during early exploration. ### Nano Banana 2 **Best for:** quick iteration, lower-stakes generations, draft-quality exploration. **Strengths:** fast and cheap. Good enough for early ideation. **Weaknesses:** style adherence is solid but not as crisp as Nano Banana Pro. Less detail in fine textures. **Default this for:** mood-finding, early variants where you want to cast a wide net before committing to a direction. ## Video models ### Seedance 2.0 **Best for:** human-centered video, UGC, anything with a character. **Strengths:** we have un-gated face access on Seedance 2.0, which means it handles human faces and character consistency better than most APIs. The right pick for UGC-style ads where the same persona has to appear across clips. **Weaknesses:** less strong on highly stylized or abstract video. For dreamy or surreal aesthetics, try Veo. **Default this for:** UGC ads, talking-head video, character-driven sequences. ### Veo 3.1 **Best for:** cinematic motion, environmental shots, product-in-motion. **Strengths:** strong on camera movement, atmospheric lighting, environmental scenes. Good for hero shots, brand films, and product-in-motion sequences. **Weaknesses:** less reliable on faces and character consistency than Seedance. **Default this for:** cinematic brand content, product reveal sequences, environmental b-roll. ## Text / LLM models Text nodes are LLM calls — generally for ideation, prompt-writing, brand analysis, or holding pasted context. You usually don't need to think about the model choice for these, but if you do: ### Gemini 3.8 Flash **Best for:** image style analysis and multimodal reasoning with images attached. If you're running image-attached reasoning, Gemini 3.8 Flash is a strong default. ### GPT-5 / Claude / others **Best for:** general LLM tasks — ideation, prompt-writing, brand brief synthesis, etc. For most marketer use cases, the model choice on text nodes matters less than the prompt content. The agent will pick a sensible default. Override only if you've got a specific reason to. ## Audio models ### ElevenLabs The default audio provider. Roughly 20 voices are curated in the in-product picker, with the full ElevenLabs catalog available — ping us in Slack if you need a specific voice that isn't in the picker. > [!NOTE] > > Clone a voice from a sample and reuse it across canvases on **Creator** and > above. You can also [import custom voices from > ElevenLabs](/integrations/elevenlabs). [Compare plans](/billing/plans). ## Quick decision table | If you're making... | Reach for | | - | - | | Static ads with editorial photography style | Nano Banana Pro | | Product packaging shots with legible labels | GPT Image 2 (High) | | Ads with on-image copy / typography | GPT Image 2 | | Lifestyle imagery, fashion, food, fabric | Nano Banana Pro | | Quick exploration / mood-finding | Nano Banana 2 | | UGC video with consistent character | Seedance 2.0 | | Cinematic brand video | Veo 3.1 | | Image style analysis | Gemini 3.8 Flash | | Voiceover | ElevenLabs | ## On model choice volatility Generative model capabilities shift quickly. Today's "best at typography" model may not be the best six months from now — and we add new models to the picker as they ship. The agent stays current with the model landscape, so if you're letting it pick, you'll mostly stay on the right side of those shifts automatically. If you're picking manually, check this page periodically (we update it when the landscape moves) or ask the agent: *"What's the best model on Melius for \[task] right now?"* # Your first 10 minutes Source: https://docs.melius.com/help-center/marketers/quickstart Open Melius and ship something useful before the kettle boils. Goal of this page: in ten minutes you've briefed the agent, generated a few on-brand variants of something real, and learned the three or four mechanics you'll use every day after that. Pick a real task — an Instagram ad for a current product, a hero image for an email, a lookbook frame, whatever's actually on your plate. Working from a real brief is faster than learning from a contrived one. ## 1. Create a project and canvas **1. From Projects, hit 'New project'** Name it after the brand or campaign you're working on. Inside the project, you'll get a default canvas — rename it to something specific (e.g. "Spring email banners"). **2. Open the canvas** You'll see a blank workspace with the agent chat docked on one side. The chat is where you brief the agent; the canvas is where its work appears. ## 2. Give the agent everything you'd give a junior designer The single biggest predictor of good output is how much context you supply up front. Treat the brief like you're handing off to a freelancer with no prior knowledge. Things worth pasting in: * The product PDP URL (the agent will scrape dimensions, colors, materials, copy) * Two or three reference images that match the look you're going for (Pinterest moodboard, competitor ads, existing brand work) * Your logo as a PNG or SVG * A sentence on the audience, the channel, and the desired feeling Example brief (paste into the agent chat): ``` Help me create 5 Instagram Story ads (9x16) for [product]. PDP: [link] Reference style: [attach 2-3 mood images] Audience: parents of teens who worry about losing things. Tone: warm, candid, slightly playful. Not "tech ad." Use the attached logo. Match the color palette of the references. ``` Drop the images into the chat using the paperclip / attach button. Then run it. ## 3. Watch the agent work The agent will start building. You'll see it create text nodes (style analysis, brief synthesis), image nodes (the actual generations), and connect them with edges. The whole thing typically takes 30–90 seconds. If you set the agent to **auto-run**, it'll just build. If you used **ask permission**, it'll pause to confirm decisions — useful if you want to inspect the prompts before generation kicks off. If you move to another page while it's waiting, a notification takes you back to the canvas to approve. Switch auto-run on or off from the gear button at the bottom of the chat box; a green dot on the gear means auto-run is on. ## 4. Inspect the outputs When the agent finishes, you'll have a row of generated images on the canvas. Some will be great, some won't. That's normal — image models are probabilistic, which is why we generate multiple variations at once. For each image node, you can: * Click the image to open it full-screen and see it at full resolution (the on-canvas preview is downscaled to keep the canvas fast). * See the exact prompt the agent wrote in the prompt field. * See which inputs fed in via the edges. ## 5. Tweak one node Pick the variant that's closest to what you want. Read the prompt the agent wrote. Edit it directly — change a word, add a constraint, swap a reference — and hit re-run. The original version is saved as a previous variant on that node, so you can compare them side by side. This is the most important habit to build: **don't redo the whole canvas to fix one image**. Examples of node-level tweaks: * *"Change 'lifestyle' to 'minimal product still life'"* * *"Don't show the back of the product, keep the front-facing angle"* * *"Use Canadian English spelling in any visible copy"* ## 6. Download what you need When you're happy, click the image to expand it and download. The on-canvas preview is 1K-ish for performance; the downloaded file is whatever resolution you set on the node (1K, 2K, or 4K). ## What to learn next * [Set up a brand anchor](/help-center/marketers/brand-anchor) so the agent's outputs are on-brand by default, every canvas, every time. * [Pick the right model](/help-center/marketers/picking-models) — there's no single "best" image model, and the right pick depends on what you're trying to do. * [Make a winning ad work harder](/help-center/marketers/recipes/variants) — once you have an ad that performs, Melius can produce 50 variants of it for testing in an afternoon. > [!NOTE] > > Resolution tip: keep nodes at 1K while you're exploring (it generates 3–4x > faster), then bump to 2K for the variants you're shipping. We launch > generations at 1K by default for exactly this reason. # Localize ads Source: https://docs.melius.com/help-center/marketers/recipes/localize Take an ad that works in one market and produce localized versions for every region — language, copy, cultural cues, and units. Localization is one of the bigger time sinks in performance marketing. You launch a campaign in North America, it works, and now it needs to ship to fifteen markets with translated copy, localized cultural cues, and the right units (miles vs km, currency, regional spelling). Done by hand, it's a multi-week project. Done on Melius, it's a single brief. ## The basic pattern **1. Open the canvas with your source ad** Either the original asset alone, or the full workflow that produced it. The workflow approach is faster if you're localizing several variants — you'll re-run the same workflow with localized prompts. **2. Group the source ad (and its inputs, if you're keeping the workflow)** Select everything you want localized, hit `Cmd+G` to group. **3. Brief the agent** Example: `Take this campaign and generate localized versions for the following markets: Spain (Spanish), Germany (German), Brazil (Portuguese), France (French), Japan (Japanese), South Korea (Korean). For each market: translate all visible copy, adjust units (miles → km where applicable), and adapt any cultural cues so the ad reads naturally to a local audience.` **4. Let the agent generate** For each market, the agent creates a new variant. Translation runs through a language model; the localized text gets baked into the new generation. **5. Review with a native speaker if possible** Translation models are good but not perfect. For markets with high spend, get a quick gut-check from a native speaker — especially for copy with idioms, double meanings, or culturally-specific references. ## What the agent handles automatically The current Melius agent is sophisticated enough that for a well-known brand and market, you don't need to spell out every localization rule. If you ask for "10 versions of this ad for different regions," it knows: * To translate copy into the target language * To switch units of measurement (miles ↔ km, °F ↔ °C, \$ ↔ local currency) * To swap region-specific cultural references (Thanksgiving → equivalent regional holidays where relevant) * To pick imagery that fits — different model demographics, different settings, different aesthetic norms by region For more nuanced localization — political sensitivities, regional spelling (UK vs US English), cultural taboos to avoid — be explicit in the prompt. ## A worked example **Brand:** US-based fitness app. **Source ad:** static showing a runner with text "Track your miles" and a map of San Francisco. **Target:** ten markets, full localization. The brief to the agent: ``` Take @source-ad and localize it for ten markets. For each market: 1. Translate "Track your miles" into the local language, with appropriate unit (use km outside the US/UK/Liberia/Myanmar). 2. Replace the San Francisco map with a recognizable city in the target market. 3. Update the runner's appearance and setting to feel locally appropriate without leaning on stereotypes. 4. Keep the brand palette, typography, and overall composition consistent. Target markets: UK, Germany, France, Spain, Italy, Brazil, Mexico, Japan, South Korea, Australia. ``` The agent generates ten variants on the canvas, each with localized copy, localized map imagery, and localized cultural cues — while keeping the brand's visual identity consistent. ## Working with brand-specific localization rules Many brands have explicit localization guidelines — what to translate vs leave in English, which markets get full localization vs token translation, region-specific brand voice variants. Put these in your brand anchor: ``` ## Localization rules - "Track your miles" should always be translated, including unit conversion. - "[Brand name]" never gets translated. - Use formal "you" (vous, Sie, ustedes) by default — informal only for Brazil and Mexico. - Avoid US-specific holidays in any market other than US/UK/AU. ``` Connect the brand anchor to your localization batch, and the agent will follow the rules across every generated variant. ## Sub-regional localization Some markets are too varied to treat as one localization. The classic case: Miami and rural Texas are both "US," but the audience, language register, and cultural cues are very different. Same for São Paulo vs Recife in Brazil, or Tokyo vs Osaka in Japan. If the spend justifies it, run sub-regional localization: ``` For the US market, generate three city-specific variants: - Miami: include Spanish-language copy alongside English. Beach/tropical setting. - Austin: laid-back outdoor culture. Casual register. - NYC: faster pacing, urban setting. Slightly more formal copy. ``` This is the same pattern as broader localization — just at a tighter granularity. The agent handles it without extra setup. ## Common pitfalls * **Trusting the translation 100%.** Models are good, not perfect. For high-spend markets, native-speaker review is cheap insurance. * **Localizing copy but not imagery.** Translation alone doesn't make an ad feel local — the imagery has to land too. Lean on the agent to swap settings, models, and cultural cues, not just words. * **Ignoring sub-regional variation in big markets.** US, Brazil, India, and a few other markets are too internally varied for a single localization to work everywhere. * **Hardcoding brand terms in the brand anchor without translation rules.** Your brand anchor should explicitly say what translates and what doesn't, or the model will guess. # Animate static ads Source: https://docs.melius.com/help-center/marketers/recipes/motion-on-static Animate an existing static ad with subtle motion — text animating in, a product loop, a background shimmer — without rebuilding it from scratch. You have a static that's performing, and you want a motion version of it for Reels, Stories, or any placement where movement helps. You don't need a new shoot, a new concept, or a motion editor. Image-to-video on Melius animates a still in a minute or two — and the agent writes the motion prompt for you. This is one of the most underused workflows on the platform. Marketers who learn it stop opening motion editors for the easy 90% of motion work. **Time:** 5–10 minutes per clip. **You'll need:** the static ad you want to animate. ## The workflow **1. Drop your static onto the canvas** Drag the finished ad in. If it's already a generated node from earlier work on this canvas, you can use it directly. **2. Create a video node** Right-click → New video node. Seedance 2.0 is the safer default for image-to-video on existing ads (especially anything with people in it); Veo 3.1 is strong for cinematic motion. Match the aspect ratio of your static (1x1, 9x16, 4x5). **3. Pick a duration and resolution** 6 seconds is the sweet spot for ad motion — long enough to loop, short enough to render fast. 720p is fine for early iterations; bump to 1080p for production. **4. Use the agent to write the motion prompt** Open a new agent chat on the canvas. Tag the source node with `@`, and brief the agent. The reliable pattern: `@variation-1: using Seedance, help me animate this image. 1x1 aspect ratio, 720p, 6 seconds. Keep all of the text in the same spot and keep it static. Add some light, graceful motion to [the product / the hands / the background] that loops cleanly.` Specifying *what stays still* is at least as important as specifying *what moves*. Without that, the model will animate everything — including the text — and you'll end up with copy that drifts mid-frame. **5. Watch the agent build the video node** The agent writes a Seedance prompt, connects the source image as the reference, and kicks off the generation. Video runs take longer than image runs — typically 1–3 minutes. **6. Review and tweak** If the motion is right but you want to adjust something (slower, different element moving, looping more cleanly), edit the prompt directly on the video node and re-run. Each re-run saves as a new version on the node, so you can compare without losing the original. ## What "subtle motion" actually means The mistake is asking for too much movement. Ad motion that converts is usually small: * **Light parallax on the product.** Subtle shift, like the camera is breathing. * **Loose elements moving.** Liquid in a glass, fabric in a breeze, hair, foliage, packaging held by a hand. * **A single accent loop.** A glint, a sparkle, steam, light reflection. One thing moving, everything else still. * **Text animating in.** Letterforms fading or sliding in over the first second, then static. * **Background shimmer.** The subject stays locked; the background subtly shifts color or texture. The wrong instinct is "make the whole scene move." That reads as AI-generated and pulls attention away from the product. ## A worked example A static of a supplement bottle held in two hands against a soft pastel background. The brief to the agent: ``` @hero-static: animate this image using Seedance. 1x1, 720p, 6 seconds. Keep the text, logo, and bottle label exactly where they are. Add a slow, graceful motion to the hands — a small breathing parallax as if the model is holding the bottle steady. The background should have a subtle warm light shift, like soft morning light moving across. Loop cleanly. ``` Six seconds of generation later, you have a Reels-ready motion ad that took roughly as long as it took to write the prompt. No motion editor, no keyframes, no exports. ## Why use the agent instead of writing the prompt yourself Two reasons: 1. **Motion prompts are unintuitive.** The vocabulary that gets you good results from Seedance or Veo 3.1 isn't obvious if you haven't spent time with these models. The agent has been trained on what works. 2. **You probably don't know off the top of your head how to phrase the motion you want.** You know what you want it to *look* like. The agent translates that into prompt syntax — "graceful," "loops cleanly," "subtle parallax" — that the model will actually follow. You can still tweak the prompt the agent writes. But starting from the agent's draft beats starting from a blank field. ## Common pitfalls * **Animating everything.** Tell the agent what stays still, not just what moves. Text especially — it should almost always be static. * **Too long.** A 12-second loop of a static ad with subtle motion gets boring. 6 seconds is right. * **Resolution too low for production.** 720p reads fine on phones; for desktop placements or larger formats, bump to 1080p before shipping. * **Not specifying the loop.** Without "loops cleanly," the model may end on a different frame than it started — fine for one-shots, jarring as a loop. Always specify. > [!NOTE] > > Captions on motion ads still live outside Melius for now — most teams export > the video and add captions in their video editor. Caption tooling is coming > with the timeline editor; we'll update this page when it's live. # Product photos and swaps Source: https://docs.melius.com/help-center/marketers/recipes/product-swap Swap your product into a generated scene, produce on-brand product photography without a studio shoot, and keep dimensions and logos accurate. Product photography is one of the highest-leverage uses of Melius. Instead of booking a photographer, lighting a set, and waiting three weeks for assets, you can produce production-grade product shots in an afternoon — including lifestyle context, seasonal scenes, and channel-specific variants. The two main workflows: **product photography from scratch** (generate the whole scene) and **product swap** (place your real product into an existing scene). Both follow similar mechanics. ## Workflow A: Product photography from scratch **Goal:** generate a hero shot or lifestyle image with your product as the centerpiece. **1. Drop your pack shot on the canvas** A clean product photo on a neutral background. If you have multiple angles, drag in all of them and unified-group them — the agent will use all angles as reference. **2. Paste the PDP URL into the agent chat** Brief: *"Pull the product details from \[URL] — focus on dimensions, materials, and color. Save it as a text node."* This gives the agent the actual physical specs to anchor on. **3. Add a style reference if you have one** A moodboard, a competitor's product photography, or an existing campaign whose look you want to mirror. Use [the style analysis workflow](/help-center/marketers/recipes/style-reference) to turn the references into a usable style description. **4. Create an image-to-image node** Right-click → New image node → Image-to-image. Pick Nano Banana Pro at 2K and the aspect ratio you need. **5. Connect everything in** Pack shot → image input. PDP details → context input. Style description → context input. (Use `@` mentions in the prompt as a shortcut.) **6. Write the prompt** Keep it grounded in what's *not* changing. Example: `Hero shot of @product in [setting]. Use the exact product from the reference — don't restyle the product, don't change its color, don't modify its shape or proportions. Use the @pdp-details for accurate dimensions and materials. Use the @style-description for lighting, composition, and mood.` **7. Run 3–4 variations** Inspect the results in full-screen mode (the canvas preview is downscaled). Pick the strongest. ## Workflow B: Product swap **Goal:** drop your product into a scene you already have (or have generated), replacing whatever was there. **1. Drop the target scene onto the canvas** The image where you want your product to appear. Could be one you generated earlier on the canvas, or a stock image you've uploaded. **2. Drop your product pack shot in too** Same as before — clean photo, ideally with multiple angles unified-grouped. **3. Create an image-to-image node** Nano Banana Pro, 2K. Aspect ratio matching the original scene. **4. Connect both as inputs** Scene → image input. Product → context input. **5. Write a swap prompt** Example: `Replace the [object/product] in @scene with the @product from the reference image. Keep everything else identical — same lighting, same composition, same color grade, same camera angle. Match the placement, scale, and orientation of the original [object]. Make the proportions and placement of the product feel natural and realistic.` **6. Run 3–4 variations** Inspect the results. If the product is the wrong scale or placed awkwardly, tweak the prompt with specifics (*"the product should be slightly larger, occupying about 30% of the frame width"*) and re-run. There's a **Product Swapper** preset in the templates menu that pre-configures this entire flow. If you find yourself doing product swaps frequently, start from the preset instead of building from scratch. ## Keeping product fidelity high Product fidelity is the #1 issue marketers raise on onboarding calls. The product almost-but-not-quite matches — the proportions are slightly off, the logo is rendered as a similar-looking-but-not-correct shape, the material drape looks generic. Here's the fix kit: ### Always include the PDP URL The PDP scrape gives the agent your product's actual dimensions in cm/inches, its material specs, and its color codes. Without this, the model is guessing from a single photo — and it'll guess wrong on proportions roughly half the time. ### Always include a pack shot, not just a lifestyle reference A lifestyle photo of your product in use doesn't give the model a clean view of the product itself. Drag in a clean studio shot or a transparent PNG as the product reference, separately from any mood references. ### Add the logo as its own node If the product has visible branding, drop the logo file (PNG or SVG) onto the canvas as a separate node. Connect it to the image node. In the prompt: *"Use the @logo for any branding visible on the product. Do not redraw it — use the reference exactly."* ### Use Nano Banana Pro for style; GPT Image 2 for visible text Nano Banana Pro handles material and lighting fidelity better. GPT Image 2 is unmatched for rendering legible typography (product names, labels, packaging copy). If your product has visible text on the packaging, lean GPT Image 2. ### Force higher resolution 1K previews look softer than the actual output, but going straight to 2K (or 4K) gives the model more detail to work with on small features — fine fabric weaves, embossed logos, label typography. Worth the extra render time. ## Common pitfalls * **No pack shot, just a lifestyle reference.** The model can't see the product clearly. Add a clean studio shot. * **No PDP URL.** Proportions and dimensions drift. Paste the URL. * **Re-prompting the whole thing when the product is slightly off.** Edit the existing node's prompt with a specific correction instead. *"Keep everything else, but: the product should be 20% larger / oriented vertically / placed in the foreground."* * **Logo regenerated from scratch.** Add the logo as its own reference node and tell the prompt not to redraw it. > [!TIP] > > If you're producing product photography at scale, build the workflow once on > one SKU, get it dialed in, then duplicate and swap inputs for each > additional product. This is how high-volume DTC teams produce hundreds of > product variants per week — see [Make a winning ad work > harder](/help-center/marketers/recipes/variants). # Resize for channels Source: https://docs.melius.com/help-center/marketers/recipes/resize Take one finished image and generate every aspect ratio you ship to in a single click. Every ad needs to ship in multiple aspect ratios: 1x1 for legacy placements, 4x5 for Instagram feed, 9x16 for stories and Reels, 16x9 for YouTube and desktop video, 21x9 for email banners. Doing this by hand is the kind of repetitive task that eats afternoons. **Magic Resize** does it in one click. Pick the aspect ratios you want, and the agent generates a properly-composed version of your image for each one — re-laying out the elements rather than just cropping the original. ## Why this is different from cropping Cropping (what Meta does automatically when you don't supply the right format) frequently kills the composition. Subjects get clipped at the edge, copy gets cut off, hero products get pushed out of frame. The platforms' auto-crop logic is good but not great, and most performance teams want control over how their ads adapt. Magic Resize uses an AI pass to actually re-compose the image — moving the subject, repositioning copy, regenerating the background as needed — so each aspect ratio looks intentionally designed rather than algorithmically cropped. ## The workflow **1. Right-click your image node** Or select the image on the canvas and look in the toolbar on the right. **2. Hit Magic Resize** A grid of aspect ratio options appears: 1x1, 4x5, 9x16, 16x9, 4x3, 3x4, 21x9, and so on. Click each one you want generated. **3. Run** The agent generates each variant in parallel. New image nodes appear on the canvas — one per selected aspect ratio — all connected back to the original. **4. Review and download** Hover over a generated variant and click **Fullscreen**. Select an aspect ratio in **Versions** on the left to preview it. The **Details** panel on the right shows that asset's dimensions, file size, tags, and generation information. Use the arrow keys to browse variants, download the selected image, or press **Escape** to return to the canvas. ## Standard ad formats by channel If you're not sure which ratios to generate, the common defaults: * **Meta feed (Facebook/Instagram):** 1x1 or 4x5 * **Meta stories/reels:** 9x16 * **Meta in-stream video:** 16x9 or 4x5 * **TikTok/Reels:** 9x16 * **YouTube pre-roll:** 16x9 * **LinkedIn feed:** 1x1 or 16x9 (1.91:1 specifically) * **Display banners:** varies — 300x250, 728x90, 160x600 are common, but most are close enough to 1x1, 21x9, and 4x5 respectively * **Email banners:** 21x9 is a good default for hero banners that need to fill the width without scrolling below the fold When in doubt, generate 1x1, 4x5, and 9x16 — those three cover \~80% of paid social placements. ## Working with Magic Resize on multiple images at once If you have a batch of finished ads on the canvas, you can apply Magic Resize to all of them in one agent brief: ``` Take every image node in the "winners" group and run Magic Resize on each. Generate 1x1, 4x5, and 9x16 versions of all of them. ``` The agent will queue all the resize jobs in parallel. ## When Magic Resize isn't the right move A few cases where it's better to regenerate from scratch rather than resize: * **The composition logic is fundamentally different per channel.** A 16x9 video frame and a 9x16 story sometimes need entirely different shot composition, not the same shot reflowed. Generate them separately from the same brief. * **The aspect ratio change requires major background extension.** Going from 9x16 to 21x9 forces the model to invent a lot of background. The result is usually fine for environmental shots but can break for tight portrait or product compositions. * **You haven't finalized the source image yet.** Don't resize a draft — the resizing pass also locks in compositional choices you might still want to change. ## Common pitfalls * **Selecting too many aspect ratios.** Pick the channels you actually ship to. Eight aspect ratios of a draft is forty seconds of waste; eight aspect ratios of every variant in a 50-variant batch is real time. * **Resizing at 1K and shipping it.** Make sure your output resolution is set to 2K (or higher) on the Magic Resize variants before downloading. The on-canvas preview is downscaled — what you see isn't the final resolution. * **Forgetting to brand-check the resized versions.** A composition that worked at 9x16 might push your logo or CTA off-canvas at 1x1. Spot-check every variant before shipping. # Static ads from references Source: https://docs.melius.com/help-center/marketers/recipes/style-reference Take a look you like — a mood board, a competitor ad, an existing campaign — and produce a batch of new statics in that style. This is the most-run workflow on Melius. You have a look you want to hit — your own past campaign, a competitor's ads, a Pinterest board, a fashion editorial — and you want a fresh batch of statics in that style. **Time:** 10–15 minutes from open canvas to first downloadable assets. **You'll need:** 2–10 reference images, a clear sense of the product or subject, and a brand anchor if you have one ([how to make one](/help-center/marketers/brand-anchor)). ## The workflow **1. Open a new canvas** Name it for the campaign. If you have a brand anchor, paste it in as a text node now and keep it parked at the top of the canvas — you'll connect things to it later. **2. Drop your references in** Drag 2–10 mood images onto the canvas. Two to four is usually plenty; more than ten often hurts. **3. Group them as a unified group** Select them all, right-click → "Unified group". This gives you one output port for the whole set. **4. Add the Image Style Analysis template** Templates menu → "Image style analysis". A pre-configured text node appears on the canvas. Use Gemini 3.8 Flash for image analysis. **5. Connect references → style analysis** Drag from the unified group's output into the style analysis node's reference input. Hit run on the text node. **6. Read what came out** The style analysis output is a detailed description: palette, lighting, mood, composition, depth of field, shot type. If anything seems off, edit it directly — the output is just text, you can rewrite it. **7. Create your output image node** Right-click on the canvas → New image node. Pick Nano Banana Pro (best for style adherence) at 2K resolution and the aspect ratio you need (9x16 for stories, 4x5 for feed, 1x1 for legacy, 21x9 for email banners). **8. Connect the style analysis output to the image node** Drag from the style analysis text output into the image node's input. **9. Write the prompt** Keep it short. The style description is doing the heavy lifting. Example: `Generate a hero image of [product] [in this scenario]. Use the style description below as the visual reference.` **10. Run 3–4 variations** Set the variations count to 3 or 4 before hitting run. The model is probabilistic — running multiple in parallel is faster than running one, getting a bad result, and trying again. **11. Pick winners, tweak the rest** Some variants will land, some won't. For the close-but-not-quite ones, edit the prompt directly on that image node — *"keep everything else the same, but..."* — and re-run. Each re-run is saved as a new version on the same node, so you can compare without losing the original. ## A worked example **Brand:** boutique apparel. **Goal:** five product hero shots in the style of a fashion editorial moodboard. The moodboard (six images, all painterly product photography with warm tones) goes into a unified group. Style analysis runs on the group and outputs: > *"Editorial product photography. Warm golden-hour lighting from camera-left. Shallow depth of field, painterly bokeh. Product centered with negative space above. Color palette: cream, terracotta, soft black. Composition feels like a 1990s magazine layout — generous margins, no graphic overlay..."* The image node is set to Nano Banana Pro, 4x5, 2K. The prompt: ``` Hero shot of @hoodie in the style described below. The hoodie is the subject. Soft natural light. Editorial composition. Use the style description for color, lighting, and mood. ``` Run with 4 variations. Two are usable as-is, two need minor tweaks (one has the hoodie too small in frame; the other has color that's drifted toward orange instead of terracotta). Both fixes happen on the node — edit the prompt, add the constraint, re-run. Total time from blank canvas to four production-ready hero shots: about 12 minutes. ## Common pitfalls * **Forgetting to run the style analysis node.** If you connect everything and skip the run step on the text node, the analysis output is empty and the image node has no style guidance. Always run the text node before the image node. * **Mixing incompatible references.** Five fashion editorials and one screenshot of an ecommerce storefront will confuse the style analysis. Keep the moodboard internally consistent. * **Picking the wrong model.** Nano Banana Pro is best for style adherence. GPT Image 2 is better when the output has a lot of legible typography. Use the right one for the job — see [Pick the right model](/help-center/marketers/picking-models). * **Skipping the unified group.** You can connect each reference image to the style analysis node individually, but it's tedious and easy to forget one. Unified groups handle this in a single edge. > [!TIP] > > Once you have a style analysis text node that's working well, you can copy > and paste it across canvases — same brand, different campaigns. It's a small > reusable artifact that pays off every time. # UGC videos Source: https://docs.melius.com/help-center/marketers/recipes/ugc-video Generate UGC-style video ads on Melius with live-action or fictional avatars, consistent character sheets, voiceovers, and multi-clip stitching. UGC-style video is one of the harder categories of paid creative to produce: it needs to feel authentic, the character needs to look consistent across cuts, the voiceover has to land, and the pacing has to work. Doing all this manually is slow. Doing it on Melius collapses the bottleneck. **Time:** 30–60 minutes for a single 30-second spot end-to-end. **You'll need:** a script (or a brief to generate one), an avatar reference (a photo, reference artwork, or a description), and the product. ## The general shape A UGC ad is usually three to six short clips stitched together with voiceover and on-screen copy. The Melius workflow: 1. **Define the character** — generate a character sheet so the same avatar and visual style appear across every cut. 2. **Generate each clip** — image-to-video from a starting frame, using the character sheet for consistency. 3. **Add voiceover** — use an audio node to generate the voice. 4. **Stitch the clips** — use a stitch node to concatenate them into the finished video. You finish the timeline polish (captions, cuts, music) in your video editor of choice. Most teams hand the stitched output off to their video editor as a starting point. ## Step 1: Character sheet A character sheet shows the same avatar from multiple angles with consistent features, proportions, clothing, and materials. Your avatar can be a live-action human or a fictional character in a style such as claymation, stop-motion, 2D illustration, or stylized 3D. The reference sheet keeps both the identity and the visual medium consistent across cuts and locations. > [!NOTE] > > For a speaking avatar, use a design with a visible, unobstructed mouth. If > the avatar holds or demonstrates a product, give the design usable, visible > hands. Voiceover-only videos can use a wider range of character designs > because the avatar does not need to lip-sync on camera. **1. Drop in reference art or a photo** Use artwork for an existing fictional design, a moodboard image, or a custom-generated portrait. Try not to use a real identifiable person without permission. **2. Brief the agent** *"Help me build a character sheet from this reference. I want four or five angles — front-facing, three-quarter left, three-quarter right, profile, and a casual everyday shot. Use GPT Image 2 (Medium). Image-to-image, keep the identity, body plan, surface materials, and visual medium consistent."* **3. The agent generates the angles** You'll get four to five image nodes. If the identity, anatomy, or visual style drifts from the reference, regenerate just that node. **4. Unified-group the angles** Select the character sheet images and create a unified group. You now have a single reference port you can drag into every downstream video node. > [!TIP] > > You can also consolidate the angles into a single sheet image: *"Combine > these angles into a single character sheet image in grid format."* The agent > creates one image with all angles laid out — handy for handoff and easier to > drag around the canvas as one reference. ## Step 2: Generate the clips For each clip in your script: **1. Create a video node** Right-click → New video node. Pick Seedance 2.0 (best for character work — we have un-gated face access) at 9x16, 720p (faster) or 1080p (production). **2. Connect inputs** * **Character sheet** → reference image input (keeps face consistent). - **Product pack shot** → reference image input (if the product appears in the clip). - **Brand anchor / script context** → context input. **3. Write the clip prompt** Describe what's happening in the clip and what the character is doing/saying. Example: `9 seconds. Character (from @character-sheet) sitting at a kitchen counter, holding @product, looking directly at the phone camera UGC-style. Natural morning light. Slight head movement, conversational energy. Setting: casual home kitchen.` **4. Run with 2–3 variations** Video generations are slower and more expensive than image gens, so don't overdo variations. Three is usually plenty for the model to give you a usable take. **5. Repeat for each clip** Duplicate the video node (`Cmd+C` / `Cmd+V`) and change only the prompt for each clip. The character sheet and product references stay connected. > [!WARNING] > > Most video models cap at 9–12 seconds per clip. For a 30-second ad you'll > need three to four clips stitched together. Plan your script around that > constraint. ## Step 3: Voiceover **1. Create an audio node** Right-click → New audio node. ElevenLabs is the current voice provider. **2. Pick a voice** Roughly 20 voices are curated in the picker. We have access to the full ElevenLabs catalog — if you need a specific voice that isn't in the picker, ping us in Slack. **3. Paste your VO script** The audio node will generate a clip from the script. Keep clips short — under 30 seconds each — for quality and consistency. > [!NOTE] > > Clone a voice from a sample and reuse it across canvases for consistent > persona-driven UGC on **Creator** and above. You can also [import custom > voices from ElevenLabs](/integrations/elevenlabs). [Compare > plans](/billing/plans). ## Step 4: Stitch the clips **1. Create a stitch node** Right-click → New stitch node. Or brief the agent: *"Use a stitch node to combine the video clips in order: opening, body 1, body 2, body 3, closer."* **2. Connect each video clip** Drag from each video node into the stitch node in the order they should appear. **3. Set output settings** Aspect ratio, resolution, fit-to-screen vs stretch-to-fill. Match the platform you're shipping to. **4. Run** The stitch node outputs a single video file with the clips concatenated. Running just the stitch reuses finished clips and audio. Connected sources that have no finished output generate first. To replace a finished take, run that source explicitly before stitching. Stitching finished clips is free and reuses their existing outputs. If you ask the agent to generate new clips or audio and stitch them together, only those new generations cost credits. When narration continues past the last video clip, the stitched video shows a black screen while the remaining audio plays. The output lasts until both the visuals and audio have finished, preserving the full narration and its timing. For narration-only output, ask Mel to mute the original clips while keeping your separate narration track. In the stitch editor, muted clips show 0% on the existing volume control. Drag a clip's volume to adjust its sound. When checking a repaired voiceover, ask Mel to verify the saved export. Include the exact script if you want its completeness checked. Mel checks the actual audio and duration; speech and requested loop transitions also use automated media inspection. Verification supports exports up to 100 MiB and 180 seconds. An uncertain or unavailable check is reported as **unverified**, and a detected problem is reported as **failed**. The file stays available in either case. If downloading fails, ask Mel to retrieve the existing finished export again. Checking or downloading it does not regenerate your clips or audio. Replacing paid inputs requires your explicit permission. ## Step 5: Finish in your editor Download the stitched video and the voiceover audio (as separate files). Hand both to your video editor — they'll add captions, sync the voiceover, drop in music, and handle the last-mile polish. > [!NOTE] > > Captions inside Melius are coming with the timeline editor. Until then, > captioning is the one part of UGC video work that still leaves the canvas. > Most teams handle it in their video editor of choice. ## A common pattern: agency UGC at scale Agencies producing UGC for clients typically structure work like this: * **One project per client.** Brand anchor lives in a text node at the top. * **One canvas per campaign.** Holds the character sheet, product references, and all the clips. * **Claude drives the build.** Via MCP, Claude reads the campaign brief and creative concept, then builds out the canvas — character sheet, clip nodes, voiceover, stitch — automatically. The designer or marketer comes in afterwards to pick winners and polish. This is how a 1-person creative ops team can produce 10–20x more video output than they could a year ago. See [Drive Melius from Claude](/help-center/marketers/mcp) for the setup. ## Common pitfalls * **Character drift across clips.** Without a character sheet, every video generation can change the face or head design, anatomy, materials, or clothing. Always build the character sheet first. * **One clip per take, no variations.** Video generations are probabilistic too. Run 2–3 variations per clip — the cost is real but small, and the time saved on bad takes is large. * **Trying to render a 30-second clip in one node.** Models cap at 9–12 seconds. Plan your script around 3–4 short cuts. * **Forgetting product references in the clips that show the product.** The model will invent a product that isn't yours. Connect the pack shot to every video node that needs the product visible. # Scale winning ads Source: https://docs.melius.com/help-center/marketers/recipes/variants You have an ad that performs. Use Melius to produce 10, 50, or 200 variants of it for testing. When one ad concept is working, the leverage is in scaling it — different products, different angles, different copy, different audiences — without rebuilding from scratch each time. Melius is built for this. A whole variant cascade that used to take a creative team a week typically lands in an afternoon. **Time:** 30 minutes for a basic 5–10 variant pass; an afternoon for 50+ variants with multiple dimensions. **You'll need:** the winning ad (or its constituent parts on a canvas), and a clear list of what you want to vary. ## What you can vary Variant dimensions worth running in parallel: * **Product / SKU.** Same ad, different items from the catalog. Common for retail and DTC. * **Audience segment.** Same product, different model, setting, or lifestyle context. * **Region.** Same ad, localized for different markets — different copy language, different cultural cues, different units. See [Localize for international markets](/help-center/marketers/recipes/localize). * **Channel.** Same image, every aspect ratio you ship to. See [Resize for every channel](/help-center/marketers/recipes/resize). * **Copy / headline.** Same image, different CTA or headline. * **Color / mood.** Same composition, different palette — useful for seasonal campaigns. Pick one or two dimensions to vary at a time. Varying all six at once gives you a matrix of 100+ ads with no signal about which dimension is moving the needle. ## Three ways to generate variants ### Option 1: Ask the agent for N versions Best for casting a wide net early. You'll get diversity but less control over the specific variations. **1. Drop the winning ad onto a canvas** Drag it in from your downloads, or copy it across from another canvas. This is the source the agent will riff off. **2. Brief the agent** The reliable prompt pattern, lifted from how customers actually phrase it: `Help me create 8 variations of this ad, using different creative angles and briefs. Keep the style and vibe similar otherwise. Use GPT Image 2 at 2K resolution. Mix up different aspect ratios.` Tweak the count, model, and aspect ratio rules to match the brief. Specifying the model is worth doing — if the variants need legible copy, call out GPT Image 2; if they need style adherence, call out Nano Banana Pro. **3. Let it run** The agent will reason through different creative angles, write a brief for each, and create one image node per variant — all connected to the same source ad and your brand anchor. **4. Review and tweak** Some will land first time. For the ones that didn't, edit the prompt on that specific node and re-run. > [!TIP] > > This is the workflow most marketers reach for when they have one ad that's > performing and want to test angle variations. The agent's strength is in the > *creative angle* dimension — it'll come up with different framings, > scenarios, and copy hooks that a single human brief wouldn't have produced. > You're outsourcing the angle generation, not the taste call. ### Option 2: Multi-variation on one node Best when you want the same prompt run multiple times to get options — controlling for the probabilistic nature of the models rather than producing genuinely different ads. **1. On the image node, set variations to 3–10** The variations setting is in the node's right-side panel. Up to 10 in parallel. **2. Hit run** All variations run in parallel via our temporal workflow infrastructure — you don't wait for one to finish before the next starts. **3. Pick the strongest** Each variation is saved on the same node. Click through them to compare. The unselected ones don't disappear; you can come back to them. ### Option 3: Duplicate the workflow Best for systematic variation across a known set — every product, every region, every seasonal moment. **1. Build the workflow once** Reference image → style analysis → output image. Get it working for one variant. **2. Select the whole flow and duplicate** Select all the connected nodes (`Cmd+A` and trim, or drag-select), then `Cmd+C` / `Cmd+V` to duplicate. You now have two parallel copies. **3. In the duplicate, swap the input** Use the upload node to swap in the next product photo, or change the reference link, or update the prompt. The downstream nodes will re-run automatically with the new input. **4. Repeat for every variant** Same logic — paste, swap input, run. Option 3 is the most production-ready. You end up with a canvas where every column is a different variant and every row is the same step in the workflow — easy to scan, easy to hand off, easy to revisit. ## Brand-checking variants The risk of generating variants at volume is that some will drift off-brand. Two ways to keep this in check: * **Connect the brand anchor to every output node.** Every image node should pull from your brand anchor text node as context. If one variant drifts, the brand anchor is your reference for what to fix. * **Run a final brand-check pass.** Once you have your variant set, brief the agent: *"Review every variant on this canvas against @brand-anchor. Flag any that drift on palette, typography, or composition, and regenerate them."* The agent will do the audit and re-run the offending nodes. ## When to use a scheduled run If you produce variants on a regular cadence — weekly product spotlights, monthly campaign drops, etc. — you can have an external agent (Claude with MCP, for example) kick off the canvas on a schedule. The pattern most teams use: Claude takes the latest brief on Monday morning, builds out the canvas with all the variants, and pings the designer in Slack with a link when the run finishes. The designer picks the winners. Production capacity that used to require an in-house team is now an overnight cron job. See [Drive Melius from Claude](/help-center/marketers/mcp). > [!TIP] > > When generating 50+ variants, keep all output nodes at 1K resolution. Once > you've picked winners, regenerate just those at 2K or 4K — there's no reason > to render the losers at full resolution. ## Common pitfalls * **Varying everything at once.** Diluted signal. Vary one or two dimensions per batch. * **Not connecting the brand anchor.** Variants drift faster the more of them you produce. The brand anchor is the seatbelt. * **Rendering at 4K from the start.** Slow, and most variants will be losers. Render at 1K, pick winners, upgrade resolution selectively. * **Manual variant creation.** If you're recreating the same setup five times by hand, you missed the "duplicate the workflow" pattern. Build once, paste many. # Repeatable workflows Source: https://docs.melius.com/help-center/marketers/repeatable-workflows Turn one-off canvases into reusable templates so the next campaign, SKU, or region starts at 80% built. Most marketing creative is variants of work you've already done. New SKU launches use the same hero-shot workflow. Each new campaign follows the same brand-anchor → style-analysis → output structure. UGC ads for every product use the same character-sheet → clip → stitch flow. Setting up these workflows once and reusing them is the difference between "Melius is faster than the old way" and "Melius is 10x faster than the old way." This page covers the mechanics for making canvases reusable. ## Duplicate a canvas The simplest pattern. You've built out a workflow on one canvas, it works, you want to run the same workflow for a different input (next product, next region, next campaign). **1. Duplicate the source canvas** Click the canvas name at the top left to open the canvas list. Hover the source canvas, open its menu and choose **Duplicate**. A copy appears right below it and opens. **2. Rename the copy** In the same list, hover the copy and click , or double-click the canvas you have open. Name it after whatever variant it'll handle — "Spring email banners — SKU 2" or "Localization batch 1". **3. Check the duplicate** Same nodes, same connections, same prompts — fully populated, ready to swap inputs. **4. Swap the source inputs** The reference images, the PDP URL, the product pack shot — replace each with the new variant's equivalents. The downstream generations re-run automatically with the new context. For 20–50 variants, this is faster than asking the agent to do it via chat — there's no ambiguity, no re-explaining what you want, no review. ## Use the Upload node for input-swapping If you've built a workflow where everything downstream depends on one source image, the **Upload node** turns that into a clean swap point. **1. Build your workflow with an Upload node as the entry point** Right-click → New upload node. Connect it to whatever the workflow consumes the image for (image-to-image input, style analysis reference, product pack shot). **2. Upload your first image** The workflow runs. **3. When you want a new variant, just replace the upload** Select the Upload node and press **Cmd+R** on Mac or **Ctrl+R** on Windows/Linux, or click **Upload new version** in its toolbar. Choose the replacement file to add a new version to the same node. Every downstream node re-runs with the new input. This is the cleanest pattern for "same workflow, different SKU." You're not duplicating the canvas; you're feeding the same workflow new inputs. ## Build a project-level template canvas For workflows you'll use across many campaigns — your standard "static ad batch" build, your "UGC video" build, your "product photography" build — keep a clean **template canvas** in each project. The template canvas has: * The brand anchor as a text node, pre-populated * Empty Upload nodes for the inputs that change per campaign * The workflow nodes wired up with prompts and model choices * A short text annotation at the top explaining what the template is for When you start a new campaign, duplicate the template canvas, fill in the inputs, run. We don't currently have a "Make this canvas a template" button (it's on the roadmap). Until then, the duplicate-and-swap pattern serves the same function — the canvas just sits there, named "Template — static ads," ready to copy. ## Use templates / presets (the built-in ones) Melius ships with a set of presets that wrap common workflows into one drop-in node group. Useful ones: * **Image Style Analysis** — turns a moodboard into a usable style description. See [Static ads from a reference style](/help-center/marketers/recipes/style-reference). * **Product Swapper** — pre-configured product-into-scene workflow. See [Product photography & swaps](/help-center/marketers/recipes/product-swap). * **Image -> Boomerang** — turns a static image into a short looping animation, useful for Reels and Stories. Open **Explore** to browse them at [app.melius.com/explore/recommended](https://app.melius.com/explore/recommended). Templates sit in the same grid as the looks Melius publishes. Use the search field to find one by name, and **Favorites** beside **History** to save one for your team and come back to it. On your first visit, a four-slide introduction explains how templates work. Choose **Continue** to advance, then **Browse templates** to enter Explore, or close it at any point. Completing or closing it is remembered for your account in that browser. Click a card to view its details and example inputs and outputs. Choose **Try template** to open its run screen, add your inputs or use the examples, and review the credit cost before generating. Each time you open a template in **Explore**, its preview shows the template's example, not your most recent generation. A new result appears while the dialog stays open; previous results remain in **History**. Share a template with the link button in the top right of its dialog, which copies the template's URL. In apps that show link previews, a public template's link shows its preview image or saved video frame with the Melius logo. Team-only templates keep a generic Melius preview, and sharing a link does not change who can access the template. A run that fails shows the reason in place of its output, along with how many credits it charged and how many were refunded. Melius deletes the canvas the run created, along with anything its earlier steps generated, and keeps your inputs in the form so you can generate again. **History** on the run screen keeps the runs that produced an output, with any credits refunded for steps that failed. You can leave the run screen while a run generates. The **History** button in Explore's header counts your runs still generating, a notification tells you when each one is ready, and the button counts the new results until you open it. A run of yours that couldn't be made stays in **History** with the reason in place of its image, and any credits it charged are refunded. Your team's tab lists finished results only. You can use these as starting points, then customize them for your specific use case. Once customized, the workflow is reusable across canvases via duplicate-and-swap. ## Use Claude (MCP) to spin up canvases programmatically For the highest-volume workflows — daily/weekly variant batches, scheduled production runs — the MCP path is the right answer. Instead of duplicating a canvas by hand, you brief Claude with a standing instruction: ``` For each new product launch, build a canvas in the [Brand] Melius project named after the product. The canvas should include: - The brand anchor as context - A product hero shot (Nano Banana Pro, 2K, 4x5) - Three lifestyle variants (Nano Banana Pro, 2K, 4x5) - Magic Resize on all four to 9x16 and 1x1 ``` Now any time you tell Claude *"new product launch for \[SKU]"* with the product reference attached, it builds the whole canvas to spec — no manual setup, no template-hunting. See [Drive Melius from Claude](/help-center/marketers/mcp). ## Multiplayer and shared canvases Repeatable workflows often live inside a team, not in one person's head. A few practices that help: * **Naming convention.** "Template — \[workflow name]" for templates, "\[Campaign name] — \[variant set]" for active work, "Archive — \[date]" for completed campaigns. Consistent names make it easier for teammates to find the right canvas. * **Sticky notes for documentation.** Drop sticky notes on a template canvas explaining what each section does. Press `N` (or right-click) to add one. Future you, and your teammates, will thank you. * **Comments for handoffs.** When you finish a draft and want a designer to review, drop a comment with `C` and `@mention` them. They get notified, can reply on the canvas, and resolve the thread when done. * **One project per client / brand.** Don't mix clients in one project. The MCP path, in particular, works best when each project maps to one brand. ## Common pitfalls * **Rebuilding the same workflow from scratch every time.** If you've done this twice, save the canvas as a template and copy it on the third pass. * **Templates that include real campaign content.** A template canvas should have placeholders, not the last campaign's specific images. Strip the campaign-specific stuff before parking the canvas as a template. * **Skipping the naming convention.** A project with 40 canvases all named "Untitled" is unsearchable. Name everything. * **Not putting the brand anchor in the template.** If every workflow starts by re-pasting the brand anchor, you didn't bake it into the template. Bake it in. # Troubleshooting Source: https://docs.melius.com/help-center/marketers/troubleshooting The issues that come up most often on onboarding calls, with the fixes that work. This page collects the issues we see most across marketer onboarding sessions, and the fixes that work. If something on this page describes what you're hitting, the fix should take less than a minute. If it doesn't, drop a note in the Slack channel and we'll help directly. ## Output doesn't reflect the style anchor I connected **Most common cause:** you didn't run the text node. The Image Style Analysis template, and any text node with an LLM call, doesn't auto-run when you create it. You have to click into the node and hit Run. If you connect an image node to a style analysis that's never been run, the image node sees an empty context and falls back to whatever its own prompt says. **Fix:** click the style analysis text node, hit Run, wait for the output to appear, then re-run the downstream image node. Subsequent re-runs will use the same analysis automatically. ## Logo is wrong, distorted, or invented **Most common cause:** the model is generating the logo from scratch instead of using your file as a reference. **Fix:** * Drag your logo file (PNG or SVG) onto the canvas as its own node. * Connect it to the image node as a reference. * In the prompt: *"Place the @logo as shown in the reference. Do not redraw it — use the file exactly."* If the logo still drifts, switch to GPT Image 2 (High) — it's more faithful to reference images for graphic elements. ## Product dimensions / proportions look wrong **Most common cause:** the model is guessing at your product's size and shape from a single lifestyle photo. **Fix:** * Paste the PDP URL into the agent chat: *"Pull product details from \[URL] focusing on dimensions and proportions."* The agent creates a text node with the actual specs. * Add a clean pack shot (studio photo on neutral background) as a separate reference. * Connect both to the image node. ## Output looks blurry on the canvas, but downloads sharp **This is expected behavior.** The on-canvas preview is downscaled to keep the canvas fast and responsive. The actual file is full-resolution. To see the real output: * Click the image to open it in full-screen mode, OR * Download the file — it'll be at whatever resolution you set on the node (1K / 2K / 4K). If the downloaded file is also blurry, check the node's resolution setting — you may be generating at 1K when you wanted 2K. ## "I love this generation. The next one isn't as good." **Most common cause:** image models are probabilistic. The same prompt run twice can produce noticeably different results. **Fix:** * Set the variations count to 3–4 on the image node. Multiple variations run in parallel and give you options. * Tighten the prompt with specific constraints. *"Centered composition, soft golden-hour light from camera-left, shallow depth of field, terracotta and cream palette"* gives the model fewer degrees of freedom than *"warm aesthetic."* * Use the agent to write the prompt: *"Take this image (the one I like) and write a detailed prompt that would reliably reproduce it."* The agent will generate a much more specific prompt than you'd write yourself, which reduces variance. ## Agent generated something completely off-brief **Most common causes:** vague brief, missing context, or the agent got bored of asking clarifying questions and made assumptions. **Fix:** * Switch the agent from auto-run to ask permission mode. You'll get a chance to inspect and correct the plan before generation kicks off. * In the brief, name the constraints explicitly. Not *"make some ads"* — *"5 static ads, 4x5 aspect ratio, hero product shots in the brand's editorial style, on warm neutral backgrounds, no on-image copy."* * Include reference images. The agent's interpretation of "warm aesthetic" is much sharper when it has two or three example images to anchor against. ## Image or video generation failed or was blocked AI generation can fail for a few different reasons: the provider may block the prompt or reference media, the model may time out, or the result may simply miss the creative direction. ### If a generation is blocked Content-blocked generations usually happen before the model returns usable media. Melius shows the failure on the node so you can adjust and re-run from the same place. A content-policy error identifies a blocked attempt, but the category alone does not identify the exact trigger. Unless the error message names it, the trigger could be the prompt, reference media, or generated output. A request written in German, or any other language, is not by itself evidence of why a generation was blocked. Changing the language or retrying does not guarantee success. **Fix:** * Remove ambiguous language that could look unsafe out of context. * Replace sensitive reference media with a clearer crop or a different source. * Make the prompt more specific about the intended commercial use. * If the blocked node is an image or video node and it is not already using Grok, switch to **Grok Imagine** for images or **Grok Imagine Video** for video and run it again. > [!NOTE] > > Check **Team settings → Usage → Generation history** for the **Refunded** > badge and crossed-out credit amount. A blocked status alone does not confirm > a refund. See [how to check returned > credits](/billing/plans#credits-returned-for-failed-generations) for filters > and what to do if the badge is missing. ### If the result is off-brief Generation models are probabilistic. One run can miss even when the prompt is good. **Fix:** * Run more variations. Set the variation count to 3-4 so the model explores multiple outputs in parallel. * Keep the strongest result, then re-run with a tighter prompt. * Add reference images or a brand anchor if the output is drifting on style. * Ask the agent to rewrite the prompt from a result you like: *"Use this version as the target and write a stricter prompt for three new variations."* ### If auto generation fails When the agent is in auto-run mode, it may create and run several nodes before you inspect the exact model choice. If an image or video generation fails and the node is not already using Grok, try rerunning that node with Grok before rebuilding the whole canvas. For images, pick **Grok Imagine**. For video, pick **Grok Imagine Video**. Keep the same prompt and references for the first retry so you can compare the model behavior directly. If Grok also fails, simplify the prompt or split the request into smaller steps. For example, generate the clean product shot first, then run a second image-to-image or image-to-video step for the more specific scene. ## Video credit cost changes when I connect a clip **This is expected behavior.** A video node's price depends on its mode, and its mode depends on what you connect. On some video models, including Seedance 2.5, connecting a video switches the node from reference-to-video to video-to-video. Video-to-video charges for two things: * **Output seconds**, at a lower per-second rate than reference-to-video. * **Input video seconds**, at the same per-second rate as output. All connected clips count, and the total is rounded up to a whole second. So connecting your first short clip can make the run cheaper, and each clip or extra second of video after that makes it more expensive. The number of reference images doesn't change the price. For example, a 5-second Seedance 2.5 video at 720p, before any team discount: | What's connected | Mode | Credits | | - | - | - | | Reference images only | Reference-to-video | 1,300 (260 × 5s) | | Reference images + a 2-second clip | Video-to-video | 1,092 (156 × 5s + 156 × 2s) | | Reference images + 8 seconds of clips | Video-to-video | 2,028 (156 × (5s + 8s)) | **Audio saved as a video file counts as video.** A voice or music track saved as `.mp4` or `.mov` becomes a video file node, and its seconds are charged as input video. Export it as MP3, WAV, or M4A before uploading so it connects as audio. **Fix:** * Check the credit estimate on the node's run button before you generate. It updates as you connect or remove inputs. * Trim input clips to the part the model needs. Every input second is charged. * If you only need a video for its look, compare the estimate with a still frame connected as a reference image instead. A short clip can still cost less than reference-to-video. ## Forgetting to run a node before connecting downstream A recurring issue with text nodes, especially the Image Style Analysis template. The fix is the same as the first item on this page: text nodes need to be Run before their output is usable. Get in the habit of running every text node immediately after you connect its inputs. ## I want to change one thing in an image without regenerating the whole thing You like the image. You want to remove the text, change one element, swap a color, or clear a region. You don't want to lose the rest. **Two approaches; try the first one first.** **Approach 1: Image-to-image regeneration with a "keep" prompt.** Create a new image-to-image node, drag your existing image in as the reference, and prompt: ``` Recreate this exactly, but [the specific change]. Keep everything else identical. ``` Concrete examples that work: *"Recreate this exactly, but remove all text apart from the @logo."* *"Recreate this exactly, but change the background to a peach gradient."* *"Recreate this exactly, but make the hero product orientation horizontal."* This is usually the cleanest path. The model preserves what you don't mention and re-renders the rest. **Approach 2: Inpaint.** On the image node, open the Inpaint tool. Draw a mask over the area you want to change. In the prompt field, describe what should fill the masked region. Inpaint is improving but isn't always the best tool. If the area you're changing is bordered by complex detail, the seam can show. For "remove all text" or "change the background," the image-to-image route is usually better. Reach for Inpaint when the change is highly localized and the surrounding image needs to stay byte-identical. ## "I have so many canvases and I can't find anything" **Most common cause:** no naming convention, no project structure. **Fix:** * One Melius project per brand / client. Don't mix brands. * One canvas per campaign or workflow. Name it after the campaign — "Spring drop — email banners," not "Untitled." * Archive old canvases into an "Archive" sub-section, or rename them with an "Archive —" prefix. ## Mac feels sluggish on a busy canvas **Most common cause:** too many image nodes at full resolution preview on a single canvas. **Fix:** * Generate exploratory work at 1K resolution. The on-canvas preview is much lighter. * Split very large workflows across multiple canvases in the same project (one canvas per workflow stage, e.g. "Character sheets," "Clip generation," "Stitching"). * The canvas can comfortably hold 50–100 image nodes. Past that, performance starts to dip. Move finished work into a separate "Completed" canvas if your active canvas gets crowded. ## My agent ran out of context / lost track of the canvas **Most common cause:** the agent chat has accumulated a lot of back-and-forth in a single thread. **Fix:** * Start a new chat on the canvas for a fresh task. The agent reads the canvas state regardless — it doesn't need chat history to know what's on the canvas. * You can also tag specific nodes with `@` in a new chat to point the agent at exactly what you want to work on. *"In a new chat: take @hero-shot and generate 5 lifestyle variants."* ## My MCP setup with Claude isn't working **Most common causes:** 1. API key generated from the wrong team. Re-generate from the team you actually want Claude to access. 2. Claude doesn't see the Melius connector. Restart Claude Desktop after adding the connector. 3. Claude returns auth errors. Re-authorize the connector — the API key may not have been saved on the first try. If none of these fix it, drop the issue in the Slack channel with a screenshot of the error. ## Native AI / EPS / PSD file support We don't currently support `.ai` or `.eps` for vector files, or `.psd` for layered editing. Vectors need to be SVG or PNG. We've heard the request and are tracking it — likely on the roadmap, but no firm date yet. In the meantime: export your `.ai` files to SVG (vector) or PNG (raster) for use as references. ## I want a feature that doesn't exist yet Drop it in the Slack channel. Most feature requests from active customers get evaluated within the week, and many ship within days. We've shipped Magic Resize, smart aspect ratios, in-painting, and custom font upload from customer asks. If you've got an idea, we want to hear it. > [!NOTE] > > This page gets updated as new gotchas surface. If you hit something not on > here that took you more than a few minutes to figure out, ping us in Slack — > we'll add it. # Welcome, marketers Source: https://docs.melius.com/help-center/marketers/welcome What Melius does for marketing teams, and how this section is organized. If you make ads, emails, lookbooks, product photography, or campaign assets — Melius is built for the work you do. This section of the Help Center is a working playbook: the recipes our marketing customers use most often, the best practices that come up on every onboarding call, and a few things worth knowing before you start. ## What Melius is for marketers Most creative tools were built for the production step: open a file, pull from a template, render the asset, export. Melius collapses the upstream work — model selection, prompting, variant generation, brand checking — into a single canvas where you brief an agent and steer the output. In practice that means: * **One canvas, every model.** Nano Banana, GPT Image 2, Veo, Seedance, ElevenLabs — all available as nodes on the same canvas. You don't subscribe to each one separately, and you don't need to track which model is currently best at what. * **The agent does the prompting.** Describe what you want; the agent writes the prompts, picks the models, and assembles the workflow. You stay in the seat for taste, not syntax. * **You can steer at any node.** Every prompt the agent writes is visible and editable on the canvas. If the output is 85% there, you don't redo the whole thing — you tweak the one node and re-run. * **Production-ready, on brand, fast.** A campaign that used to take a creative team weeks lands in an afternoon — variants included, brand-checked, sized for every channel. ## How this section is organized > [card] [Get started](/help-center/marketers/mental-model) > > The mental model behind the canvas, and a 10-minute quickstart. > [card] [Set up your brand](/help-center/marketers/brand-anchor) > > Get your fonts, logos, pack shots, and brand voice onto the canvas once, > then reuse them everywhere. > [card] [Recipes](/help-center/marketers/recipes/style-reference) > > Step-by-step workflows for the things marketers do most: static ads, > variants, product shots, UGC video, localization. > [card] [Drive from Claude](/help-center/marketers/mcp) > > Connect Melius to Claude via MCP and let Claude build canvases for you. If you'd rather just open the platform and figure it out as you go, head to [Your first 10 minutes](/help-center/marketers/quickstart). Otherwise we'd start with the [canvas mental model](/help-center/marketers/mental-model) — five minutes of context that makes everything else faster. > [!NOTE] > > Stuck? The fastest path to help is the shared Slack channel we set up during > onboarding. Engineering is in there. Bug fixes typically land same-day. # What is Melius? Source: https://docs.melius.com/index A creative canvas for generating, iterating, and composing AI images and video. Melius is a visual canvas for AI-generated images, video, audio, and text. You arrange **nodes** on an infinite **canvas**, wire them together with **edges**, and run generations across the latest image, video, audio, and language models from one place. Multiplayer is built in — collaborators (and AI agents) show up on the canvas in real time. ## Start here > [card] [Quickstart](/getting-started/quickstart) > > Create your first project, drop a node, and run a generation. > [card] [Core concepts](/getting-started/concepts) > > Projects, canvases, nodes, edges, runs, and versions. > [card] [MCP server](/mcp/overview) > > Connect Claude, ChatGPT, Codex, or another agent to your Melius > workspace. > [card] [CLI](/cli/overview) > > Create canvases and run generations from your terminal with `mel`. > [card] [API reference](/api/overview) > > Drive canvases and generations programmatically with the REST API. ## What you can build > [card] [Canvas](/canvas/nodes) > > Text, image, video, file, and group nodes. Wire them together to compose > multi-step generations. > [card] [Models](/models/overview) > > GPT, Claude, Gemini, Grok, Flux, Stable Diffusion, Seedream, Nano > Banana, Veo, Kling, Seedance, Ray, ElevenLabs, and more. > [card] [Brand kits](/brand-kit/overview) > > Save each brand's logos, colors, fonts, and voice once so Mel stays on > brand in every chat. # ElevenLabs Source: https://docs.melius.com/integrations/elevenlabs Import custom voices into Melius. Connect your ElevenLabs account to import your custom voices into Melius. Once connected, your voices will appear as options in audio nodes across your projects. > [!NOTE] > > Import custom voices from ElevenLabs on the Melius **Creator** plan and > above. [Compare plans](/billing/plans). ## Create an API key **1. Open the ElevenLabs API keys page** Go to [elevenlabs.io/app/api/api-keys](https://elevenlabs.io/app/api/api-keys) and sign in to your ElevenLabs account. **2. Create a new key** Click **Create API Key**. Give it a descriptive name (e.g. "Melius"). **3. Enable Restrict Key** Toggle **Restrict Key** on so you can scope the key to only the permissions Melius needs. **4. Set permissions** Under **Endpoints**, grant **Access** to each of the following: Text to Speech, Speech to Speech, Speech to Text, Sound Effects, Audio Isolation, and Music Generation. Under the resource permissions, set **Voices** to **Read**. This allows Melius to list and use your custom voices. ![ElevenLabs API key endpoint permissions](https://mintcdn.com/melius/dldg38QaqMxvL3Wn/images/elevenlabs-api-key-endpoints.png?fit=max\&auto=format\&n=dldg38QaqMxvL3Wn\&q=85\&s=90131e09492766fff1b0e851114fdc4b) ![ElevenLabs API key Voices permission](https://mintcdn.com/melius/dldg38QaqMxvL3Wn/images/elevenlabs-api-key-voices.png?fit=max\&auto=format\&n=dldg38QaqMxvL3Wn\&q=85\&s=76da337a29b62197e929b0d4a41c8616) **5. Save and copy the key** Click **Save Changes**, then copy the API key. You will not be able to see it again. ## Add the key to Melius **1. Open Settings** In Melius, go to **Settings**. **2. Enter your API key** Paste the ElevenLabs API key into the **ElevenLabs API Key** field and save. Your custom ElevenLabs voices will now appear as options in audio nodes across your projects. # Figma Source: https://docs.melius.com/integrations/figma Browse and search your team's Melius images and videos from Figma and drag them onto the canvas. > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. Melius for Figma is a plugin that opens a Melius panel inside Figma. It shows your team's projects and the images and videos in them. Open a project or search, then drag an asset onto the canvas. There's no need to download a file from Melius and upload it to Figma. > [!NOTE] > > Browse and place your team's Melius assets from Figma on the > **Professional**, **Team**, and **Enterprise** plans. [Compare > plans](/billing/plans). ## Before you start * A Melius team on the **Professional**, **Team**, or **Enterprise** plan. Members of teams on other plans can sign in, but the panel shows **Your plan can't browse assets from Figma**. * Edit access to a Figma Design file, with a Figma seat that can run plugins in it. On Figma's Starter plan, anyone with edit access can. On a paid Figma plan, you need a Full seat. * To place videos, the Figma file must be in a paid Figma team. Figma doesn't let plugins add video to files on its free Starter plan. * An internet connection. The panel loads from Melius each time you run the plugin. The plugin runs in the Figma desktop app and in Figma in the browser. ## Install the plugin **1. Find Melius in the Figma Community** Open the [Figma Community](https://www.figma.com/community) and search for **Melius**. Select the **Melius** plugin. **2. Open it in a file** Click **Open in** and choose a Figma Design file, or create a new one. The plugin opens in that file. **3. Save it for later** Click **Save** on the plugin's Community page. Saved plugins appear under **Saved and recent** when you browse plugins from any Figma Design file. After that, run the plugin from any Figma Design file: search Figma's plugins for **Melius** and click **Run**. Figma's guide to [using plugins in files](https://help.figma.com/hc/en-us/articles/360042532714-Use-plugins-in-files) shows where plugin search is in your version of Figma. If your Figma organization only allows approved plugins, ask a Figma admin to approve Melius. If you run the plugin while you're offline, its window shows **You're offline** and opens Melius as soon as your connection is back. Click **Try again** to check sooner. If Melius doesn't load within 30 seconds, the window shows **Couldn't load Melius** with **Try again**. When the connection drops while the panel is open, the panel shows **You're offline, check your internet connection** until it's back. ## Sign in **1. Click Sign in** In the **Melius** panel, click **Sign in**. Your browser opens, and the panel shows **Finish signing in in your browser**. **2. Choose a team** Sign in to Melius if you're asked to. On **Connect Melius for Figma**, choose the **Team** whose assets you want to use, then click **Authorize**. **3. Return to Figma** When the browser shows **You're signed in**, go back to Figma. The panel shows your team's projects. Finish signing in within five minutes. After that, the panel shows **Sign-in didn't finish, try again**, and you click **Sign in** to start over. **Cancel** in the panel stops waiting and takes you back to **Sign in**. Signing in creates an API key for you in the team you chose, named `melius-figma-…-mcp`. Figma keeps the key on this device, so the panel stays signed in the next time you run the plugin. On another device, sign in again. The panel shows one team at a time. To use another team's assets, sign out, then sign in again and choose that team. ## Find an asset The panel has two tabs, **Projects** and **All assets**. It opens on **Projects** the first time you run it. After that, it reopens on the tab and project you used last. ### Projects **Projects** lists your team's projects, most recently edited first, with a preview of each project's newest images and videos. Scroll down to load more. If your team has no projects yet, the panel shows **No projects yet**. Click **See all assets** to browse every asset instead. Click a project to open it. Inside a project: * **Images** and **Videos** switch which kind of asset you see, newest first. * **Search this project** finds the project's assets by what's in them. Describe what you're after, like "red sneaker". If nothing matches, click **Search all projects** to run the same search across your team. * The canvas menu appears when the project has more than one canvas. Pick a canvas to see only its assets, or **All canvases** to see the whole project. * **Open in Melius** opens the project in your browser. Click the back arrow to return to your projects. The preview on a project in the list can't be placed. Open the project to drag its assets. ### Search projects and assets On the **Projects** tab, type in **Search projects and assets** to search your whole team. The panel shows up to five projects whose name matches, then the matching images or videos from every project. Each asset shows the project it's in, if it's in one. **Images** and **Videos** switch the asset results. Clear the search to return to your projects. ### All assets **All assets** shows your team's images and videos newest first, whichever project they're in. Scroll down to load more. * **Images** and **Videos** switch which kind of asset you see. **Videos** opens on your team's newest videos. * **Search assets** finds assets by what's in them. * The folder menu lists your team's folders when it has any. Pick a folder to see its images or videos, including those in its subfolders. Pick **All folders** to see everything again. With a folder picked, a search looks only in that folder. If your team has no images yet, the panel shows **No images yet**. ## Place an asset on the canvas * **Drag** a tile out of the panel and let go over the canvas. Inside the panel, a copy of the tile follows your pointer. A gray placeholder appears where you let go, and it fills in with the asset once it has downloaded. Let go over a frame to place the asset inside that frame. To cancel a drag, let go over the panel. * **Double-click** a tile, or select it and press **Enter**, to place the asset in the middle of your current view. Each asset becomes a rectangle layer named after the asset, with the image or video as its fill, the same way Figma adds an image you upload. The fill keeps the asset's full resolution. The layer takes the asset's pixel size, scaled down to at most half the width and height of the canvas you can see, and is selected once it's placed. If an asset can't be placed, Figma removes the placeholder and says why, for example **Couldn't place Launch teaser, videos need a file in a paid Figma team**. When the panel can already tell that Figma won't take a video, because it's over 100 MB or isn't an MP4, MOV, or WebM file, it doesn't send it. It shows **Can't place** with the asset's name and the reason instead. ## File formats and sizes Figma lets plugins add PNG, JPEG, and GIF images up to 4096 pixels on each side, and videos up to 100 MB in a paid Figma team. Melius converts images that are outside those limits before they reach Figma. It doesn't convert videos: | Asset in Melius | What lands in Figma | | - | - | | PNG, JPEG, or GIF image up to 4096 px on its longest side | The original file | | Image in another format, such as WebP | A PNG at the same size | | Image larger than 4096 px on its longest side | A PNG scaled down so its longest side is 4096 px, keeping its proportions | | MP4 video up to 100 MB | The original file | | MOV or WebM video up to 100 MB | The original file, if Figma accepts it. Figma's docs list these formats, but Figma can still refuse a video that isn't an MP4, so use MP4 when you can | | Video in another format | Nothing. The panel shows **Can't place** and says Figma takes MP4, MOV, or WebM videos | | Video over 100 MB | Nothing. The panel shows **Can't place** and says Figma takes videos up to 100 MB. Download the video from Melius instead | ## API usage Browsing runs on your API key. Each page of projects, assets, or search results, and each project, folder list, and account check the panel loads, counts toward your team's monthly API calls, like any other API key. Downloading an asset to place it doesn't count. ## Disconnect In the panel, click your picture or initial at the top right. The menu shows the email you signed in with. Click **Sign out**. Melius revokes the plugin's API key, then Figma removes it from this device. The key stops working straight away, and it leaves your API keys list. Signing out waits up to 3 seconds for Melius. If it can't reach Melius in that time, for example because you're offline, the panel still signs you out, but the key keeps working. To remove it, revoke it in Melius: 1. In Melius, switch to the team you chose when you signed in. 2. Open **Team settings → Integrations**. 3. Under **API keys**, find the key named `melius-figma-…-mcp`. 4. Open its **...** menu, click **Revoke key**, then click **Revoke key** again to confirm. Revoking a key there also signs out any panel that still holds it. The panel returns to **Sign in** the next time it loads assets. ## Known limits * The plugin browses and places assets only. You can't generate from Figma, or send Figma layers to Melius. * The plugin runs in Figma Design files only, not in FigJam, Figma Slides, Figma Buzz, or Dev Mode. * Placing videos needs a file in a paid Figma team, and each video must be 100 MB or smaller. MP4 works best. * The plugin needs an internet connection. * The panel shows one team at a time. ## Troubleshooting | What you see | What to do | | - | - | | **Melius for Figma isn't available yet** in your browser | Melius for Figma is in beta and isn't turned on for your account. Reach out to support if you'd like access. | | **Your plan can't browse assets from Figma** | Your team's plan is below Professional. A team owner or admin can upgrade in **Team settings → Plans & billing**. [Compare plans](/billing/plans). | | **Sign-in didn't finish** in the panel or the browser | Sign-in took longer than five minutes, or didn't complete in the browser. Click **Sign in** in the panel and finish in the browser window that opens. | | **Couldn't place** or **Can't place** followed by an asset's name | The rest of the message says why. Videos need a file in a paid Figma team, must be 100 MB or smaller, and work best as MP4. If it says **Couldn't load** the asset from Melius, check your connection and try again. | | **You're offline** or **Couldn't load Melius** in the plugin window | Check your internet connection. Melius opens once you're back online, or click **Try again**. | | **Couldn't load assets**, **Couldn't load projects**, or **Couldn't load this project** | Click **Try again**. | | The panel goes back to your projects when you open one | The project was deleted, or you no longer have access to it. | | The panel shows **Sign in** again | Your key was revoked. Sign in again. | Still stuck? Reach out to support with the asset's name and the time you tried to place it. # Slack Source: https://docs.melius.com/integrations/slack Use Mel, the Melius Slack bot, to generate from any channel. Connect your Slack workspace to Melius to bring **Mel**, the Melius Slack bot, into your team's channels. Mention Mel in any channel to start generating images, video, audio, and text — the results land on a Melius canvas you can open from the thread. ## Install the bot To install Mel in your Slack workspace, you need to be: * A **team owner or admin** on Melius, and * A **Slack workspace admin** (or have permission from your Slack admin to install apps). **1. Open Settings in Melius** In Melius, go to **Settings** and find the **Slack** integration. **2. Connect your workspace** Click **Connect Slack**. You'll be redirected to Slack's authorization screen. **3. Authorize Mel** Review the requested permissions and click **Allow**. You'll be returned to Melius with the workspace connected. > [!NOTE] > > Each Melius team can be connected to one Slack workspace. Anyone in that > Slack workspace who also has a Melius account on the connected team can use > Mel. ## Use Mel in Slack ### Start a new thread Mention `@Mel` in any channel where the bot is present, along with your prompt: ``` @Mel make me a product shot of our new sneaker on a marble background ``` Mel replies in a thread under your message and begins generating. When the result is ready, Mel posts it in the thread along with an **Open canvas** button that takes you straight to the Melius canvas where the work lives. > [!NOTE] > > Mel needs a prompt with the mention. A bare `@Mel` with no instruction will > be rejected. ### Continue mid-thread You can pull Mel into any existing Slack thread by `@Mel`-mentioning it. Mel will pick up the conversation from there — replies, follow-ups, and new instructions all stay scoped to that thread. Within a thread you can: * Ask follow-ups in plain language ("make it warmer", "try a vertical version"). * Drop in images or files as references — Mel ingests attachments. * Answer Mel's clarification prompts using the inline buttons it posts. ## How threads map to canvases Each Slack thread corresponds to exactly **one Melius canvas**. * A new `@Mel` mention always starts a **new Slack thread**. The thread can be tied to a new canvas or to an existing project or canvas. * **Follow-up** mentions in the same thread keep adding to the same canvas, so iteration stays in one place. Mel posts an **Open canvas** link in the thread so anyone with access can jump from Slack to the full canvas view in Melius, where they can keep editing, branching, or sharing the result. > [!NOTE] > > To use Mel from Slack, you need a Melius account on the connected team with > edit access to the canvas. Viewers can browse generated results in Slack but > can't trigger new generations. # Vibe Source: https://docs.melius.com/integrations/vibe Export videos from Melius to Vibe as streaming TV ads. [Vibe](https://www.vibe.co) is a self-serve platform for buying ads on streaming TV. Connect your team's Vibe account to Melius, then export any video from **Assets**, a canvas, **Cast**, **Playground**, or **Explore** straight into an advertiser's creative library in Vibe. ## Before you start * A **Vibe account** with at least one advertiser. * A **team owner or admin** on Melius to connect Vibe. Each Melius team connects one Vibe account. * **Editors, admins, and owners** can export videos once Vibe is connected. Viewers can't. ## Connect Vibe You can start from Melius or from Vibe's Marketplace. Either way, you approve access on Vibe's consent screen. > [tab] From Melius > > **1. Open Integrations** > > In Melius, open **Settings** and select **Integrations**. > > **2. Connect** > > On the **Vibe** card, click **Connect**. A Vibe window opens. > > **3. Approve access** > > Sign in to Vibe if asked, choose which advertisers Melius can > export to, and approve. The window closes and the card shows who > connected it. > [tab] From Vibe > > **1. Install Melius** > > In Vibe's Marketplace, open **Melius** and click **Install**. > > **2. Sign in to Melius** > > Sign in to the Melius team you want to connect. You need to be > an owner or admin of that team. > > **3. Approve access** > > Choose which advertisers Melius can export to, and approve. > You're returned to Melius with Vibe connected. Melius asks Vibe for three permissions: read your advertisers, read creatives, and upload creatives. It can't create, change, or launch campaigns. ## Export a video **1. Open Share on the video** Click **Share** on a video wherever you see it: - **Assets**: the **...** menu or right-click menu (hover **Share**), or the fullscreen viewer. - **Canvas**: **Share asset** on a video node's toolbar, in its right-click menu, or in the fullscreen viewer. - **Cast**, **Playground**, and **Explore** history: the **Share** button on a finished video. **2. Choose Export to Vibe** Select **Export to Vibe**. Melius checks the video against Vibe's requirements first. If it misses any, the dialog lists what to fix. **3. Pick an advertiser and name** Choose the **Advertiser** and edit **Name in Vibe** if you like (up to 150 characters). **4. Export** Click **Export**. You can close the dialog while it uploads; Melius lets you know when it's done. ### Export several videos at once In **Assets**, select the videos, then click **Share** → **Export N videos to Vibe** on the selection bar, or in the **...** or right-click menu of any selected file. Pick the advertiser once and click **Export**. Each video goes in under its own name. Files that aren't videos are skipped, and you can export up to 25 videos at a time. A notification shows the export while it runs, then tells you which videos made it and why any didn't. The video lands in the advertiser's creative library in Vibe as **Pending review**. Vibe scans every new creative within 30 minutes; once it's **Approved**, you can add it to a campaign. ## Video requirements Vibe accepts videos that meet all of these: | Requirement | Value | | - | - | | Format | MP4 | | Aspect ratio | 16:9 (landscape) | | Resolution | At least 1280×720; 1920×1080 recommended | | Length | 5 to 90 seconds | | File size | 100 MB or less | | Frame rate | Constant 23.976, 24, 25, 29.97, or 30 fps | | Bitrate | At least 2,500 kbps | Melius fixes what it can as it exports. If a video is slightly off 16:9, like the 1344×768 some video models produce, Melius exports it at 1920×1080 with thin black bars, so it's exactly 16:9. If the format, frame rate, bitrate, or file size is outside Vibe's specs, Melius re-encodes the video to fit. Melius can't fix a video that is far from 16:9 (such as vertical or square), smaller than 1280×720, or outside 5 to 90 seconds. The **Export to Vibe** dialog lists anything like this before you export. ## Disconnect Vibe Owners and admins can open **Settings** → **Integrations** and click **Disconnect** on the **Vibe** card. Members can no longer export videos to Vibe after you disconnect. To fully remove access, also remove Melius from the apps installed on your Vibe account. ## Troubleshooting | What you see | What to do | | - | - | | **Export to Vibe** is greyed out | Vibe takes videos only, so it's greyed out on images, audio, and PDFs. On a video, viewers can't export: ask a team admin to change your role to editor. | | "Vibe isn't connected to this team" | A team owner or admin needs to [connect Vibe](#connect-vibe). | | "The Vibe connection expired" | Connections expire if Vibe access is revoked or unused for 90 days. A team owner or admin clicks **Reconnect** on the **Vibe** card in **Settings** → **Integrations**. | | The advertiser you want isn't in the list | Melius only sees the advertisers you approved when connecting. Reconnect Vibe and include that advertiser. | | "This video doesn't meet Vibe's requirements" | The video's shape, resolution, or length can't be fixed automatically. Generate or export a 16:9 version at 720p or higher, 5 to 90 seconds long, and export that. | | "Vibe rejected it" | Vibe's review rejected the video. Open the advertiser's creative library in Vibe to see why. | | The Vibe window doesn't open | Your browser blocked the pop-up. Allow pop-ups for Melius and click **Connect** again. | | "Vibe isn't responding right now" | Vibe is temporarily unavailable. Try again in a few minutes. | Still stuck? Reach out to support with the video's name and the time you exported it. # MCP server Source: https://docs.melius.com/mcp/overview Connect Claude, ChatGPT, Codex, Grok Bot, or another agent to your Melius projects, canvases, and creatives. The Melius MCP server lets an AI agent (Claude, ChatGPT, Codex, Grok Bot, or any MCP-compatible client) read and write to your projects: create canvases, drop nodes, wire edges, run generations, upload files, and download outputs — all without leaving the agent chat. ## Connection options | Connection | Endpoint | Auth | When to use | | - | - | - | - | | **Melius connector** (recommended) | `https://mcp.melius.com/mcp` | Sign in with Melius | Sign in and authorize access — no API key to create or paste. | | Remote HTTP | `https://api.melius.com/mcp` | API key | Clients with no OAuth flow, and headless setups (CI, servers). | | Local stdio | `mel-mcp --hosted` | API key | Stdio-only clients, including Cast, through your configured backend. | All three use the hosted MCP tool catalog. The older direct REST mode (`mel-mcp` without `--hosted`) supports canvas tools and local file uploads, but does not support Cast. > [tab] Connect via Claude (recommended) > > The Melius connector signs you in with your Melius account — no API key to paste. Use this for Claude.ai, Claude Desktop, and Claude Code. > > ### Connect Claude on web or desktop > > **1. Connect Claude** > > Click [Connect Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Melius\&connectorUrl=https%3A%2F%2Fmcp.melius.com%2Fmcp). Sign in to Claude if prompted, then confirm the custom connector with **Melius** and `https://mcp.melius.com/mcp` already filled in. > > **2. Sign in with Melius** > > Claude opens a Melius login page in your browser. Sign in (or use your existing session), pick the team you want Claude to work in, and click **Authorize**. Melius creates a connector key for Claude on your behalf — you don't need to create or paste anything. Claude is connected immediately. > > **3. Set tool permissions** > > Go to **Tool Permissions** and select **Always Allow** for everything. > > **4. Check the connection** > > Open a chat and ask for something that needs Melius, such as "Using the Melius MCP, list my Melius projects." If Claude answers without Melius tools, reopen **Connectors** and confirm the server URL. > > ### Claude Code > > **1. Add the connector** > > ```bash theme={null} > claude mcp add melius --transport http https://mcp.melius.com/mcp --scope user > ``` > > **2. Authenticate** > > Run `claude`, type `/mcp`, select **melius**, and follow the browser prompt. Sign in to Melius and pick a team. > > ### Disconnect > > The connector key Melius created during authorize is listed in **Team settings → Integrations** under your API keys, named `claude-…-mcp`. To remove Claude's access at any time, delete that row. Claude loses access immediately. > [tab] Connect ChatGPT & Codex > > ChatGPT connects through the official Melius plugin. Codex CLI and the Codex IDE extension use a separate MCP configuration. > > These clients use the same Melius connector as Claude: you sign in with your Melius account and there is no API key to paste. > > ### ChatGPT on web or desktop > > **1. Connect ChatGPT** > > Open the [official Melius plugin](https://chatgpt.com/plugins/plugin_asdk_app_6abedd3381b88191a27be5cca3c066bc). Sign in to ChatGPT if prompted and click **Connect**. No custom server setup is needed. > > **2. Sign in with Melius** > > Melius opens a login page in your browser. Sign in (or use your existing session), pick the team you want the agent to work in, and click **Authorize**. Melius creates a connector key on your behalf — you don't need to create or paste anything. > > **3. Check the connection** > > Open a chat and ask for something that needs Melius, such as "Using the Melius MCP, list my Melius projects." If ChatGPT answers without Melius tools, reopen the Melius plugin and confirm it is connected and enabled in your chat. > > ### Codex CLI > > `codex mcp add` only registers local stdio servers, so add the remote Melius server to `~/.codex/config.toml` yourself: > > ```toml theme={null} > [mcp_servers.melius] > url = "https://mcp.melius.com/mcp" > ``` > > Then sign in: > > ```bash theme={null} > codex mcp login melius > ``` > > Codex opens the Melius authorize page in your browser. Pick a team, click **Authorize**, and Codex stores the credential. Run `codex mcp list` to confirm, or type `/mcp` in the Codex TUI. > > To scope Melius to a single repo instead of your whole machine, put the same block in that project's `.codex/config.toml`. > > Codex asks before each tool call by default. To let it run Melius tools without prompting — the equivalent of Claude's **Always Allow** — add `default_tools_approval_mode` to the same block: > > ```toml theme={null} > [mcp_servers.melius] > url = "https://mcp.melius.com/mcp" > default_tools_approval_mode = "auto" > ``` > > ### Codex IDE extension > > **1. Open MCP servers** > > Open the gear menu and select **MCP servers → Add server**. > > **2. Fill in the server** > > Name it **Melius**, choose **Streamable HTTP**, and paste `https://mcp.melius.com/mcp`. > > **3. Restart and authenticate** > > Save the server and select **Restart extension**, then select **Authenticate** to sign in with Melius. > > ### Headless setups > > Where a browser sign-in isn't possible (CI, a remote box, a container), skip OAuth and pass an API key from **Team settings → Integrations** as a bearer token: > > ```toml theme={null} > [mcp_servers.melius] > url = "https://api.melius.com/mcp" > bearer_token_env_var = "MEL_API_KEY" > ``` > > Codex reads the key from the `MEL_API_KEY` environment variable, so the key itself never lands in the config file. > > ### Disconnect > > The connector key Melius created during authorize is listed in **Team settings → Integrations** under your API keys, named after the client that connected (`codex-…-mcp`). Delete that row to revoke access immediately. > [tab] Connect another client > > Any client that can add a remote MCP server over Streamable HTTP, such as Notion or Cursor, connects through the same Melius connector. You sign in with your Melius account and there is no API key to paste. > > **1. Add a custom server** > > Open your client's MCP or connector settings and add a custom server. > > **2. Name the server** > > Set the name to **Melius**. If the client asks for a transport type, choose **Streamable HTTP**. > > **3. Paste the URL** > > ``` > https://mcp.melius.com/mcp > ``` > > **4. Sign in with Melius** > > Melius opens a login page in your browser. Sign in (or use your existing session), pick the team you want the agent to work in, and click **Authorize**. Melius creates a connector key on your behalf — you don't need to create or paste anything. > > If your client can't sign in to an MCP server, use an API key instead. See the **Connect with an API key** tab. > > ### Grok Bot > > Grok Bot adds MCP servers from a chat message. > > **1. Ask Grok Bot to add Melius** > > Send this message in a Grok Bot chat, then approve the confirmation card: > > ``` > Add a custom MCP server called melius at https://mcp.melius.com/mcp/grok-bot-plugin > ``` > > **2. Sign in with Melius** > > Click **Authenticate** on the Melius card. Sign in to Melius in your browser, pick the team you want Grok Bot to work in, and click **Authorize**. > > ### Disconnect > > The connector key Melius created during authorize is listed in **Team settings → Integrations** under your API keys, named after the client that connected (for example `notion-…-mcp`). Grok Bot signs in as Cursor, so its key is named `cursor-…-mcp`. Delete that row to revoke access immediately. > [tab] Connect with an API key > > ### API Keys > > Generate an API key from **Team settings → Integrations** in the Melius app. Each key: > > * Is shown once at creation time — copy it before closing the modal. > * Can be named (`Claude`, `prod-bot`, etc.). > * Is scoped to a single team. > * Can be given an expiry or marked `no expiry`. > * Can be revoked at any time from the same settings page. > > ### Connect Claude Desktop > > **1. Open Claude** > > Go to **Customize → Connectors → Add (+) → Custom**. > > **2. Name your connector** > > Set the name to **Melius**. > > **3. Paste the endpoint** > > ``` > https://api.melius.com/mcp > ``` > > **4. Paste your API key** > > Use a key from **Team settings → Integrations**. Save the connection. > > **5. Set tool permissions** > > Go to **Tool Permissions** and select **Always Allow** for everything. > > ### Claude Code > > **1. Add the connector** > > ```bash theme={null} > claude mcp add melius --transport http https://api.melius.com/mcp --scope user > ``` > > **2. Authenticate** > > Run `claude`, type `/mcp`, select **melius**, and follow the browser prompt. > > ### Local stdio (`mel-mcp`) > > `mel-mcp` ships with the Melius CLI. Configure your MCP client to run the binary with the right env: > > ```bash theme={null} > MEL_API_KEY=mel_... # required > MEL_BASE_URL=https://api.melius.com # optional; override for self-hosted > mel-mcp --hosted > ``` > > If `MEL_API_KEY` isn't set, `mel-mcp` falls back to `~/.mel/config.json` (the file `mel auth login` writes). `MEL_BASE_URL` defaults to `https://api.melius.com`. With `--hosted`, the binary forwards to that backend's `/mcp` endpoint, which must be running. Attachment uploads use your client's file-transfer support. > > Example Claude Desktop `claude_desktop_config.json`: > > ```json theme={null} > { > "mcpServers": { > "melius": { > "command": "mel-mcp", > "args": ["--hosted"], > "env": { > "MEL_API_KEY": "mel_..." > } > } > } > } > ``` ## Verify the connection In a new chat, send: > "Create a new project called Hello World in Melius" If the agent calls `project_create` and reports a new project ID, you're connected. ## Output counts and credits Melius instructs connected agents to generate one output per requested item unless you ask for alternatives or ask to keep an existing batch size. Each additional output uses credits. For example, “make three versions of this video” requests three paid outputs. Agents choose the count they send to Melius. To make your intent explicit, say “generate exactly one version of each item.” A saved batch size can carry over when an agent omits the count. ## Uploading images, videos, and audio In ChatGPT, attach the image or video to your message. The agent adds it to the canvas with [`attachments_to_canvas`](/mcp/tools#files), so there is nothing to set up. In clients that can read and transfer local files, you can upload images, MP4 or MOV videos, and WAV or MP3 audio: 1. Create a file node with [`node_create`](/mcp/tools#nodes). Set `mediaType` to `image`, `video`, or `audio` to match the file. 2. Call [`file_upload`](/mcp/tools#files) with the file path, node ID, and canvas ID. If the result is `complete`, the file is ready. 3. If the result is `pending_curl`, the agent runs the provided transfer command, then calls [`file_upload_complete`](/mcp/tools#files) with the returned metadata, ETag, and file size. Upload WAV and MP3 files directly as audio to use them with Scribe, voice isolation, or Seedance audio inputs. Wrapping a song in an MP4 makes it a video asset, which audio-only tools cannot use. In a sandboxed Claude environment, the sandbox must allow network egress to `*.melius.com`: **1. Open Organization Settings** Go to **Organization Settings → Capabilities → Code execution**. **2. Enable code execution and egress** Turn on **Cloud code execution and file creation** and **Allow network egress**. \**3. Allowlist *.melius.com** Add this exactly to the network egress allowlist: ``` *.melius.com ``` **`file_upload` takes images, MP4 or MOV videos, and WAV or MP3 audio.** For PDFs and other audio formats, drop the file onto the canvas in the Melius app; agents can then use that file node. ## Inline canvas previews Claude and ChatGPT show an interactive canvas preview inline in the chat via [`display_canvas`](/mcp/tools#display). Each preview shows when its content was checked and identifies generations that were still queued or running. In other clients, the agent shares a link to the canvas along with the capture time and generation status. In clients that support interactive MCP Apps, click **Refresh** to fetch the latest canvas content and generation status. Each refresh counts toward your MCP call limit. Refresh keeps your zoom, canvas position, and playback on unchanged nodes. If a refresh fails or a replacement preview is cancelled, the previous canvas stays available so you can try again or choose **Open in Melius**. A generation that finishes while the card stays open appears on the next refresh. For a finished deliverable, your agent can wait for the relevant generations and show a new preview. Saved standalone HTML shows the content from its capture; request another preview to update it. ## Troubleshooting ### Melius tools aren't showing up If your agent reports **"Melius tools aren't available through the connected MCP servers"** or in Claude connectors you see **"This connector has no tools available,"** the client connected before the tool list finished loading. Refresh the tools list to fix it. **1. Open the connector menu** Click the triple-dot (**⋯**) menu on the Melius connector in Claude. **2. Refresh the tools list** Select **Refresh** to reload the tools list. The Melius tools appear once the refresh completes. ![Refresh the tools list from the connector's triple-dot menu](https://mintcdn.com/melius/cH1oNUe2ZIqtntYT/images/MCP-troubleshoot.png?fit=max\&auto=format\&n=cH1oNUe2ZIqtntYT\&q=85\&s=135384beb3e3473a7108acef90df7911) There is no equivalent refresh in ChatGPT desktop or Codex — restart the client instead. In ChatGPT desktop, quit and reopen the app; in the Codex IDE extension, select **Restart extension**; for the Codex CLI, quit and relaunch `codex`. If the tools still don't appear, confirm your endpoint and credentials are correct (see [Connection options](#connection-options)) and that your connection in Melius hasn't been revoked. ### Codex can't sign in `codex mcp login melius` completes the sign-in in a browser on the same machine. On a remote box or in a container, use an API key as a bearer token instead — see **Headless setups** in the ChatGPT & Codex tab above. ## Full tool reference See [Tool reference](/mcp/tools) for every tool and what it does. ## Data and permissions The Melius MCP server reads from and writes to your Melius account. Specifically: * **Reads** your projects, canvases, nodes, edges, runs, comments, presets, teams, and models you have access to. * **Writes** new projects, canvases, nodes, edges, runs, uploads, comments, and team skills you ask it to create. * **Deletes** projects, canvases, nodes, and edges you ask it to delete. * **Generates** images, video, audio, and text on the canvas via Melius's existing third-party model providers. All generation is initiated by explicit tool calls. * **Does not** read your chat history, conversation summaries, agent memory, or files outside the canvas. The server only operates on data the agent provides through tool calls and the canvases it explicitly opens. The connector is scoped to the single Melius team you pick during authorize. ## External links and origins The `display_canvas` MCP App opens links to your Melius canvas via `ui/open-link`. The only origin it opens is the Melius web app: ``` https://app.melius.com/projects/*/canvas/* ``` ## Tested surfaces The Melius MCP server is tested with **Claude.ai**, **Claude Desktop**, and **Claude Code**. The **ChatGPT desktop app**, the **Codex CLI**, and the **Codex IDE extension** connect over the same Streamable HTTP and OAuth flow. Other MCP-compatible clients work as long as they speak Streamable HTTP MCP. ## Cast Connect to the hosted Melius MCP server and describe the video you want. Name an existing avatar—“make a UGC video of Loopy talking about chemistry class”—to use it directly without a picker. If you haven’t chosen an avatar, browse the library or create four candidates and select your favorite. Your agent writes the script in chat and infers the generation settings from your request. Confirm your avatar in the inline picker. It collapses to a card showing the avatar you selected. If your client puts the selection message in the chat box, press **Send** to continue. Your agent uses that choice before preparing the script; it does not pick a different avatar while waiting. Generation uses your client’s native MCP tool approval. With auto-approve enabled, an explicit request such as “make 10 videos using Loopy” runs without extra Generate clicks. Draft-only requests stop at the script. The agent waits for each requested video and shows its finished result with **Download video**. Each finished video comes with its Cast link, shared the way **Share** in Cast shares it: anyone you send the link to can watch the video. The default is **Seedance 2.5**, your avatar's saved voice and portrait video. You can override supported settings in chat, such as “make it horizontal, 1080p, with subtitles and a warm tone.” Explicit model, resolution, aspect ratio, subtitles, tone and voice requests take priority; the agent infers the remaining settings. Voice, background, prop and template pickers appear only when you ask for them. Otherwise, the agent uses your brief, your avatar's saved voice, an automatic scene, and any supplied selections or attachments. MCP Apps clients show avatar choices and the finished video with **Download video** inline. Other clients receive numbered choices and media links. Attachments require file access and transfer support in your client. See [Cast tools](/mcp/tools#cast). ### Batches Ask explicitly for Cast, for example: “Create 10 Cast videos using Loopy, each visiting a different European city.” Your agent prepares one review with all scripts, settings and the total estimated credits. Native MCP permission approves the batch, including your client's automatic approval setting. One batch card shows every video, ready/failed/pending counts, individual downloads and **View all in Cast**. If the server connection is interrupted, the card reports that current status is unknown and retries. It never generates replacements. Batches support up to 20 videos per request and retain normal credit and queue limits. Accepted videos keep running after a disconnect; unsubmitted items are reported separately. # MCP tool reference Source: https://docs.melius.com/mcp/tools Every tool exposed by the Melius MCP server. The Melius MCP server exposes the tools below. The agent picks the right ones based on your prompt — you don't have to call them directly. Tools are grouped below by category. ## Guide | Tool | Purpose | | - | - | | `get_guide` | **Mandatory first call.** Returns the agent's working context for the current task. | | `get_docs` | Fetch Melius documentation pages by topic. | ## Teams & Projects | Tool | Purpose | | - | - | | `team_list` | List teams your API key has access to. | | `project_list` | List projects in a team. | | `project_get` | Get a project by ID. | | `project_create` | Create a new project with an empty canvas. | `project_list` accepts an integer `limit` from 1 to 100 (default 50) and a nonnegative integer `offset` (default 0). To read the next page, increase `offset` by the number of results returned. When a request is invalid, the error names the field and the value or format it expects. ## Canvas | Tool | Purpose | | - | - | | `canvas_list` | List canvases in a project. | | `canvas_get` | Get canvas metadata. | | `canvas_content` | Read canvas nodes and edges, inspect one node, or find named references. | | `canvas_create` | Create a new canvas and return its link, which the agent shares with you. | | `canvas_delete` | Delete a canvas and everything on it. | | `canvas_plan_layout` | Compute positions for new nodes that don't overlap existing content. **Call before `bulk_create_nodes`.** | `canvas_list` accepts an integer `limit` from 1 to 100 (default 50) and a nonnegative integer `offset` (default 0). To read the next page, increase `offset` by the number of results returned. When a request is invalid, the error names the field and the value or format it expects. To read a large canvas quickly, pass `detail: "compact"` to `canvas_content`. Each node comes back as one small record: its ID, type, title, group, model settings, prompt and generated text, and the active output's `versionId`, `assetId`, media type, size and summary. Edges and notes keep their IDs and wiring. URLs, positions, timestamps and version history are left out, and text longer than 280 characters is cut and marked with `<field>Truncated: true`. Read a node with `nodeId` and `detail: "full"` (the default) when you need its whole prompt or its media URLs. To find a character or product reference by name, pass `canvasId` and `nodeQuery` to `canvas_content`. It searches node titles across the canvas and returns up to 10 compact candidates in `nodeLookup`. In this mode, `nodes` and `edges` are empty; they do not describe the full canvas. Use the returned `nextOffset` as `nodeOffset` for more candidates, or read a candidate with `nodeId` to inspect its current asset and version. Do not combine `nodeQuery` with `nodeId` or `includeAllVersions`. > [!NOTE] > > **Beta** — run input records are rolling out gradually. Reach out to support > if you'd like access. With `nodeId` and `includeAllVersions`, each version carries `producedBy`: the run that wrote it and the sources that run sent to the model (`inputs`), each with the source node, version, asset, its label at run time, its role (`image`, `end_image`, `reference_image`, `video`, `audio` or `text`) and its position. The record is written when the run starts and does not change when a source is later renamed, rewired, rerun or deleted, so it is the record to name or trace an output by. `producedBy: null` is a version no run wrote (an upload); `inputs: null` is a run from before inputs were recorded. Tool runs record the version they processed the same way. An upscale, background removal, crop, trim, GIF, voice change, subtitles, frame extraction, layer split or Magic Resize run has one input: the source node, the exact version it read and the asset it processed. `run_get` returns it in `inputs`, and the version the tool wrote names it in `producedBy`, so you can tell which version an upscale came from even after the source node gets a newer version. ## Nodes | Tool | Purpose | | - | - | | `node_create` | Create a node (text, image, video, file, custom\_text, or group). | | `node_update` | Update a node's prompt, model, or settings. Pass `detail: "compact"` to get back only `{ id, title }`. | | `node_set_text` | Set the literal text content of a `custom_text` node. | | `node_set_version` | Select a specific generation version on a node. | | `node_delete` | Delete a node. | | `bulk_delete_node` | Delete multiple nodes in one batch. Requires user confirmation. | | `bulk_create_nodes` | Create multiple nodes — and optionally edges — in one call. | | `bulk_update_nodes` | Update up to 200 nodes in one call, with `node_update`'s fields. | For image shapes, node creation, editing, layout, and run tools accept the shared ratio list, including `4:5` and `5:4`. Each model supports its own subset. For image quality, check the variant's `qualityOptions` in `model_list`, then set `modelConfig.quality` to the requested option ID on `node_create`, `node_update`, `bulk_create_nodes`, or `run_start`. For example, use `"max"` when that variant lists Max. Quality affects the credit price. Omitting quality from an explicit model selection uses the variant's `defaultQuality`. To switch an existing node back to Auto, use `node_update` with `modelConfig: null`. Omitting `modelConfig` preserves its current choice. Only clear a configured model when you want Auto to choose the model. ### Replace a shot in a stitch | Tool | Purpose | | - | - | | `stitch_get` | Read a stitch's saved edit, its revision and each shot's list index or clip ID. | | `stitch_clip_replace` | Replace one shot, keeping its duration and every other shot, effect and audio. | Pass the revision from `stitch_get` and exactly one shot to `stitch_clip_replace`. The new take must be the same media kind and cover the shot's duration; it plays from its start. The previous edit is kept as a connected stitch copy, and `onDuplicate` edits a copy instead of the original. If the stitch changed since `stitch_get`, the call is refused; read it again. The edit is saved but not rendered: run the returned `nodeId` to render it. ### Video audio control Check `model_list` for a video variant with `supportsAudioToggle: true`. With that model explicitly selected, set `generateAudio: false` on `node_create`, `node_update`, or each video in `bulk_create_nodes` to generate without audio. Set it to `true` to enable audio again. The setting is saved on the node and reused by single and bulk runs. Omit it on updates to preserve the current setting. Auto model mode ignores saved audio overrides. For a single generation, `run_start` also accepts a boolean `generateAudio` override. When running the saved node model, omit it to inherit the saved setting or model default. When overriding the model for a run, pass `generateAudio` explicitly. This controls new generations; it does not remove audio from an existing video. To mute source clips in a stitch while retaining narration overlays, use `node_update.muteSourceAudio: true` instead. ## Groups | Tool | Purpose | | - | - | | `node_group` | Group a set of nodes into a container. | | `node_ungroup` | Dissolve a group and release its children. | To color a group, pass `groupColor` to `node_group`, or to `node_update` for an existing group: `default`, `amber`, `blue`, `purple`, `olive`, `red`, `pink`, `green` or `yellow`. On `node_update`, `null` resets it. When the nodes you pass to `node_group` are part of one group, the new group is created inside it. Groups nest up to three levels deep. To take one node out of its group, call `node_update` with `groupId: null`. The node keeps its place on the canvas unless you also pass `geometry`. ## Edges | Tool | Purpose | | - | - | | `edge_create` | Connect two nodes with an edge. | | `bulk_create_edges` | Create multiple edges in one call. | | `edge_delete` | Remove an edge. | ## Runs | Tool | Purpose | | - | - | | `run_start` | Start an AI generation on a single node. Pass `postProcess: "video-gif"` on a video node to convert the finished clip to a GIF in place. | | `run_get` | Get the status and result of a run, with `inputs` (the sources it sent to the model) and `outputVersionIds`. | | `run_wait` | Wait for a single run to finish, fail, or be cancelled. | | `run_latest` | Get the most recent run for every node on a canvas. | | `bulk_run_start` | Start runs on multiple nodes at once. Pass `postProcess: "video-gif"` to convert the run's final video to a GIF in place. | | `bulk_run_get` | Get the status of a bulk run. Pass `includeInputs: true` to attach every entry's `inputs` and `outputVersionIds` in one call. | | `bulk_run_wait` | Wait for a bulk run to finish. | Hosted `run_wait` and `bulk_run_wait` calls use a wait window of at most 120 seconds, even when you request a longer timeout. A status request already in progress can take additional time to return. If generation is still running, the response includes `waitTimedOut: true`. Call the same wait tool again with the same run ID to continue waiting; generation continues on the server. Starting another run would create and charge for another generation. A failed run reports why in `errorReason`: on the run from `run_get` and `run_wait`, and on each failed entry from `bulk_run_get` and `bulk_run_wait`. `content_policy` means the model provider's moderation refused the prompt or the output. The other values are `insufficient_credits`, `no_media_generated`, `provider_error`, `validation_error`, `timeout`, `system` and `unknown`. ## Node tools Node tools post-process a node that already has a finished asset. They also work on file nodes that hold an uploaded image or video. Each returns a run ID — call `run_wait` to block until it finishes, and the finished run activates the new version automatically. | Tool | Purpose | | - | - | | `run_video_subtitles` | Add subtitles to the selected finished video on a video, file, or stitch node in a chosen style preset. Stitch inputs must be complete and current. | | `run_video_background_removal` | Remove the background from a video, producing a transparent WebM by default. | | `run_video_gif` | Convert a video of up to 30 seconds into a GIF, which replaces the node's video output. A GIF request with no video generates a short clip first. | | `run_image_background_removal` | Remove the background from an image, producing a transparent PNG. | | `run_image_upscale` | Upscale an image with Topaz, 1–4×, with the same model, face enhancement and format options as the canvas. | | `run_magic_resize` | Resize an image into several aspect ratios at once. Creates and runs a magic resize node beside the source. | For stitched videos, ask Mel or your MCP agent to add subtitles after the final stitch. The subtitled output becomes a new version on the same node. Re-stitching creates a fresh output that needs subtitles applied again; your captioned version remains available in version history. Before captioning a stitch, every included clip and audio overlay must finish generating, and the rendered stitch must use their currently selected versions. If an input or the edit changes—including clip timing, trims, text overlays, or audio settings—render the stitch again first. Older stitches without recorded inputs and edit settings also need one new render. If you explicitly want captions on an existing partial or outdated preview, ask your agent to use `allowPartialStitch: true`. This option captions only that existing video; it does not add missing clips. ## Downloads | Tool | Purpose | | - | - | | `run_download` | Download outputs from a single run. | | `bulk_run_download` | Download outputs from a bulk run. | | `creative_download` | Download all creatives from a canvas as a ZIP. | | `output_list` | List the finished outputs of a project, canvas or group, one compact row per node. | Each ZIP from these tools has a `manifest.json` at its root. It lists every file in the ZIP (`file`) with the asset, node, version and run it came from: `assetId`, `fileType`, `mediaType`, `fileSizeInKb`, `width`, `height`, `durationInMs`, `nodeId`, `nodeTitle`, `nodeType`, `canvasId`, `nodeVersionId`, `nodeRunId`, `toolName`, `layerIndex`, `model`, `variant` and `prompt`. Use it to import outputs by ID instead of matching file names, which change when two files share a name. Where run input records are available, each file also carries `inputs`: the sources its run sent to the model, in the same shape as the version's `producedBy.inputs` above. `output_list` returns, for each node with a finished output, its canvas, node, title, group, active `versionId` and `assetId`, media type, size, model (or the tool that produced it), `createdAt` and `updatedAt`. Uploads and nodes without a finished output are left out. Pass `groupId` with `canvasId` to list everything inside a group, including nested groups. Pass `since` to list outputs whose version changed after your last import: `updatedAt` moves when an output lands, so a generation that finishes after an import is still picked up. A version can appear again after a later edit, so deduplicate by `versionId`. A project is read 10 canvases per call: pass the returned `nextCanvasOffset` as `canvasOffset` until it is `null`. A canvas that cannot be read appears in `failedCanvases` with its error, and the other canvases' outputs are still returned. ## Models | Tool | Purpose | | - | - | | `model_list` | List available AI models, variants, and supported settings. | | `model_defaults` | See which models are used when none is specified. | ## Audio | Tool | Purpose | | - | - | | `audio_voice_list` | List stock ElevenLabs voices for audio nodes (text-to-speech or audio-to-audio). | | `custom_voice_list` | List the team's saved custom voices (cloned, designed, or imported). | ## Comments | Tool | Purpose | | - | - | | `comment_list` | List comments on a canvas. | | `comment_create` | Create a comment thread at a position on the canvas. | | `comment_reply` | Reply to an existing comment. | | `comment_resolve` | Mark a comment as resolved. | ## Presence | Tool | Purpose | | - | - | | `show_presence` | Claim a region of the canvas. **Required before node-scoped mutations.** | | `release_presence` | Release the current presence claim. | The claim overlay names the agent working in that region. Pass `agentName` to `show_presence` to set that name yourself; leave it out and the name of the client you connect through is used. `show_presence` returns a `presenceId`. Pass it to every later `show_presence` and `release_presence` call for the same task, so the release clears your overlay even if your client opens a new connection for each tool call. `release_presence` returns `removed: false` when no overlay with that `presenceId` was showing. An overlay you never release disappears on its own five minutes after your agent's last request to Melius. ## Presets | Tool | Purpose | | - | - | | `preset_list` | List available canvas presets — pre-built node + edge templates for common workflows. | | `preset_apply` | Apply a preset to a canvas in one call. Auto-positions to avoid overlapping existing content. | ## Files & imports | Tool | Purpose | | - | - | | `file_upload` | Upload images, MP4/MOV videos, or WAV/MP3 audio to an existing file node. Returns `complete` or transfer instructions. Optional `tags` label the file in Assets. | | `file_upload_complete` | Finalize a `pending_curl` upload after running its transfer command. | | `url_to_canvas` | Download image or video URLs and add them as file nodes on the canvas. | | `attachments_to_canvas` | Add images or videos you attached in ChatGPT to the canvas as file nodes. ChatGPT only. | Before `file_upload`, create a file node with `mediaType: "audio"` for WAV or MP3 files. Upload the audio directly to use it with Scribe, voice isolation, or Seedance audio inputs. See the [upload workflow](/mcp/overview#uploading-images-videos-and-audio). `file_upload` takes up to 20 tag names. Each name matches one of your team's tags ignoring case, and a name your team doesn't have yet creates the tag. Tags are added with the file, so you can find it later by tag in **Assets**. Viewers can upload but can't tag. ## Team skills Team skills are the skills saved under **Settings** > **Agent**. The tools act on the team the MCP connection uses. | Tool | Purpose | | - | - | | `list_agent_team_skills` | List the team's saved skills with their slash commands and instructions. | | `load_agent_team_skill` | Load one skill by ID or slash command, including its images. | | `create_agent_team_skill` | Save a reusable team skill — a named set of agent instructions applied from chat by typing `/skill-name`. | | `update_agent_team_skill` | Rename a skill or change its kind, description, or instructions. | | `delete_agent_team_skill` | Delete a skill and its images. | | `list_agent_team_skill_assets` | List a skill's images with their descriptions. | | `upload_agent_team_skill_asset` | Add an image to a skill. | | `attachments_to_agent_team_skill` | Add images you attached in ChatGPT to a skill. ChatGPT only. | | `complete_agent_team_skill_asset_upload` | Finish an image upload when the agent had to transfer the file itself. | | `update_agent_team_skill_asset` | Change an image's description. | | `remove_agent_team_skill_asset` | Remove an image from a skill. | ## Agent context | Tool | Purpose | | - | - | | `import_agent_context` | Materialize the team's agent-context images on the canvas as a default group with matching description text nodes. | ## Display | Tool | Purpose | | - | - | | `display_canvas` | Render an inline preview of the canvas the agent changed, with a link to open it. | Pass `focusNodeIds` to `display_canvas` to center the preview on the specified nodes or groups. If none of the IDs resolve, the preview and generation status use the canvas overview. The preview is a timestamped snapshot of the canvas and its generation status. An unfinished image shows **Generating image**; when a new version is generating, the previous image stays visible with a caption beneath it. Click **Refresh** to fetch current content while preserving your view and playback on unchanged nodes. Each refresh and agent call to `display_canvas` counts toward your MCP call limit. Text results identify unfinished generations and failed, cancelled, or unavailable outputs. Runs outside the requested focus are listed separately. Template runs appear under their visible template box; their internal workflow stays private. For finished deliverables, your agent uses `bulk_run_wait` for returned bulk run IDs or `run_wait` for individual run IDs, then calls `display_canvas` again. A template without a public bulk run ID can be checked with **Refresh** or **Open in Melius**. When the server cannot provide status, the preview says it is unavailable. An overview can be shown while generations continue. ## Cast > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. Ask explicitly to use **Cast** to create presenter videos inside your agent chat. Generic video requests continue to use the regular Melius canvas workflow. Choose or create an avatar and describe your video. Your agent writes the script, validates the settings and generates through your client’s normal tool approval. Cast tools appear when you connect with a team. Access is checked again whenever a tool runs, including actions in the image picker. | Tool | What it does | | - | - | | `cast_options` | Read capabilities privately so the agent can infer settings | | `cast_template` | Browse current Cast templates and choose a starting script | | `cast_library` | Choose an avatar from All, Custom avatars or Melius avatars, or a saved background | | `cast_resolve_selection` | Recover an already-selected avatar or background without showing another picker | | `cast_render` | Generate four avatar or background choices, or up to 12 different people at once | | `cast_save_choice` | Save the image you selected, or every avatar you kept from one card | | `cast_voice` | Preview, filter and choose stock or team voices, or Auto | | `cast_prop` | Search DAM prop images by meaning/name and requested folder, tag or source; upload or skip without Assets | | `cast_prop_upload` | Transfer a pasted/chat image, Cowork project image or accessible local image | | `cast_attachments_upload` | Save an image you attached in ChatGPT as a Cast prop. ChatGPT only. | | `cast_prepare` | Review your avatar, script, settings and estimated duration/cost | | `cast_batch_prepare` | Review all scripts/settings together with the combined estimate | | `cast_batch_run` | Submit 2–20 videos with one native approval and one batch card | | `cast_batch_result` | Check batch outcomes without opening another card; return videos and platform links | | `cast_run` | Generate the video from your selections | | `cast_video` | Compatibility name for `cast_run` | | `cast_wait` | Wait for the same generation without opening another card | | `cast_result` | Show generation progress, choices, or the finished video | | `cast_download` | Download the finished video | | `cast_history` | Browse your own or your team's past Cast videos, with the settings to remix each one | | `cast_library_rename` | Rename one of your team's saved avatars or backgrounds | | `cast_library_delete` | Delete one of your team's saved avatars or backgrounds | | `cast_background_from_photo` | Save your own photo of a place as a background, without generating one | Clients that support MCP Apps show avatar choices and a video player with **Download video**. Other clients receive numbered choices and media links. Voice, background, prop and template pickers appear only when you explicitly request them. Ask your agent to draft or edit the script in chat. Draft-only requests stop before generation. For generation requests, it infers settings from your brief. The default is **Seedance 2.5**, your avatar's saved voice, portrait 9:16, the model’s default resolution and no subtitles. An avatar saved without a voice reads in the studio's default voice, as it does in the Cast studio. You can request any supported model, aspect ratio, resolution, subtitles, Auto voice or specific voice in chat. You can also ask for a tone, such as warm, deadpan or hype, or describe your own. Explicit settings take priority; incompatible choices need clarification. Technical settings are not shown as inline controls. Video style and speech delivery stay internal and do not appear as review fields. Scripts support both spoken lines with visual direction and separate silent action sections. Your agent can add gestures, demonstrations and reactions when they help your brief. For example, ask: “Explain how the Moon formed, act out the impact silently, then continue speaking.” Actions appear in the script review before generation and are not read aloud. You can also supply exact dialogue and stage directions in chat. A video can hold up to four props. A single prop appears throughout the video unless an action places it in specific sections. With several props, each appears only in the sections whose action uses it, as in the Cast studio. For example: “Show the serum while I talk about mornings and the mask while I talk about evenings.” To make new avatars without describing anyone, ask your agent to generate some for you, up to 12 at once. It writes different people, each with their own name and voice, and shows them in one card. Every person starts ticked: untick anyone you don't want, rename them, play and change their voice, then save them all in one step. Each avatar reads in the voice it was saved with. **Change voice** opens the same voice picker as Melius, already narrowed to voices like that person's. Search, filter by gender, age, language and more, switch between the Standard library and your team's voices, play samples and heart favorites. In clients without inline cards, your agent lists the people and their voices in chat and changes a voice when you describe the one you want. An avatar made from your own description comes with a suggested voice. Play it or choose another before you save. Naming an existing avatar in your first request already selects it. Your agent can prepare or generate using that name directly, without opening the library or asking you to confirm it. Matching ignores capitalization. If the name is missing or matches multiple avatars, the agent asks for clarification instead of substituting another avatar. After you confirm an avatar in a picker, your agent continues with that selection. If your client places the selection message in the chat box, press Send to continue. The agent can recover the named selection without opening another picker. Generation uses your MCP client’s native tool approval. With auto-approve enabled in the client, a request such as “make 10 videos using Loopy” needs no additional **Generate** click for each video. Your agent reuses the named avatar, prepares all requested scripts and checks their combined estimate, then submits every video without waiting for earlier renders. Your plan and the generation queue determine how many render simultaneously. Multi-video requests use one batch review and one live batch card containing every video, completion/failure counts, downloads and **View all in Cast**. Each request supports up to 20 videos. Single videos retain their individual card. Existing credits and usage limits apply. Keep the conversation active until all requested videos are submitted. Accepted renders continue on the server; the agent cannot resume an unsubmitted batch after the client closes. Saved avatars use a headshot cropped from the same identity image used by the Cast studio. No extra image generation is needed. Ask about past videos to see your own Cast history, or your team's finished videos. To remix one, ask for the same video with your changes: your agent reuses its avatar, voice, tone, props, script and settings, and tells you anything it cannot carry over. You can also rename or delete your team's saved avatars and backgrounds, and save a photo you already have as a background without generating one. Your agent deletes only when you ask it to, and confirms the name first. In Apps clients, the card opened by an accepted generation tracks that video through rendering and subtitles, then becomes the finished player. Your agent does not need another result call. Text-only clients poll accepted videos and return media links. Loading cards update automatically without an elapsed-time counter. Progress checks never restart generation. Each wait call uses a short window; an unfinished window continues checking the same video. A failed video stops waiting and shows its error. Requested subtitles finish before **Download video** retrieves the file. If subtitles still fail after retries, the original is available with a warning and the subtitle credits are refunded. You can ask the agent to check an existing run again without creating another video or card. If a status check fails, the card reports that the current status is unavailable and provides **View in Cast**. Batch cards check only unfinished videos and slow their retries during outages. Your Cast review includes the selected prop image so you can verify it before generation. For an image already attached or present in your Cowork folder, the agent uses that file directly without searching Assets. If your team has access to **Assets**, you can select an existing image as a prop. Semantic library search requires **Pro** or above; uploading an image from chat does not. Otherwise, attach an image in your chat or skip the prop. Attachments require a client that can access and transfer the file; the remote MCP server cannot read your device's files itself. Cast follows the same MCP usage policy as the other tools. Ordinary Cast calls are recorded in your team's MCP usage; `cast_result`, `cast_wait` and `cast_batch_result` polling have the same counting exemption as other generation polling tools. Image and video generation use your team's credits. Checking an existing run never restarts the video. For a video requested with subtitles, Melius adds them once the original video is ready, whether or not anything is checking. A subtitle pass that fails or stalls is retried, up to five passes in total, and checking never starts an extra one. If some candidates fail, the available images remain selectable with their original option numbers. ## Sticky notes Read sticky notes through `canvas_content`. The `notes` array includes each note's ID, text, color, position, width, height and group. Use `noteId` for one note, or `noteOffset: 0` followed by `nextNoteOffset` to page through notes. A grouped note's position is relative to its group. Use `note_create` to place a label, `note_update` to change its text, color, position or size, and `note_delete` to remove it. All three require editor access. Omitted update fields are preserved. Set `color` to `yellow`, `pink`, `blue`, `green` or `purple`. New notes default to `yellow`. Set `geometry.w` to at least 240 and `geometry.h` from 120 to 960. Widths such as 1500 are supported. Values below the minimum or above the height limit are clamped, and a short wide note works as a label bar. Text stays at its chosen size when the note is resized. Long text scrolls inside the note. A side stored outside its range keeps its size until you change it. ```json theme={null} { "canvasId": "<canvas-id>", "body": "Alex", "color": "blue", "geometry": { "x": 0, "y": -120, "w": 1500, "h": 120 } } ``` Create and update responses return the saved note, including its ID and color. Use that ID as `noteId` when updating or deleting it. Call `note_delete` with `canvasId` and `noteId`; it returns `{ "message": "Deleted", "noteId": "<note-id>" }`. # Audio models Source: https://docs.melius.com/models/audio Audio-generation models available on audio nodes. ## ElevenLabs * ElevenLabs v4 * ElevenLabs v4 Turbo * ElevenLabs v3 * ElevenLabs Turbo v2.5 * ElevenLabs Sound Effects * ElevenLabs Music * ElevenLabs Scribe v2 * ElevenLabs Voice Changer * ElevenLabs Voice Isolator — needs an audio clip at least 4.7 seconds long ## ByteDance * Seed Audio 1.0 ## Fish Audio * Fish Audio S2.1 Pro ## MiniMax * MiniMax Speech 2.8 HD * MiniMax Music 3 ## Alibaba * Qwen3 TTS 1.7B — choose Vivian, Serena, Uncle Fu, Dylan, Eric, Ryan, Aiden, Ono Anna, or Sohee in the voice picker. Vivian is the default. ## Google * Gemini 3.1 Flash TTS — supports inline delivery instructions and expressive tags such as `[laughing]` and `[whispering]` ## xAI * xAI TTS v1 ## Sonilo * Sonilo Sound Effects * Sonilo Video Sound Effects Use [`model_list`](/mcp/tools#models) for the live catalog and exact variant IDs. # Image models Source: https://docs.melius.com/models/image Image-generation models available on image nodes. The default model for image generation and editing is **GPT Image 2.5 Sunburst**, using **High** quality. Choose another model on the node or in your team's [generation preferences](/canvas/dimensions#set-the-defaults-for-new-nodes) to override it. ## OpenAI * GPT Image 2.5 Sunburst * GPT Image 2.5 Flare * GPT Image 2 (High) * GPT Image 2 (Medium) * GPT Image 2 (Low) ### GPT Image 2.5 Choose **GPT Image 2.5 Sunburst** or **GPT Image 2.5 Flare** on an image node to generate from a prompt or edit with up to 16 connected reference images. Use **Quality** to select **Auto**, **Low**, **Medium**, **High**, **Extra high** (`xhigh`), or **Max** for either model. **High** is the default for everyday production. Try **Extra high** or **Max** selectively for complex poses or hero images; higher settings increase detail and generation time. **Auto** lets the model choose the quality. Both models support **1K**, **2K**, and **4K**, with **2K** selected by default. Available aspect ratios are **21:9**, **20:9**, **19.5:9**, **2:1**, **16:9**, **3:2**, **4:3**, **5:4**, **1:1**, **4:5**, **3:4**, **2:3**, **9:16**, **1:2**, **9:19.5**, **9:20**, and **9:21**. GPT Image 2 offers the same aspect ratios. Use **Background** to choose **Transparent background** for a PNG with no background, such as a sticker, logo, or product cutout. **Solid background** always fills the background, and **Auto background**, the default, lets the model decide from your prompt. Transparent works best when the prompt describes only the subject: a scene in the prompt can override it, and fine edges like hair or glass may be imperfect. The background choice does not change the credit price. The credit price shown before generation is the amount charged per image. It is based on estimated token usage for the selected quality and resolution; additional references increase the price. **Auto** uses the **Max** quality quote because the model chooses its quality during generation. Resolutions above 2560 × 1440 are experimental. ## Google * Nano Banana 2 * Nano Banana 2 Lite * Nano Banana Pro ## Ideogram * Ideogram 4.5 ### Ideogram 4.5 precise edit When you connect an image to an Ideogram 4.5 image node, turn on **Precise edit** in the toolbar to change only what your prompt asks for. Everything else in the image stays pixel for pixel the same, so you can keep editing the same image without it drifting. The result keeps the source image's size, so aspect ratio and resolution are not used while it is on. Precise edit costs the same as a regular edit at the same quality. ## Black Forest Labs * Flux 3 Image * Flux Schnell * Flux Pro 1.1 Ultra * Flux 2 Max * FLUX.1 LoRA * FLUX.2 LoRA ## Stability AI * Stable Diffusion XL ## Melius * Better Fonts > [!NOTE] > > Available on **Professional** and above. See [Plans](/billing/plans). Better Fonts uses **GPT Image 2.6 Sunburst** at fixed **High** quality to render text in your chosen font. This applies to both prompt-only generation and image editing. ## Quiver * Arrow 2 * Arrow 2 Telos Choose **Arrow 2** or **Arrow 2 Telos** to generate SVG artwork from a prompt and up to 14 reference images. Both support aspect-ratio selection and **Low**, **Medium**, **High**, or **Extra high** quality. Medium is the default; higher quality gives the model more reasoning effort. When you connect one image and leave the aspect ratio unset, the SVG uses the closest supported ratio to that image's dimensions. Select a ratio to override it. With multiple images or unavailable source dimensions, the default is square. For these two models, the credit amount shown before running is an estimate. Your final charge uses the input and output tokens reported by Quiver, including reference images, with Melius's standard image markup. Telos costs 50% more per token. Longer prompts, more references, and more detailed output can increase the final charge. Team discounts and free-generation access still apply. The final charge must fit your available credits and member spending limit before the result is delivered. ## ByteDance * Seedream 5.0 Pro * Seedream 5.0 Lite ## Krea * Krea 3 ## Luma * Uni-1.1 Max ## Microsoft * MAI Image 2.5 * MAI Image 2.5 Pro ## Alibaba * Qwen Image 3 ## xAI * Grok Imagine * Grok Imagine Image 2.0 ### Grok Imagine Image 2.0 quality When you select Grok Imagine Image 2.0 manually, use **Quality** to choose: * **Low** for lower-cost drafts. * **Medium** for higher-quality output. * **Auto** to mirror xAI's current automatic choice: Low for image generation and Medium for image editing. Quality and resolution both affect the generation's credit cost. The run button shows the combined estimate before you generate. ## Recraft * Recraft V4.1 * Recraft V4.1 Pro * Recraft V4.1 Flash ## Meta * Muse Image Use [`model_list`](/mcp/tools#models) for the live catalog and exact variant IDs. # Models overview Source: https://docs.melius.com/models/overview Every AI model available on the canvas, grouped by category. Melius routes generations through frontier text, image, video, and audio models. The catalog changes frequently. Use [`model_list`](/mcp/tools#models) (MCP) for the live set, including image and video tools. ## Categories | Category | Used on | Purpose | | - | - | - | | `text` | Text nodes | Language model output. | | `image` | Image nodes | Image generation. | | `video` | Video nodes | Video generation. | | `audio` | Audio nodes | Audio generation — speech, music, sound effects. | | `image-tool` | Image nodes | Image-to-image transforms and edits. | | `video-tool` | Video nodes | Video-to-video transforms. | ## Defaults When you create a node without specifying a model, Melius picks a sensible default for that node type. Call [`model_defaults`](/mcp/tools#models) to see the current defaults. ## Picking a model Each node has a model selector. Filter by category, then pick the variant. The selector also shows which settings (aspect ratio, resolution, quality, duration, or text-model thinking level) the model supports — unsupported settings are hidden. ## Deprecation These catalog pages list active models only. Models are occasionally deprecated when a provider replaces them with a newer version. Existing nodes pointing at a deprecated model continue to work for a grace period — Melius surfaces an in-app warning when this happens and recommends a successor. After the grace period, the deprecated model is removed and re-runs use the recommended successor. # Text models Source: https://docs.melius.com/models/text Language models available on text nodes. The following text models are currently available on text nodes. ## Thinking controls Select a text node and choose a specific model to set its **Thinking** level in the node toolbar. The menu shows only the levels that model accepts, including **Off** when reasoning is optional. Models with fixed reasoning or no reasoning control do not show the menu. When you switch models, Melius keeps the closest supported level. **Auto** routing uses the router's own reasoning default and hides the manual control. Higher thinking levels can take longer and consume more output tokens, so the final credit cost can increase. ## OpenAI * GPT-6 Astra * GPT-5.6 ## Anthropic * Claude Fable 5.1 * Claude Haiku 4.5 * Claude Sonnet 5 * Claude Opus 5.5 * Claude Opus 5 ## Google * Gemini 3.8 Flash * Gemini 3.5 Flash * Gemini 3.1 Pro Gemini 3.1 Pro text nodes keep the selected model during provider recovery, including template runs. If generation cannot complete, retry Pro or choose another model that supports your connected inputs. Failed attempts do not add a completed-generation charge. Content-policy blocks and invalid requests still fail. ## xAI * Grok 4.6 * Grok 4.5 ## Meta * Llama 4 Maverick ## Mistral * Mistral Large 3 ## Alibaba * Qwen 3.5 397B * Qwen 3 VL 235B ## DeepSeek * DeepSeek V4 Pro Use [`model_list`](/mcp/tools#models) for the live catalog and exact variant IDs. # Video models Source: https://docs.melius.com/models/video Video-generation models available on video nodes. ## Google * Veo 3.1 * Gemini Omni Flash 1.1 ## xAI * Grok Imagine Video * Grok Imagine Video 1.5 * Grok Imagine Video Extend ## Kuaishou (Kling) * Kling 3.0 Omni * Kling 3 Turbo Standard * Kling 3 Turbo Pro * Kling 3 Pro * Kling 2.5 Turbo * Kling Lipsync * Kling Avatar Kling 3.0 Omni accepts input videos from 3 to 15 seconds long. If your clip is outside this range, choose a longer clip or trim it before generating. Melius checks the video length before sending it for generation. Kling Lipsync accepts videos from 2 to 10 seconds and audio from 2 to 60 seconds. The audio and video can have different lengths. Choose longer clips or trim clips outside these ranges before generating. ## ByteDance * Seedance 2.5 * Seedance 2.0 * Seedance 2.0 Mini ### Seedance 2.5 aspect ratio When you connect exactly one video and a text prompt, **Aspect ratio** is locked to **Auto** and follows the input video. To extend the scene, describe what should happen after the video's final frame in your prompt. Connect a second video, an image, or an audio reference to choose an aspect ratio manually. Your previous manual ratio remains selected when the control unlocks. Other Seedance models keep their existing aspect-ratio controls. ### Seedance 2.5 drafts Turn on **Draft** to preview a take at 480p for fewer credits. The switch is in the node toolbar and in the details panel on the right when the node is selected. While Draft is on, the resolution stays at 480p. ![A Seedance 2.5 video node with the Draft switch turned on in the node toolbar and the resolution locked at 480p](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-switch.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=0b7938c5291ee6a25a46b7dca22408dd) When a draft looks right, select **Upscale to 1080p** in the details panel, or hover the node's run button and select **Upscale**. Melius renders the same prompt, shot, and audio at 1080p as a new version on the same node. You can upscale a draft for 7 days after it's made. The node header shows **Upscaled** next to the model name while an upscaled version is on show, and upscaled versions are tagged **Upscaled** in the version history. ![The details panel for a draft, with Draft turned on and the Upscale to 1080p button below it](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-upscale-panel.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=bbee249918eca0b1607facadfa90b55a) ![The same video node showing its 1080p version, with Upscaled next to the model name](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-upscaled-node.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=65449e2b9bdea4cf7d61c8ac8ef657c5) ![Hovering the node's run button reveals Upscale, with a tooltip showing the credit cost and the date the draft can be upscaled by](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-upscale-run.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=7eb568c86b19d66d929566d1dca5d9c1) The upscale keeps the draft's framing, motion, and timing, and adds the detail a 480p preview can't hold. ![The same frame from a 480p draft and its 1080p upscale, side by side; the shot is identical and the upscale is sharper](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-vs-upscale-vertical.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=1becc314f621284b03423d5df141db6e) ![A close crop of fine engraving from a 480p draft and its 1080p upscale; the upscale resolves the fine lines the draft blurs](https://mintcdn.com/melius/TypWwCVMX4IfiDM_/images/seedance-drafts/seedance-draft-vs-upscale-detail.jpg?fit=max\&auto=format\&n=TypWwCVMX4IfiDM_\&q=85\&s=2872b074dc5edd44f3331975de8c13b9) Fine texture, small text, and distant detail gain the most from the upscale. Judge a draft on composition, motion, and timing, then upscale the ones you want to keep. To upscale several drafts at once, select their video nodes and choose **Upscale to 1080p** in the right-hand panel. The button appears only when every selected node is showing a draft. Each upscale creates a new version on its original node; if any selected draft has expired, the button is disabled. To run the node at another resolution instead, turn off **Draft** and choose a **Resolution**. ### Seedance 2.5 reference media Reference videos must fit between 1:2.5 and 2.5:1. Melius adds black bars to a wider or taller video before generating. Reference audio clips must each be 1.8 to 30 seconds, with up to 30 seconds of audio in total. ## Alibaba * Wan 3.0 * Wan 2.7 * Wan 2.2 * Happy Horse 1.1 ### Wan 3.0 video extension For Wan 3.0, including its fast **Prime** tier, connect exactly one video and write a prompt describing the continuation, such as "Extend Video 1 forward: the person keeps walking and enters the building." **Aspect ratio** locks to **Auto** to follow the source video and enable extension based on your prompt. Connect another video, an image, or an audio reference to choose a ratio manually. Your previous manual ratio is restored. Text-only and image-only generation keep their existing aspect-ratio controls. Wan 3.0 reference videos must each be at least 1 second long, with up to 15 seconds of reference video and 15 seconds of reference audio in total. ## Lightricks * LTX 2.5 * LTX 2.3 * LTX 2.3 Quality ## Vidu * Vidu Q3 ## Luma * Ray 3.2 To edit a video with Ray 3.2, connect a source clip of 18 seconds or less. ## PixVerse * PixVerse v5.6 ## MiniMax * MiniMax H3 * MiniMax H3 Max — the faster post-trained preview supports text, first/last frames, and multimodal references at 480P, 768P, or 1080P. A reference generation can combine up to nine images, three video clips, and three audio clips, with 12 files total. In Auto mode, the canvas rejects additional reference-image connections once nine images are connected and shows the model's limit. Connect at least one image or video when you use reference audio. Reference audio clips must each be 2 to 15 seconds, with up to 15 seconds in total. A reference generation can also open on a starting frame and end on a last frame, which count toward none of those limits. The video takes the starting frame's shape. With a reference video connected, the frames are used as reference images instead. * MiniMax H3 Max Turbo — the quickest H3 tier. It generates from text or from first/last frames at 480P or 768P, at half the credits of H3 Max per second. It also takes the same multimodal references as H3 Max, at 480P, 768P, or 1080P. The half-price rate does not apply to references: a reference generation costs as many credits per second as on H3 Max. * MiniMax H3 Max Extend — connect one video and describe what happens next. It adds 5 to 15 seconds of new footage and returns the source with the continuation appended, in the source's aspect ratio, at 480P, 768P, 1080P, or 2K. The source clip must be 1.6 to 60 seconds long and up to 50 MB. Credits are charged for the new seconds only. * MiniMax H3 Max Turbo Extend — the same extension as H3 Max Extend, with the same inputs, durations and resolutions, at half the credits per second. * MiniMax H3 Max Camera Controls — connect one image as the starting frame and pick a camera move from **Camera** on the node or fullscreen toolbar: dolly in or out, truck left or right, pedestal up or down, pan, tilt or roll left or right, or S-curve forward. The camera makes exactly that move. Choose **Camera from the prompt** to let the prompt direct the camera instead. Once a move is picked, the prompt is optional: leave it blank and the scene holds still while only the camera moves. Clips run 5 to 15 seconds at 480P, 768P, or 1080P, in the starting frame's shape. ## Black Forest Labs * Flux 3 * Flux 3 Extend * Flux 3 Keyframes * Flux 3 Edit ### Flux 3 video editing Choose **Flux 3 Edit** on a video node, connect one source video, and describe the changes in a prompt of up to 4,096 characters. For example: "Make it snow heavily and give the scene a cold winter palette." The edit preserves the source clip's motion, timing, and framing. Use a clip under 15 seconds and 50 MB; Melius prepares the source as MP4 before submitting it. Output settings follow the editing model automatically. Editing costs **34 credits per second** of source video, rounded up to a whole second. A five-second clip costs 170 credits. ## Sonilo * Sonilo Video Music * Sonilo Video Sound Effects ## Lipsync & avatar * Boreal * Infinitalk — use audio at least 1.8 seconds long with an image, or 3.4 seconds with a video. The generated clip can end slightly before the audio to fit the model’s supported frame lengths. * AI Avatar * HeyGen Lipsync * HeyGen Digital Twin * HeyGen Avatar IV * VEED Fabric 1.0 * VEED Lipsync v2 * Sync Lipsync v3 * Sync Lipsync v2 Pro Use [`model_list`](/mcp/tools#models) for the live catalog and exact variant IDs. # Agent Source: https://docs.melius.com/settings/agent Configure MCP, team-wide context, and reusable skills for Mel. ## Dictation Click the microphone in an empty chat composer to dictate a message. Click **End** when you finish, or pause to let recording end automatically. The transcript appears in the message box for you to review and edit. If you type while recording, the transcript is added after your text. Click the send arrow or press **Enter** when your message is ready to run Mel. ## Queued messages You can send a follow-up while Mel is working. It waits as one queued message; anything else you send while it waits is added to that message. Click the queued message's pencil icon to edit it. The message bubble updates as you type. Mel waits until you save the edit with **Enter** or the send arrow, even if the current task finishes or you decline an approval. Press **Escape** to discard your edits and release the original queued message. While its attachments upload, you can edit it once they finish. Click the queued message's **×** to cancel it. Mel never receives it, and your draft in the composer stays as it was. Click **Stop** to halt Mel's current task. Stop also cancels the queued message, so nothing sends after the task stops. A queued message holds up to 50,000 characters. If a follow-up you type would go over that, it stays in the composer. If a queued message still ends up over the limit, Mel waits until you edit it to fit. ## MCP Use the **MCP** to connect Melius to Claude, Cursor, and other [MCP](/mcp/overview) clients. MCP lets external agents read and write to your Melius projects and canvases. The API keys these clients use are managed under [Integrations](/settings/overview#integrations). ## Context Context (Applied automatically to every agent message for this team.) is team-wide guidance that Mel uses on every agent call. Use it for stable rules like brand voice, product constraints, preferred style, naming rules, or anything Mel should always remember for the team. Good examples: * Use a polished editorial tone. * Prefer square compositions unless the user asks otherwise. * Never use competitor logos. * Our brand colors are cobalt blue, white, and charcoal. Avoid putting one-off task instructions here. Put those in the chat prompt. ## Brand kit Turn on **Use brand kit in Mel by default** to start every new chat with your team's default [brand kit](/brand-kit/overview). Turn it off to use the kit only in chats where you turn on **Attach brand kit** in the chat's **+** menu. ## Video pronunciation > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. When you ask Mel to make a video with dialogue or a voiceover, Mel checks for words that may be mispronounced, such as brand names or unfamiliar names. Before generating, Mel suggests a phonetic spelling and asks you to confirm it. For example: “Should Cantina sound like kan-TEE-nuh?” You can accept the suggestion, give a different pronunciation, or keep the original spelling. Mel saves your choice in a **Pronunciation notes** text node on that canvas and reuses it for later videos, including in a new chat. You can edit the note or ask Mel to change or forget a pronunciation. Say “this time only” to use a choice without saving it. Choices stay on that canvas. Pronunciation guidance applies to speech. Captions, logos, and other visible text keep their original spelling. Phonetic hints can improve pronunciation, but the generated audio may still need another attempt. This check applies to videos prepared through Mel; it does not intercept runs you start directly from a node. ## Skills Skills are saved instructions your team can apply in agent chat by typing `/skill-name`. Create a skill for repeatable workflows, styles, or production rules that should only apply when selected. Example: ```md theme={null} /portrait-retouch Retouch portraits naturally. Preserve skin texture, avoid plastic smoothing, keep lighting realistic, and do not change facial identity. ``` To use a skill, type its `/skill-name` at the start of an agent message. You can also click the **+** button in the chatbox and select the skill from the dropdown. Selected skills appear as chips in the chat input and apply to that message only. Select the skill again for any later message that should use it. ## Skill images Skills can include reference images. When you select a skill with images, Mel can use those images as references for generation. They are not added to the canvas automatically. ## Import skill Use **Import skill** to upload a Markdown skill file. The file's `name` frontmatter or first `#` heading becomes the skill name, and the Markdown body becomes the instructions. ## Manage skills from other tools Agents connected through [MCP](/mcp/tools#team-skills) and scripts using the [REST API](/api/overview) can list, create, update, and delete your team's skills and their images. Changes appear here immediately. ## Context vs skills * Use Context for rules that should always apply. * Use Skills for reusable instructions that should only apply when selected. * Use the normal chat prompt for one-off instructions. # Settings Source: https://docs.melius.com/settings/overview Where to find account, team, billing, and API key settings. Settings live in two places: **account-level** (you as a user) and **team-level** (the team you're working in). Open **Settings** from the sidebar or the canvas menu without leaving your work. The address keeps your current page and adds the section, such as `/projects?settings=usage`. Switching sections updates that address. **Back** or **Close** returns to your work. Refreshing restores the same page with Settings open; unsaved work follows that page’s usual reload behavior. For a link that opens Settings independently of a project or canvas, use `/settings/profile`, `/settings/members`, `/settings/usage`, or `/settings/api-keys`. Closing this dedicated view goes to Home. Settings opens for the team selected in the recipient’s browser; the link does not grant team access. Signing in and completing required onboarding preserves the destination. Settings lists its sections under two headings: **Account** for what belongs to you, and **Team** for what the whole team shares. ## Account ### Profile Your picture, name, and email, each on its own row. Your email is shown but not editable here. **Session** below it holds **Sign out**, which ends the current session for your account on this browser. ### Preferences The settings that follow you to every team you belong to: display options such as hiding dedicated prompts on media nodes, the generation checks that warn you before a run, your canvas group colors, and your own generation defaults. #### Generation preferences The model and settings the nodes you create start with, on top of your team's. Each menu starts on **Team default**; change one to override the team for your own nodes only. See [Your own defaults](/canvas/dimensions#your-own-defaults). #### Canvas group colors Choose a color scheme for canvas groups: **Current**, **Vibrant**, **Soft**, **Stark**, **Earth**, or **Neon**. The scheme applies as soon as you select it and recolors existing groups, their titles, and the color swatches in a group's toolbar. It's saved to your account, so it follows you to your other browsers and devices, and other members keep their own scheme. Select **Current** to return to the default look. ### Agent See [Agent](/settings/agent) for MCP setup, team-wide guidance, and reusable instructions Mel can use in chat. ## Team ### Members Who is on the team and what each person may reach and spend. **Access** at the top of the page holds automatic joining, on teams that have it, and **Leave team**. Below it are search, inviting by email, and the roster with per-member project access and credit limits. The roster fills the rest of the page and scrolls within it. See [Members & roles](/collaboration/members). ### Usage A live view of credits consumed in the current cycle, broken down by model and by member. Useful for spotting expensive generations or runaway agents. ### Integrations Generate API keys for the [MCP server](/mcp/overview). Each key is shown once at creation time — copy it then; you can't view it again. Keys can be: * Named (e.g. `Claude`, `prod-bot`, `local`) * Scoped to specific teams * Given an expiry or marked `no expiry` * Revoked at any time ### Preferences **Team details** holds the team's name and picture. **Team preferences** gathers Autoformat spacing, generation controls, and agent chat sharing in one card. **Danger zone** at the foot of the page holds **Delete team**, for an owner. #### Generation preferences The model, aspect ratio, resolution, duration, voice, and variation count that the team's new nodes start with, plus the default font for the Better Fonts model. Owners, admins, and editors can change them; viewers see them read-only. To open them from a canvas, click the hamburger menu in the canvas menu bar, then **Settings**. See [Set the defaults for new nodes](/canvas/dimensions#set-the-defaults-for-new-nodes). ### Plans & billing See [Plans & billing](/billing/plans) and [Payment methods](/billing/payment). # Uploads & assets Source: https://docs.melius.com/uploads/overview Bringing your own images, videos, audio files, and PDFs into Melius, and attaching videos to Mel chat. You can bring your own images, videos, audio files, and PDFs into a canvas as **file nodes**. Uploaded files become first-class assets — they can be referenced by edges, passed to models, or used as references on video nodes. ## What you can upload to a canvas * **Images** — JPEG, PNG, WebP, GIF, AVIF, SVG, HEIC, HEIF. HEIC and HEIF originals are preserved for download, with JPEG previews for display and generations (up to 64 MB and 100 megapixels per photo). * **Videos** — MP4, MOV, and WebM. * **Audio** — MP3, WAV, M4A, AAC, OGG, and FLAC. An audio file becomes a file node with an audio output, which you can connect to any node that takes audio. * **PDFs** — choose **Summarize** to add the PDF with a text summary and its key images, or **Extract each page as an image**. * **Maximum size** — 20 GB per file. ## Attach videos to Mel chat You can upload videos from your computer to **Mel web chat**. Click the attachment button or drag a video into the chat composer. You do not need to publish your video on a public hosting site. * **Formats** — MP4, WebM, and MOV. * **Maximum size** — 50 MiB per video. * **Per message** — up to three videos. Mel cannot open a file path on your computer directly. Attach the file through the composer so Mel can access it. These chat limits are separate from a generation model's video-input limits. ## How to upload * **In the app** — drag files from your computer onto the canvas, or pick **Upload** from the node toolbar. * **MCP** — create a file node with the matching media type, then call [`file_upload`](/mcp/tools#files). If it returns `pending_curl`, run the transfer command and call [`file_upload_complete`](/mcp/tools#files). * **CLI** — `mel upload <path>`. The MCP `file_upload` tool takes images, MP4/MOV videos, and WAV/MP3 audio. Upload songs directly as audio for Scribe or voice isolation; wrapping them in an MP4 makes them video assets. `mel upload` takes images. For other formats, drop the file onto the canvas in the app. When you drop or select several files for the canvas at once, they appear together in a compact, roughly square grid inside a group. The layout keeps your file order and leaves room for different image sizes. ## Attach files in Mel chat The Mel chat box takes images, videos, audio files, PDFs, and Markdown files. Click the attachment button or drag files into the chat box. * **Images** — JPEG, PNG, WebP, and GIF. Up to 15 per message, 50 MB each. * **Videos** — MP4, WebM, and MOV. Up to 3 per message, 50 MB each. * **Audio** — MP3, WAV, M4A, AAC, OGG, and FLAC. Up to 5 per message, 50 MB each. * **Documents** — PDFs up to 25 MB and Markdown files up to 1 MB. Up to 5 per message. Images, videos, and audio files you attach are also added to the canvas as file nodes. An attached audio file becomes a file node with an audio output, and Mel connects it to the nodes that use it, for example as the soundtrack under a video. The prompt box on **Home** takes the same files. They're added to the new canvas when it opens. ## Upload images in Cast > [!NOTE] > > **Beta** — this feature is rolling out gradually. Reach out to support if > you'd like access. After choosing an avatar in **Cast**, drag an image from your device onto the **Background** or **Prop** card. You can also click an empty card's upload area to choose a file. Dropping an image onto a populated card replaces its selection. Background uploads are saved for your team to reuse; prop uploads select the image for your cast. Each card uses the first supported image from a drop, and shows **Uploading…** until it finishes. ## Track uploads in Files Uploads and imports started from **Files** appear in a queue at the bottom right. Expand the queue to check progress, or collapse it while you work. * **Device uploads** continue when you navigate to another page in Melius. Keep the tab open until they finish. * **Connected Google Drive imports** run durably in the background. If you reload or restart Melius, retained import jobs return to the queue. * **Failed uploads** remain in the queue so you can retry or dismiss them. ## Playback quality for large videos Large uploaded videos get smaller playback copies at up to **480p**, **720p**, and **1080p**. Playback automatically selects a suitable resolution for your connection and player size. There is no quality setting to manage. The smallest copy becomes available first. The player only lists prepared qualities, and never enlarges a source beyond its original dimensions. Reopen a video to pick up qualities that finished while you were watching it. While preparation runs, Melius plays the original when your browser can decode it. Preparation finishing in the background does not restart an open video. Use **Download options** to save a prepared **480p**, **720p**, or **1080p** MP4. Each size becomes available as preparation finishes, with its dimensions and file size shown in the menu. Sizes still being prepared are marked **Preparing**. The **Original** and, where available, larger **Optimized** download remain available. ## Sandboxed-agent network allowlist If you're running an MCP-driven agent in a sandboxed environment (Claude Code's sandboxed shell, for example), the sandbox needs network egress to `*.melius.com` for uploads to succeed. Add this exact entry to the sandbox's network allowlist: ``` *.melius.com ``` For Claude Desktop / Claude Code, the toggle lives in **Organization Settings → Capabilities → Code execution**. See the [MCP overview](/mcp/overview#uploading-images-videos-and-audio) for the full setup.