Upgrade20% OFF

Generate images & videos
inClaude withReelMe

  • Free to connect
  • You approve the price before each run
  • Runs use your ReelMe credits
  • Top up link when you run out
Image to videoOne still, animated with Seedance 2.0.
Canvas templateFilm
Image editKeep the subject, change everything around it.
Canvas templateAds

Skills your AI gets

Playbooks ReelMe hands your AI app for each kind of job, so it plans the canvas the way our own Canvas Agent does.

Camera language for video prompts (one move per shot)camera-languageMUST READ before writing any video prompt — shot sizes, one camera move per shot and what each move means, angles, lenses as visible results, coverage (180°, eyeline, screen direction) and emotion → camera picks.Seedance 2.0Seedance 2.0 FastSeedance 2.0 MiniSeedance 2.5Kling O3 Pro
Build well on the ReelMe canvas (read first)canvas-craftRead before building anything non-trivial on a canvas — how wires, references, models, node tools and Sequences really behave on ReelMe, the principles and techniques that get better, more consistent, cheaper results, and a decision table.GPT Image 2.5 SunburstGPT Image 2.5 FlareGPT Image 2Seedance 2.0Seedance 2.5Kling O3 ProGemini Omni Flash 1.1MiniMax H3 Max - Reference
Canvas recipes — node graphs for common jobscanvas-recipesReady node graphs for common jobs (product ad, UGC, fashion, food, real estate, music video, explainer, short film, key art, carousel, character series, before/after, end card, localisation) — which nodes, wires, tools and models, and what each costs roughly.GPT Image 2.5 SunburstGPT Image 2.5 FlareGPT Image 2Seedance 2.0Seedance 2.0 FastKling O3 Pro
Clone a video — same camera, timing and story, new character / product / placeclone-and-swapUse for the "Clone & swap" chip and whenever the user has a clip and wants the same video with someone or something else in it — replace the main character with their photo, swap the product, restyle the place — keeping the original performance, camera movement, timing and composition. One price card, no questions.Seedance 2.5Seedance 2.0Kling O3 ProMiniMax H3 Max - ReferenceMiniMax H3 MaxGPT Image 2.5 SunburstGPT Image 2.5 Flare
Direct a film or ad on the canvas (story, coverage, continuity)film-directorMUST READ before making any film, story, ad or multi-shot video — the director's process, beat sheets for 30 s / 60 s / 2 min, clips and shots, coverage, continuity, light and colour, dialogue and sound, references (tested on ReelMe) and the blockout mode.Seedance 2.0Seedance 2.0 FastSeedance 2.0 MiniSeedance 2.5Kling O3 ProGPT Image 2.5 SunburstGPT Image 2.5 Flare
Image-first: get every image right before any videoimage-firstMUST READ before the images of a film or ad — the 10 gated steps from intake and Film Bible to look frame, plates, keyframes and video, plates vs keyframes, keyframe = the starting frame of the move, and the two ways a keyframe goes into Seedance.GPT Image 2.5 SunburstGPT Image 2.5 FlareGrok Image v2Seedream V5 ProSeedance 2.0Seedance 2.5
Write image prompts for keyframes, characters and productsimage-promptingUse when you write the prompt of a ReelMe image node — a body or face plate, a location or prop plate, a look frame, a storyboard keyframe, or an edit of an existing image wired in as reference.GPT Image 2.5 SunburstGPT Image 2.5 FlareGrok Image v2Seedream V5 ProGPT Image 2
Animate an image (motion and camera)image-to-videoUse when the user wants an existing or generated image to move — wire the image into a video node and write a motion-only prompt, optionally with a start and end frame.Seedance 2.0Seedance 2.0 FastSeedance 2.5Kling O3 ProGemini Omni Flash 1.1MiniMax H3 MaxGemini Omni Flash - ReferenceMiniMax H3 Max - Reference
Make a long video from many clips (sequence)long-videoUse when the user wants a video longer than one clip (30 s to a few minutes) — a short film, story, explainer or music-style montage built from ordered clips joined into a Sequence.Seedance 2.0Seedance 2.5Seedance 2.0 FastGPT Image 2.5 SunburstGPT Image 2.5 Flare
Write MiniMax H3 / Hailuo video prompts for ReelMeminimax-promptingUse when a ReelMe video node runs a MiniMax row (H3 Max, H3 Max - Reference, H3 Max Turbo, Hailuo 2.3 / 2.3 Fast) — how to name the wired files, label shots, write dialogue, timing and music, and the H3 film path (which row, the multi-shot recipe, what H3 does to timing, hitting an original's cuts).MiniMax H3 Max - ReferenceMiniMax H3 MaxMiniMax H3 MaxMiniMax H3 Max TurboMiniMax H3 Max TurboMiniMax Hailuo 2.3MiniMax Hailuo 2.3MiniMax Hailuo 2.3 Fast
Make a cinematic product adproduct-adUse for the "Product Ad" chip and any polished, commercial-style product video (hero reveal, feature in action, closing hero frame) from the user's product photo. Picks a content type (TVC by default), one price card, no questions.GPT Image 2.5 SunburstGPT Image 2.5 FlareGrok Image v2Seedance 2.0Seedance 2.5Kling O3 Pro
Turn an idea into a shot-by-shot script on the canvasscript-writerUse first when the user has an idea, topic or product but no script — write the beat sheet, dialogue/voice lines and per-shot durations, put it in a Script text node, and lay out one node per shot.
Write video prompts for ReelMe (Seedance structure)seedance-promptingUse whenever you write or fix the prompt of a ReelMe video node — text-to-video or image-to-video, single shot or multi-shot, with or without native audio.Seedance 2.0Seedance 2.0 FastSeedance 2.0 MiniSeedance 2.5Kling O3 ProGemini Omni Flash 1.1MiniMax H3 Max
Make a vertical short-drama episode (hook, conflict, twist, cliffhanger)short-dramaUse for the "Short drama" chip and any micro-drama / short drama / vertical series episode — two characters in conflict, an immediate hook, an emotional twist, a cliffhanger. Builds the whole episode with dialogue on Seedance 2.5 scene mode. One price card, no questions.GPT Image 2.5 SunburstGPT Image 2.5 FlareGrok Image v2Seedance 2.5
Plan the whole film first, then review every stagestory-directorMUST READ for any film, story or multi-scene ad before the first keyframe — the plan ReelMe holds you to (a story with a beat map in seconds, cast / place / style cards, a scene card per scene, in set_script) and the review after the plan, the keyframes and the joined draft (review_stage). No keyframe or clip is priced before them.
Keep characters, products and places consistent across shotsstoryboard-consistencyUse when a story, ad or film has more than one shot with the same person, product or location — build anchor nodes, wire them into every shot, and lock identity in the prompts.GPT Image 2.5 SunburstGPT Image 2.5 FlareSeedance 2.0
Storyboard an idea as keyframes (up to 8 frames, one consistent look)storyboardUse for the "Storyboard" chip and whenever the user wants a storyboard, shot list or set of keyframes for an idea before any video — one line + a frame count → a shot list and N consistent keyframes on the canvas, ready to turn into clips. No video runs. One price card, no questions.GPT Image 2.5 SunburstGPT Image 2.5 FlareGrok Image v2
Make a UGC ad (a real creator filming on a phone)ugc-adUse for the "UGC Ad" chip and any TikTok / Reels / Shorts ad that should look filmed by a real person on a phone — selfie talk, unboxing, routine, reaction, before/after — featuring the user's product. One price card, no questions.GPT Image 2.5 SunburstGPT Image 2.5 FlareSeedance 2.0Seedance 2.5
Director Kit + Lens Combo — every pick iddirector-kitEvery valid id of each Director Kit and Lens Combo group (size, angle, move, light, color, stock, look, camera, lens, focal length, aperture, style packs…), read off ReelMe's preset catalog — the ids presets {group: id} and a Script shot's size / move take; a section gives a group's words.

Every canvas model, insideClaude

The image and video models of the ReelMe canvas, picked per node by your AI.

GPT Image 2.5 SunburstImage
GPT Image 2.5 FlareImage
Grok Image v2Image
Nano Banana 2.1Image
GPT Image 2Image
Nano Banana 2Image
Seedream V5 ProImage
Nano Banana ProImage
Seedream 4.5Image
Flux 2 ProImage
Seedream 5.0 LiteImage
Seedance 2.5Video
MiniMax H3 MaxVideo
Gemini Omni Flash 1.1Video
Seedance 2.0Video
Kling O3 ProVideo
Seedance 2.0 FastVideo
MiniMax H3 Max TurboVideo
Seedance 2.0 MiniVideo
MiniMax Hailuo 2.3Video
MiniMax Hailuo 2.3 FastVideo
MiniMax H3 Max Lip SyncVideo
ReelMe GenjutsuVideo

Add manually

Claude: what to put in each field. Keep the defaults unless you have a reason.

WhereCustomize → Connectors → Add custom connector
Namereelme
Remote MCP server URLhttps://reelme.ai/api/mcp
AuthenticationSign in now (detected) — or Sign in when needed
OAuth clientClaude's published identity (detected) — leave as is
Own OAuth client (only if you pick it)Client ID reelme-claude · Client secret empty
TransportStreamable HTTP

Keep the defaults: Sign in now + Claude's published identity + Streamable HTTP. "No sign-in" can't work: ReelMe always needs your account. SSE isn't supported.

Fewer "Allow?" prompts

WhereCustomize → Connectors → reelme → Tool permissions
Read-only toolsAlways allow
Write/delete toolsAlways allow the canvas edits; keep Needs approval on enhance_prompt, run_confirmed, run_workflow, check_images, render_sequence, run_node_tool, delete_node
In the chatOr pick "Always allow" the first time Claude asks for a tool

On Team / Enterprise plans an owner may need to turn on "Allow 'Always allow' for connector tools" first.

Troubleshooting

I pasted the page URL (…/mcp) or just the siteIt works: ReelMe answers MCP on those too. The standard URL ends in /api/mcp.
"Sign-in doesn't work on this address"You used http:// or 127.0.0.1. Use the https URL shown above (locally https://localhost:3000/api/mcp).
"Unknown OAuth client ID"Clear the OAuth client ID / secret fields in your app (or use reelme-claude / reelme-chatgpt / reelme-codex, no secret).
The app says sign-in is required / 401Set authentication to OAuth / Sign in — ReelMe has no no-auth mode.
"Use Streamable HTTP" / connection fails on SSEPick Streamable HTTP (or http) as the transport.
It worked yesterday, now asks to sign inYour ReelMe session ended (sign-in expired, account changed or the server key rotated): connect again and press Allow.
Signing out of the ReelMe websiteDoesn't disconnect your AI app — it has its own session. To disconnect, remove ReelMe from the app's connectors.
ChatGPT has no "Apps & Connectors" or Developer modeChatGPT calls them Plugins now: add ReelMe at chatgpt.com/plugins → Add ▾ (Upload plugin archive or Create MCP App); set its permissions in chatgpt.com/settings/plugins-settings.
ChatGPT keeps asking "Allow?"In chatgpt.com/settings/plugins-settings set Default permission to "Allow low-risk tools", or change ReelMe's own permission.
ChatGPT rejects the iconIt takes a PNG up to 10 KB: use /icons/mcp-chatgpt-256.png, or leave the icon empty.
Out of creditsYour AI shows a Top up link that opens ReelMe's paywall on your canvas.

What your AI can do

The tools ReelMe hands your AI app — the same canvas actions Canvas Agent uses in the app.

Read · free

List skillslist_skillsPlaybooks for jobs on ReelMe (script writing, product ads, image→video, long videos…): name, title, when to use, models. Read one with get_skill before starting that job.
Read a skillget_skillThe playbook for one skill from list_skills — model choice, prompt patterns and the tool steps. A long one lists its sections; read one with section (its id).
How to build on ReelMeget_workflow_instructionsCall first: how to lay out a storyboard on a ReelMe canvas with these tools — the order to call them in, and how paid runs and credits work.
What ReelMe can doget_capabilitiesCall when the user asks what ReelMe / this connector can do, or right after connecting: the features by group with things to try, the user's credits and latest canvas, and suggested next steps.
Who am I signed in aswhoamiThe ReelMe account this connection acts for (name, email).
List canvaseslist_canvasesThe user's ReelMe canvases (storyboards), newest first. Each has a canvasId used by every other tool.
Read a canvasget_canvasNodes (id, kind image|video|audio|text, name, prompt, model, status, refs = ids wired into it, previewUrl of its result) and wires of one canvas, plus its rev. On a film board, `film` (first): its steps, what to do next, what is blocked, done — a film is finished only when done is true. Read this before editing. A whole board can be 100+ KB: only: "film" = the film's state alone, only: "nodes" = one short line of facts per node (no prompts, no wires); nodeIds (and fields) = a few nodes; read_node gives one node's long words whole. E.g. {canvasId, only: "film"}.
List models and priceslist_modelsModels an image, video or audio node can use (the ids set_model takes), with the credits one output costs at the catalog's default settings. That is NOT what a node will cost (its own resolution / duration / audio change the price), and each row is priced at ITS OWN defaults (priceAt): a row that looks dearer may just default to a longer or higher-resolution output, so compare rows only at the same settings. Never quote or estimate a total from these — price with quote_run or the run_workflow plan. Video: create models (modes t2v / i2v; i2vInput "frames" = start + end frame, "references" = up to maxImages), and the Edit Video / Motion Control models (modes edit / motion — a video wired into the node; set_model with that mode). Edit rows say the source clip length they take (sourceSeconds), how many reference images, and whether the output follows the clip. Audio: voice-over (group speech), music, sound effects, and sound made for a wired video; each row lists its settings, its text limit (maxChars) and its voices; the price depends on the text length (voice-over) or the length asked.
Director Kit presetslist_presetsThe canvas's Director Kit and Lens Combo — the preset buttons on image / video nodes. Without group: every group (genre, setting, time, size, angle, move, light, color, look, palette, tempo…; Lens Combo camera, lens, focalLength, aperture) with its ids only. With group: those groups' ids, the exact words each adds to the prompt when the node runs, and which picks can't go together. Set them with add_node / update_node presets {group: id}; suggest_settings says which ones a prompt asks for. Free. E.g. {group: ["move", "size"], kind: "video"}.
Suggest settings for a promptsuggest_settingsWhat a prompt asks for, as the canvas's live suggestion chips show it while the user types: Director Kit presets ({group: id}) and model settings — sound on for a spoken line / voice / music, a 9:16 / 16:9 / 1:1 frame, a length in seconds. Rules on the words, free, nothing is changed. With canvasId + nodeId: that node's prompt (or `prompt`), only what it doesn't hold yet and only settings its model sells. Apply with update_node presets / selection.
Plan a job (graph, model, price)plan_jobRead-only. Ranks 1–3 ways to do a job (goal clone_swap | ugc_ad | product_ad) from the real model limits and catalog: each option has its node graph, model, the credits one output costs at the node's default settings (pricedAt says which: an Edit node's length is its own setting), why it fits and what is weak; models that don't fit say why (whyNot). clone_swap weighs an Edit of the source, the MiniMax H3 Reference route (the source's pieces as video references + the character images) and the H3 start / end-frame route (keyframes per shot); a source longer than a model takes is split into pieces that model accepts (pieces: how many, each up to how long). clone_swap needs sourceSeconds (the source clip's length) and refs (character images). Call it BEFORE building when the user asks which model / how much / how to swap or remake. Prices are estimates: only quote_run on the built nodes gives the confirmable total. Charges nothing, writes nothing; asking twice gives the same answer. E.g. {goal: "clone_swap", sourceSeconds: 60.7, refs: 3}.
Look at a node's pictureview_nodeSEE a node's picture yourself — free, charges nothing, no describe run. Returns the image of up to 4 nodes (an image node's picture; a generated video: ONE strip of 3 frames — start | middle | end — with its real length, whether it has an audio track and whether that sound is heard, measured from the file) as images you can look at, shrunk to ≤ 1280 px. Say a clip is done / has sound only as these facts say. Use it BEFORE describe / analysis (those cost credits): look first to check identity, framing, text, hands; run describe / analysis only when you need the picture written out. Audio and empty nodes have nothing to see (the answer says why). A video with no poster has nothing to see: cut a frame with run_node_tool capture (free, runs on the server) or see its frames with view_frames (free), then view the new image node; or use describe / analysis (they cost credits: ask first). Only nodes of the given canvas.
See a video's frames on one sheetview_framesSEE many frames of a video node at once — free. ONE contact sheet (left to right, then down) of up to 36 frames: at the seconds you name (at), one every N seconds (every), or one per shot on its real cuts (cuts: true — the cuts are listed too; sensitivity "high" also finds shots under 0.25 s, whips and same-framing cuts, and may take a fast action beat for one). For a remake, a check of continuity, or what happens between view_node's 3 stills.
Read a node's wordsread_nodeREAD a node's words a page at a time — free: a text node (a long Analysis breakdown, a Script, a note) or a media node's prompt, from offset, limit characters (default 6000); the answer says the offset to read on from. get_canvas and view_node cut long text short.
Credit balanceget_balanceThe user's ReelMe credit balance.
Credits and planget_plansThe user's ReelMe credit balance, their plan (or none), and — with neededCredits — how far a job is short. Shows a card with ReelMe's own Top up credits / See plans buttons. Call it when a tool answers no_credit or the user has no plan. Plan tiers and prices are only on ReelMe's pricing page: never invent them.
What this canvas costget_spendThe credits ReelMe actually charged on a canvas for this app's runs (generations, renders, node tools, clip checks), run by run as each was charged; failed runs are refunded and left out. Nothing is priced or charged here. Use it when the user asks what the work cost so far — not the quotes.
Run statusget_run_statusStatus of ONE run started by run_confirmed / run_node_tool: processing, success, failed (refunded or not) or hung, with startedAt (and finishedAt) in server time. When it has finished, the result is written onto its node (previewUrl). `charged` = the credits ReelMe kept for it (0 once refunded; `refundedCoin` = what came back). allDone is about the whole canvas: false while any other run on it still generates. For several runs, get_canvas_status — never this tool in a loop.
What is generating on a canvasget_canvas_statusONE status call for the whole canvas, as ReelMe's own run list has it: every run started on the canvas since your last call (none left out) with its final state — success, failed (refunded or not), still processing, or hung (running far past its usual time: what happens to its credits is said) — startedAt / finishedAt in server time, plus the workflow and the Sequence render. A finished run's result is written onto its node here if it was not yet. Free, not counted in the 60-calls-a-minute limit. Call it when you need a result, not to watch: keep working on other steps meanwhile. waitSeconds holds the answer (up to 600 s; many apps cut a call near 60 s — then 45): until "all" (default) = until nothing is generating, "any" = back as soon as any run finishes. allDone = nothing on the canvas is processing (hung runs included). E.g. {canvasId, waitSeconds: 280, until: "any"}.
List canvas templateslist_templatesReady-made ReelMe storyboards (the /canvas Templates tab): key, title, type, thumbnail. Open one with use_template.
Check the filmcheck_filmFree preflight of a canvas: every node not made yet (or `nodeIds` / groups), each with ALL its problems at once — the film's gates (wires, keyframes, the Script's lines and moves, picks), the lint on the prompt it would send, its price — the same checks quote_run refuses with. Run it after building a film and before quoting; fix everything it lists in one pass. Once a draft is joined it adds a RHYTHM section (the edit pass): the target cut list — the original's Analysis, else the Script — against the Script's shots and the render's measured cuts: each shot's length, cuts more than 0.3 s off, the length's difference, missing / extra shots. On a film it ends with a DIRECTOR section: the plan's gaps and each stage's review due (review_stage) — the next stage waits for them. Nothing is charged. Compact: the nodes with problems or warnings, the rest counted; verbose: true lists every node with its prompt's sent length.
Workflow statusget_workflow_statusAdvance and report the canvas's workflow run: each step's state and result. get_canvas_status reports it too (with every run on the canvas) — check it when you need a result, never this tool in a loop.
Sequence render statusget_sequence_statusReport the canvas's sequence render (one run: rendering / done / failed). get_canvas_status reports it too — check it when you need the film, never this tool in a loop. When done it returns the joined video's previewUrl, also written onto its node.
Node toolslist_node_toolsThe canvas node toolbar's tools for one node (image: multiAngle, upscale, removeBg, faceSwap, sketch, crop, describe, stillClip (the picture held `seconds` as a silent clip — an end card, a title; on a film board give its `film`: {role: "clip", scene, cut: "endcard"}) · video: clip, edit, analysis, extractAudio (its sound as an mp3 audio node), addSound (a copy with AI sound), burnSubtitles (a rendered film with its subtitles burned into the picture, in a chosen style) · text: runText): which can run now, each one's live price in credits and its params. Every result is a NEW node wired from this one; nothing is charged here.

Edit the canvas · free

Create a canvascreate_canvasCreate a new, empty ReelMe canvas and return its canvasId and link.
Add a nodeadd_nodeAdd an image, video, audio or text node, in one change: `prompt` = its prompt (or set_prompt later), `refs` = nodes wired into it, `model` = a model id (else the default; an audio node needs one, list_models {kind: audio}) — set after the wires. Settings go on set_model after it. A field it doesn't take is refused, never dropped. Placed right of `after` (or of the board). `media` = an https URL to show an existing image/video in the node.
Set a promptset_promptSet the prompt of an image/video node, or the body (markdown) of a text node.
Set a node's modelset_modelPick the model of an image/video/audio node (an id from list_models; for audio {kind: audio}). Optional settings hints are matched to that model's options; ones it doesn't offer stay on Auto.
Wire two nodesconnectWire `from` into `to`: an image feeds another node as a reference (a video node with an image in runs Image to Video); a text node feeds its text as the prompt (into an audio node: the words it says); a video into an audio node = sound made for it; an audio node into a video that already has a file = put it on the video, into an EMPTY Seedance video node = an audio reference, into a Sequence = its soundtrack.
Apply several editsapply_batchUp to 20 add_node / set_prompt / set_model / connect / update_node calls saved as ONE change — use it to lay out a storyboard or re-set many nodes at once. Prefer it over the single edit tools, even for one or two edits: one tool to allow means fewer permission prompts for the user. Give add_node an "arguments.ref" label and point later calls at "@label". update_node here takes name, prompt, presets, film, emotions, shots, position and the video choices (a model or settings change: set_model in the batch). E.g. {canvasId, calls: [{name: "add_node", arguments: {kind: "image", ref: "kf1", name: "KF 1.1", prompt: "…"}}, {name: "connect", arguments: {from: "i_face", to: "@kf1"}}, {name: "update_node", arguments: {nodeId: "i_crop", name: "Mia — front view", film: {role: "character", name: "Mia", plate: "view", variant: "front", from: "i_sheet"}}}]}.
Update a nodeupdate_nodeRename, re-prompt, change the model or settings (selection: axis → value from quote_run / list_models; null = Auto), a video node's choices (mode, extendDirection, joinMode, joinAudio, firstFrame — the settings picked stay), its Director Kit / Lens Combo picks (presets), or move one node.
Write a film's Bible and Scriptset_scriptWrite (or rewrite) the film's Film Bible and / or Script as data — one node each, their text built from it. bible: the frame (aspect), each character's card word for word (cast; a speaker's voice and language too — their lines go out with them), the style card as picks (kit: laid on every frame and clip), the FORBIDDEN / GRADE / SOUND lines, screenDirection (the 180° line every clip keeps: who is screen-left / right, facing which way, a fixed landmark), whether it has a score; a scene's own screenDirection only where it differs. scenes: each with its shots — seconds from/to on the clip's clock, size / angle / move as Director Kit ids (list_presets), the action, every spoken line {who, words, emotion}. Clips are held to the Script's lines and moves. A film of 2+ scenes usually plans two signature moves (craneUp, craneDown, orbit, dollyZoom, aerial, whipPan…) — fewer is written and said, never refused (a remake keeps its source's camera). Up to 16 shots a scene. The plan comes first (get_skill story-director): bible.outline (the story + a beat map in seconds over the whole film), bible.places (an environment card per place), bible.style (camera, light, palette, texture) with grade, a voice + language on every speaker's card, and each scene's place + card {header, prose with its lines in quotes and @Name mentions, sfx, style} — no keyframe or clip is priced before the plan is whole and reviewed (review_stage).
Review a film stagereview_stageThe director's review of a film stage, written onto the board (one "Director's review" text node): the plan (Bible + Script), the keyframes, or the draft (its clips — before or after their join). Look first, fix what is off, then write what you found — logic (cause → effect, nothing missing or doubled), continuity (people, props, place, light, screen direction across the cuts), rhythm (lengths against the beat map; the draft: check_film's RHYTHM), physics (real-time speed, weight, gravity), story (against the outline; a remake: the original's Analysis) — and the concrete revisions you made (a scene rewritten, a frame retaken, a shot trimmed or moved), or why none. The next stage waits for it: keyframes for the plan's review, clips for the keyframes', a retake or final of a joined clip for the draft's. A review is of the stage as it is now: any change after it makes it stale and the stage is reviewed again. Free. E.g. {canvasId, stage: "plan", findings: {logic: "…", continuity: "…", rhythm: "…", physics: "…", story: "…"}, revisions: ["Scene 2: the call now comes before the drive (cause before effect)"]}.
Delete a nodedelete_nodeRemove a node and its wires from the canvas (a group's members stay); the answer lists what went. A node other nodes are wired from is NOT deleted — the answer names them (dependents): ask the user, then call again with force: true, or disconnect first. The user can undo from the open tab's history only while it's open; otherwise it's gone.
Remove a wiredisconnectRemove the wire from one node into another (the ✕ on a wire in the canvas): the target stops reading the source; both nodes stay.
Tidy the boardtidy_canvasAuto-arrange the board like the canvas's Tidy up: wired nodes in columns left to right by what feeds what, unwired ones in a grid below; groups move as one block. Give `nodeIds` (2+) to tidy only those, else every top-level node. Call it once at the end of a build so the user opens a readable board.
Group nodesgroup_nodesWrap 2+ nodes that belong together (one scene, one shot and its references) in a named group. They must share the same parent (or none); a group's frame grows to hold them.
Use this takeuse_takeOn a film board: make this finished picture (a keyframe; a person's plate, sheet or panel; a place's or a prop's view; the look) or clip the take the film uses. Its slot's other finished takes on the film go to the "Takes" group, it stands in the first one's place, and a node not made yet that one of them fed (or a panel not cut yet from one) reads it instead. A clip already made keeps the picture it was made from until it is made again. With `film`: a picture picked from the board for that role takes it, and the role's pictures go to "Takes" keeping theirs (so they can be used again). Free. Only when the user picked the take.
Keep as iskeep_as_isOn a film board: keep these finished pictures or clips as they are although what they were made from changed since (get_canvas film `changed` lists them and why) — they stop being out of date and nothing is made again. Free. Only when the user chose to keep them; to redo them instead, quote_run them (target "take": the old one stays as a take).
Share a canvasshare_canvasA view-only link to the canvas as it is now — the canvas's Share button: anyone with the link sees its nodes, wires, pictures, videos and prompts and can duplicate it into their own account; nobody can change this canvas through it. A snapshot: later changes don't reach an old link (share again for a new one). Free. Only when the user asks to share.
Start from a templateuse_templateLay a template's nodes on a new canvas (or to the right of `canvasId`'s board) — nothing runs, 0 credits. Returns the input slots to fill (upload_media into them), its brief, and a run_workflow hint.
Upload an image or videoupload_mediaPut an image, video or audio file (mp3 / wav / m4a / aac / ogg / flac) onto the canvas from an https URL (or small base64 ≤ 4 MB): uploaded to the user's ReelMe library, then shown in `nodeId` (e.g. a template slot or an empty node) or in a new node.
Accept a picture as checked by a personaccept_checkThe user — or you, with your written reason — looked at this finished image (or clip) and it is right: it counts as passing its check when what is made from it is priced — for this take only (a new take is checked afresh). Free. The checker's own verdict stays on the node for the record. Give the reason as what was seen, in plain words: the person reads it beside the picture — no tool names, no ids. Tell the user it was accepted and on whose word.
Stopcancel_runStop the canvas's workflow and its sequence render: steps not started yet don't start (like the Stop button), a planned join doesn't happen. A generation already running can't be stopped — ReelMe has no cancel — it finishes and is charged.

Generate · uses credits, only after you approve the price

Quote a generationquote_runPrice generating image/video nodes (at most 4 outputs in total). Returns the total in credits and a confirmToken, and shows a confirm card where the user can change prompt / model / settings. The user must have explicitly said yes to this total before you call run_confirmed (a multi-stage job: one run_workflow with joinNodeIds instead, so there is one quote). Nothing is charged here. A node that already has a result runs in a new node beside it (target "replace" overwrites it instead); a node still generating is refused as busy. Out of credits → the answer carries a paywallUrl to show the user. The answer is compact — confirmToken first, then per run its label, price and the prompt's sent length; verbose: true adds each run's models, settings and the whole prompt sent. E.g. {canvasId, runs: [{nodeId: "v_clip1"}, {nodeId: "v_clip2", selection: {resolution: "1080p"}}]}.
Magic promptenhance_promptThe node's ✨ Magic prompt: rewrite an image / video node's prompt into a model-ready one (one model call, its own template's price — no generation). It keeps every person, action, @ImageN reference and spoken line, follows the node's model rules and its Director Kit picks, and writes the result INTO the node's prompt (the user can Undo it on the canvas). Only when the user asks for it. Without confirmToken it returns the price and a confirmToken: get the user's yes, then call again with it (spends credits). The answer says what changed (changes) and any conflict with the picks; the node runs later with quote_run as usual.
Start a quoted generationrun_confirmedStart the runs of a quote the user approved (spends credits) — or of several (confirmTokens: quote_run and run_node_tool quotes, one call). Only call after the user explicitly said yes to each quote's total. Results land on their nodes by themselves: keep working on the steps that don't need them; when you need one, get_canvas_status {canvasId, waitSeconds, until: "any"} — one call for all of them. Never end the turn asking the user to say "continue". E.g. {confirmTokens: ["<token 1>", "<token 2>"]}.
Run the workflowrun_workflowRun a whole canvas (or `nodeIds` / groups) in wire order, like /canvas's Run workflow: mode "all" or "changed" (only steps whose input changed). Images not generated yet are priced and run before the videos they feed, so one plan covers keyframes + clips. Give `joinNodeIds` (2–8 clips, in order) to also join them into one video when they're done — priced into the same total (the Sequence Render row for that many clips); `nodeIds: []` with joinNodeIds of clips already made = the join alone. A step that already has a result runs in a new take beside it unless `target` is "replace". Without confirmToken it returns the plan — compact: confirmToken first, then each step's label, price and wave (verbose: true adds each step's models and settings) — show it and get ONE yes; call again with confirmToken to start. On a film, one card covers every wave: a step made from pictures the plan makes first waits for their picture check, which the run asks for itself as each lands — priced on the card as its own line — and a picture that fails stops only what is made from it (get_canvas_status says each check); nothing to approve between waves. The approved chain then runs by itself on ReelMe (no polling needed): keep working on what doesn't need its results, and check get_canvas_status {canvasId} when you need one — or end the turn saying it keeps running. E.g. {canvasId, nodeIds: ["i_kf1", "v_clip1"], joinNodeIds: ["v_clip1", "v_clip2"]}.
Check a film's picturescheck_imagesThe picture checker on a film board's keyframes and references (plates, sheets, panels, places, props): each scored against its prompt and the Film Bible's card; a reference or keyframe that has not passed is not priced into what is made from it. Reading the board never runs it. Without confirmToken: the images it would check and the price — one model call each, its price × their number — show the user and get a yes; then call again with confirmToken. No nodeIds = every made image with no check standing (a check made against a Bible card rewritten since no longer stands); nodeIds = those, asked again even when a check stands (a verdict you think is wrong); a made clip named is checked too (its frame, lines and camera move, as get_run_status {check}) unless its take's check stands.
Render a sequencerender_sequenceJoin generated videos into one video, like the canvas's Sequence Render: ONE server run (trims, joins, mixes the audio) priced by its template's price row for this many clips and audio — at most 8 clips and 3 audio. A clip in another frame is cropped to fill the first clip's frame (a portrait clip after a landscape one loses its top and bottom). Audio nodes with a file wired into the Sequence (or given in `audio`, each with its start second) are laid over the film, mixed with the clips' sound (muteClips: only the audio plays). Levels are set by the render: music sits well under the clips' dialogue and carries the film when the clips have no sound, a voice-over sits at dialogue level, and the whole film is normalised to -14 LUFS (-1 dBTP) with a fade out over its last 1.5 s (fadeOut sets it; 0 = none). The quote says each laid track's level against the clips' sound, measured from the files, and where one is not heard. `cut` = an edit list: entries in order, a clip any number of times, each with its own start / end (put a remake's cuts back on a clip that runs several shots). More than 8 clips: render parts of up to 8 with fadeOut: 0, then a Sequence of the parts — the film fades only at its real end. `watermark` lays a logo in a corner (the ReelMe logo, or an image node's picture). `gainDb` on an audio item moves that track up or down from its level (e.g. -4 when the user finds the music too loud). Give `nodeIds` (2 or more generated videos, in order) to create the Sequence node, or `sequenceId` for an existing one. Without confirmToken it returns the total in credits and a confirmToken — it needs the user's explicit yes to this total; call again with confirmToken to start (spends credits). It then renders by itself on ReelMe (3–8 min); the video's previewUrl is written onto the Sequence node — check get_canvas_status {canvasId} when you need it. Out of credits → the answer carries a paywallUrl.
Run a node toolrun_node_toolRun one toolbar tool on a node (tool + params from list_node_tools). Crop and capture are free and run at once; a crop can be named and given its film role in the same call (params name, film). Every other tool: without confirmToken it returns the price and a confirmToken — show the price, get the user's explicit yes, then call again with the SAME params and confirmToken (spends credits). The result lands in a new node wired from the original by itself (get_canvas_status reports it). Out of credits → no_credit (call get_plans). E.g. {canvasId, nodeId: "i_sheet", tool: "crop", params: {rect: {x: 0, y: 0, w: 0.25, h: 1}, name: "Mia — front view", film: {role: "character", name: "Mia", plate: "view", variant: "front", from: "i_sheet"}}}; {canvasId, nodeId: "v_source", tool: "analysis"}.

Please rotate your device

This app works best in portrait mode.