MCP.so
Sign In

Veltake Studio MCP ServerVerifiedFeatured

@Veltake AI

Basic information

Transport

Streamable HTTP

Authentication

OAuth

Category

Media & Design

Author

Veltake AI

Submitted by

Veltake

About Veltake Studio MCP Server

Drive Veltake Studio from any AI agent: create film and ad projects, have the Studio agent build scenes on the canvas, price and start renders, export edited cuts, and make single images, video, speech and music in one call. OAuth 2.1 sign-in; every paid call runs only at the price it was quoted.

Connection details

https://veltake.ai/v1/mcp

Setup

claude mcp add veltake --transport http https://veltake.ai/v1/mcp

Veltake Studio MCP Server tools

40

List the account's Studio projects (film and marketing), newest first, with their ids.

Create a Studio project (with one empty canvas) and answer its id and canvas id.

Read one project: its canvases, scenes and shots, cast, and the agent conversations on it.

Open a conversation with the Studio agent on a project's canvas. Answers the chat id.

Send a message to the Studio agent and wait (up to ~45s) for its answer. The agent builds on a working copy and answers with a PROPOSAL (apply it with apply_turn), a question, a priced plan (answer with plan_approved:true to build it), or a run request with its price. If the turn is still working when the wait ends, poll get_turn.

Read a turn: its status (running | waiting | done | failed | canceled), the agent's reply (its final answer), the steps it took (kind "call" carries `tool`; kind "say" is a step where the agent only spoke and has no `tool`; either may carry `say`, what the agent said on the way), its proposal, estimate, question, plan and what it changed.

Apply a turn's proposed canvas. With run:true also start the run the agent asked for — this SPENDS coins; pass expected_total (the turn's estimate.total_coins) so the charge cannot differ from the quote. The agent reviews the results when the run finishes. A turn's cut_proposal (a large cut edit held for review) is applied separately, with cut_only:true.

Stop a running turn (its work so far is kept) or cancel a waiting turn's review.

Read a canvas run: status, cost, and each node's state, model and result URLs.

List the agent conversations on a project (yours, and any a teammate shared), newest first, without their transcripts.

Read one conversation with its transcript: each turn's message, status, reply and what it proposed or changed.

Revert what a turn changed OUTSIDE the canvas — cuts it created or edited, voiceovers or music it placed, notes it wrote, shots it filed — each only while it is still what the agent wrote. A canvas proposal never lands without apply_turn, so it needs no undo.

Ask again: regenerate the conversation's LATEST message (omit message), or replace its words (message) and let the agent answer the edit. The old answer is kept as an earlier version and stops being part of the conversation. Only your own message, only the latest one, never while it is running; refused while what it changed outside the canvas is still in place — undo_turn it (and its reviews) first. Waits like send_message.

Hand the agent a message WHILE a turn is running ("no, use the other character"): it reads it at its next step instead of finishing the wrong work first. Only a running turn of a conversation you can message; once the turn has ended (or already has messages waiting) it is refused — send it with send_message as the next message instead. Answers how many of your messages the turn has not read yet; get_turn shows the rest. Repeat message_id on a retry so the message lands once. Omitted, it is derived from you, the turn and the words — so the same words sent twice are ONE message (already_received:true says a message was not queued again); pass your own message_id to send a deliberate repeat.

List a project's cuts (edited films), each with its length, clip count and newest export.

Read one cut: its full timeline document (clips, voiceovers, music, captions, aspect ratio) and version. A clip's source is a take, a text card, or an upload (the person's own footage, by url); `takes` and `uploads` carry the media behind them, and a clip missing from both has no usable media.

Queue a render of a cut to a video file — one export per aspect ratio. Rendering spends no coins; the quality rungs and formats the account allows, and a daily export allowance, apply. Poll get_export for the file.

Read an export: status, and when done the film's URL, frame size and frame rate.

Price running a canvas (free, spends nothing): the total in coins, who pays (payer: personal, or team — a team project's runs are always paid from its team's pool), that payer's balance, each node's price and model, and the canvas version the price is for. Pass the total and the version to start_run.

Start rendering a canvas. This SPENDS the user's coins: pass expected_total and version exactly as estimate_run answered them — if the canvas or its price changed since, the run is refused and nothing is spent. Poll get_run.

List the models that make one kind of creation — image, video, speech or music. Each has its id, name and maker, what it accepts (aspect ratios, resolutions, durations, audio, reference images, voices, lengths) and what a default generation costs in coins; the coin balance comes too. Pass a model's id to estimate_generation and generate.

Price a generation without making it. Free, changes nothing. Takes the same arguments as generate (without expected_cost) and answers the coins it would cost, the coin balance and the settings that price is for (resolution, duration, audio). Every check generate makes runs here too, so a refused request is found before the person is asked anything. Pass the answered coins to generate as expected_cost.

Make an image, a video, a spoken script or a song. This SPENDS the user's coins: pass expected_cost exactly as estimate_generation answered it — if the price changed, nothing is charged and the new price is answered. The charge is a reservation of at most that number: a failed or canceled generation is refunded in full and the settlement may return part of it. Every call is paid in coins — a Relax queue or an unlimited allowance does not apply through an agent, and nothing here buys coins. Media (images, last_frame, reference_video, reference_audio) must be hosted: a URL import_media answered, or one on Veltake's own media host — import anything else first. Answers the generation (music answers its two takes); poll get_generation for the result. Repeat idempotency_key on a retry so it answers the first generation instead of charging again.

Read one generation made with generate (or in the app's Create): its status (queued, in_progress, succeeded, failed, canceled), progress, and once it has succeeded the result URL, preview image, size and length. Music answers one take per call; the take_group ties the two.

List the account's Create generations, newest first (logos and Studio takes are not listed here). limit defaults to 20, at most 50; next_offset pages on.

Bring a file into the account's uploads and answer a hosted URL to pass to generate (images, last_frame, reference_video, reference_audio), to upscale, or to a Studio send_message as an attachment. Give either url — a DIRECT link to an image, video or audio file, not a web page — or file, a file the person attached in this conversation. The file is kept as a temporary upload.

Cancel a queued or running generation. The coins it held are returned in full; the provider is not told, so a result already on its way is discarded. A finished generation cannot be canceled.

Open Veltake's home for the person: a composer for images, videos, voice and music that shows each generation's price in coins before it is made, their recent work, and ready-made workflows. Use it when the person wants to browse, pick a model or settings themselves, or start from a workflow. Takes no arguments; kind and prompt optionally pre-fill the composer. The answer is a short summary for you — the home itself is shown to the person.

Show the person the generations of the last 24 hours, live, each one playable. Use it when they ask what is running or what was just made. Takes no arguments.

Price upscaling an image or a video (a sharper, larger copy of a file the person already has). Free, changes nothing. The price comes from the file itself — its size and, for a video, its length and frame rate — so it reads the file first. Answers the coins, the balance, the output size and the targets the upscaler offers. Pass the answered coins to upscale as expected_cost. The file must be hosted: import_media first.

Upscale an image or a video. This SPENDS the user's coins: pass expected_cost exactly as estimate_upscale answered it for these arguments — if the price changed, nothing is charged and the new price is answered. A failed or canceled upscale is refunded in full. Answers the generation; poll get_generation for the result. Repeat idempotency_key on a retry.

For the Veltake app's own screens only — not for a conversation. Answers the home: balance, recent work, workflows.

For the Veltake app's own screens only — not for a conversation. Answers list_models for one kind with the picker's extra fields (logo, badge, a one-line summary, the default).

For the Veltake app's own screens only — not for a conversation. estimate_generation for the composer's settings.

For the Veltake app's own screens only — not for a conversation. generate from the composer: this SPENDS the user's coins at expected_cost, the number on the button the person pressed.

For the Veltake app's own screens only — not for a conversation. list_generations with posters for the grid.

For the Veltake app's own screens only — not for a conversation. import_media for a file the person picked in the app.

For the Veltake app's own screens only — not for a conversation. estimate_upscale for the app's Upscale card.

For the Veltake app's own screens only — not for a conversation. Read-only: did the idempotency_key of an unconfirmed app_generate / app_upscale create a generation for this person? Never spends, never retries.

For the Veltake app's own screens only — not for a conversation. upscale from the app: this SPENDS the user's coins at expected_cost, the number on the button the person pressed.

Overview

What is Veltake Studio?

Veltake Studio is an AI film and ad production canvas with its own agent. This remote MCP server lets any MCP client (ChatGPT, Claude, Claude Code, Cursor, Codex, VS Code and others) work in your Veltake projects: create a project, ask the Studio agent to build scenes and shots on the canvas, price and start renders, and export the edited cut. The same server also makes single images, videos, speech and music, one call each, with no project needed.

How to connect

Server address: https://veltake.ai/v1/mcp (streamable HTTP). Sign in with OAuth 2.1 in the browser when your client asks; a client without OAuth can send a personal access token as a Bearer header.

  • Claude Code: claude mcp add --transport http veltake https://veltake.ai/v1/mcp, then /mcp → veltake → Authenticate
  • Cursor: add {"mcpServers": {"veltake": {"url": "https://veltake.ai/v1/mcp"}}} to ~/.cursor/mcp.json
  • Codex: codex mcp add veltake --url https://veltake.ai/v1/mcp
  • VS Code: code --add-mcp "{\"name\":\"veltake\",\"type\":\"http\",\"url\":\"https://veltake.ai/v1/mcp\"}"
  • ChatGPT / Claude: add https://veltake.ai/v1/mcp as a custom connector

Setup for every client: https://veltake.ai/mcp

Tools

  • Projects: list_projects, create_project, get_project
  • The Studio agent: start_chat, send_message, get_turn, apply_turn, stop_turn, retry_turn, interject_turn, undo_turn, list_chats, get_chat
  • Renders: estimate_run, start_run, get_run
  • Cuts and exports: list_cuts, get_cut, export_cut (up to four aspect ratios, h264 / hevc / prores), get_export
  • Media: import_media
  • Create (image, video, speech, music): list_models, estimate_generation, generate, get_generation, list_generations, cancel_generation, estimate_upscale, upscale
  • App (hosts that render MCP Apps): open_veltake, open_generation_tray

Guardrails

  • The quote is the charge. Every call that spends coins must repeat the exact total it was quoted; if the canvas or the price changed, nothing runs and nothing is spent. A failed generation is refunded.
  • Least privilege. Scopes form a ladder (studio:read < studio:write < studio:spend), and you can grant a lower rung on the consent page.
  • You stay in control. An agent acts as your account under the same rules as you. It cannot see your password, change account settings or buy coins, and every connected app can be removed at once in Settings.

Connecting, reading and pricing are free.

Full reference: https://veltake.ai/llms-mcp.txt

Frequently asked questions

1

What is the Veltake Studio remote MCP server?

The Veltake Studio remote MCP server is a hosted Model Context Protocol endpoint at https://veltake.ai/v1/mcp, so AI assistants can connect to it without installing or running anything locally.

2

How do I connect to the Veltake Studio MCP server?

Add the endpoint https://veltake.ai/v1/mcp to any MCP-compatible client such as Claude Code, Cursor, or VS Code. The setup snippets on this page configure each client in one step.

3

Does the Veltake Studio MCP server require authentication?

Yes. Veltake Studio uses OAuth: the first time you connect, your MCP client opens a browser window to sign in and authorize access, then reuses the credentials for future sessions.

4

Which transport does the Veltake Studio MCP server use?

Veltake Studio exposes a Streamable HTTP endpoint, the transport used by remote MCP servers and supported by all major MCP clients.

Comments