← Home
SETUP

By Valmera Editorial · Published · Updated

Connect your assistant → Set up ChatGPT, Grok, Codex, Claude or Cursor and check your connection in one place.

Add Valmera as an MCP Server

One endpoint, every client. Valmera is a remote Model Context Protocol server over streamable HTTP with OAuth 2.1, so in most clients the entire configuration is a URL and a sign-in. Below is the exact config location and the literal JSON or command for each one, plus what the first call does once you are connected.

Each entry shows the date its client's own documentation was last checked.

THE ENDPOINT
https://valmera.io/mcp/server

Streamable HTTP · OAuth 2.1 with dynamic client registration and PKCE · a bearer-token path for clients without OAuth · 143 tools (live server card, October 2026)

JUMP TO YOUR CLIENT

Claude (claude.ai, Claude Desktop, mobile)ChatGPTClaude CodeCodex (CLI and IDE extension)CursorVS Code (GitHub Copilot)ClineWindsurf (Cascade)ZedContinueGooseLibreChatMCP InspectorGemini CLIAnything stdio-only

Before You Start

You need a Valmera account. Sign up with email or Google; creating an account and uploading are free, and editing requires a subscription. Two things are worth knowing before you paste anything.

MCP access is included with eligible Valmera subscriptions. See the plans at /subscribe. Your account's access is checked on every request.

Google sign-in works with your existing Valmera session. The consent page uses your normal Valmera sign-in, Google included: sign in with the account you subscribed with, then choose Allow connection. No separate password is needed.

How to Add Valmera to Any MCP Client

  1. 1
    Find your client's MCP config
    Most clients keep a JSON or YAML file with a map of servers. The key is mcpServers in Cursor, Cline, Claude Code and LibreChat; servers in VS Code; context_servers in Zed; extensions in Goose. Several also have a UI that writes the file for you, which is the safer path the first time.
  2. 2
    Add the endpoint as a remote streamable-HTTP server
    The entry is the URL https://valmera.io/mcp/server plus, in some clients, an explicit transport type — http in VS Code and Claude Code, streamable-http in Continue and LibreChat, streamableHttp in Cline, streamable_http in Goose. Windsurf documents the field as serverUrl. ChatGPT and Claude take the URL in their own settings screens.
  3. 3
    Authenticate
    If the client supports OAuth, that is the whole of it: it reads the 401 challenge, discovers the authorization server, registers itself and opens a Valmera sign-in. There is no client id, secret or token to create. If it does not, paste a bearer token into the client's headers block instead.
  4. 4
    Confirm, then edit something
    Ask the model to list your Valmera projects. If it comes back with a list — or an honest empty one — the connection works. Then create a project, upload footage, wait for indexing, and describe the edit.

Setup is one paste and one sign-in in most clients. The first upload then needs a one-time analysis pass — transcript, silences, shot boundaries, frame tiles — which reports progress and is reused by every edit afterwards.

Every Client at a Glance

ClientConfig lives inAuthThe shape
Claude web / desktop / mobileCustomize → ConnectorsOAuthURL only
ChatGPTchatgpt.com/plugins → Create custom MCP serverOAuthURL only
Claude Code~/.claude.json or .mcp.jsonOAuth or bearerclaude mcp add --transport http
Codex~/.codex/config.tomlOAuth or bearercodex mcp add --url · codex mcp login
Cursor~/.cursor/mcp.json or .cursor/mcp.jsonOAuthmcpServers → url
VS Code (Copilot).vscode/mcp.jsonOAuthservers → type: http
Gemini CLI.gemini/settings.jsonOAuth or bearergemini mcp add --transport http
ClineRemote Servers tab or ~/.cline/mcp.jsonBearertype: streamableHttp
Windsurf~/.codeium/windsurf/mcp_config.jsonOAuth or bearerserverUrl · 100-tool cap
Zed~/.config/zed/settings.jsonOAuthcontext_servers → url
Continue.continue/config.yamlBearertype: streamable-http
Goose~/.config/goose/config.yamlOAuth or bearertype: streamable_http · uri
LibreChatlibrechat.yamlOAuth (DCR) or headerstype: streamable-http
MCP Inspectornpx, no installOAuth or --header--server-url --transport http
Anything stdio-onlyThat client's stdio configOAuth via the bridgenpx mcp-remote <endpoint>

The spread in that third column is the whole reason this page exists. Five clients spell the same transport five different ways, one renames the URL field, and one caps how many tools it will accept — none of which is discoverable from an error message.

The Configs

Claude (claude.ai, Claude Desktop, mobile)

Custom connector

CONFIG LOCATION

Customize → Connectors → + Add → Add custom connector

AUTH

OAuth — nothing to paste but the URL

Name it Valmera, paste the endpoint and continue. Claude reads the 401 challenge, discovers the authorization server and opens a Valmera sign-in and consent page. If Claude asks how it should identify itself (OAuth client), choose Register automatically: Valmera uses dynamic client registration, so there is no client ID or secret to create.

https://valmera.io/mcp/server
  • Custom connectors are available on Free, Pro, Max, Team and Enterprise. Free accounts are limited to one custom connector.
  • On Team and Enterprise, an Owner adds it from Organization settings → Connectors, and members click Connect under Customize → Connectors.
  • Once added, the connector works across claude.ai, Claude Desktop and the mobile apps. Turn it on per chat from + → Connectors.
  • Sign in with the email or Google account you subscribed with. Google accounts use the normal Valmera login; no separate password is needed.

Full Claude guide →

Checked 2026-10-06 against Anthropic's custom-connector help article.

ChatGPT

Custom MCP server

CONFIG LOCATION

chatgpt.com/plugins → + → Create custom MCP server

AUTH

OAuth — nothing to paste but the URL

Name it Valmera and paste the endpoint under Connection. Keep OAuth as the authentication, review the risk notice, select I understand and want to continue, then Create as a plugin. Sign in to Valmera when prompted. In a new chat, type @ and choose Valmera.

https://valmera.io/mcp/server
  • If the create option is missing, turn on Developer mode in Settings → Security and login. Availability depends on your ChatGPT plan and workspace policy.
  • ChatGPT caches the tool list. After Valmera adds tools, open the connection on chatgpt.com/plugins, select Refresh and start a new chat.
  • Files attached to a ChatGPT message don't reach Valmera. Upload in Studio, or paste a link for fetch_url to import.

Full ChatGPT guide →

Checked 2026-10-06 against OpenAI's connect-and-test guide for MCP servers.

Claude Code

CLI

CONFIG LOCATION

~/.claude.json (local/user scope) or .mcp.json at the repo root (project scope)

AUTH

OAuth, or a bearer token in a header

One command, then /mcp inside a session to complete the browser sign-in. Add --scope user to get it in every repo, or --scope project to write a committed .mcp.json your team inherits.

claude mcp add --transport http valmera \
  https://valmera.io/mcp/server
  • Confirm with claude mcp list — a working server reads ✔ Connected, ! Needs authentication means the sign-in has not completed, ✘ Failed to connect is transport or credentials.
  • For a static token instead: --header "Authorization: Bearer vlm_mcp_..." (-H is the short form).
  • Hand-editing .mcp.json: an entry with a url and no type is read as a stdio server and skipped. Keep "type": "http" — "streamable-http" is accepted as an alias.
  • Claude Code expands ${VAR} inside url and headers, so a committed .mcp.json can reference ${VALMERA_MCP_TOKEN} and keep the secret out of git.

Full Claude Code guide, with a session end to end →

Checked 2026-08-04 against code.claude.com/docs/en/mcp and used end to end with Valmera.

Codex (CLI and IDE extension)

CLI or config.toml

CONFIG LOCATION

~/.codex/config.toml (or .codex/config.toml in a trusted project)

AUTH

OAuth via codex mcp login, or a bearer token

Add the server, then run the login command; Codex opens the Valmera sign-in in your browser. In the IDE extension, open the gear menu → MCP servers → Add server, choose Streamable HTTP, paste the URL, restart the extension and select Authenticate.

codex mcp add valmera --url https://valmera.io/mcp/server
codex mcp login valmera

OR ADD THE TABLE TO ~/.CODEX/CONFIG.TOML BY HAND

[mcp_servers.valmera]
url = "https://valmera.io/mcp/server"
  • For a token instead of OAuth, add bearer_token_env_var = "VALMERA_MCP_TOKEN" to the same table and set that variable.
  • Codex has a shell, so it can upload local files with upload_start and upload_finish.

Checked 2026-10-06 against OpenAI's Codex MCP documentation.

Cursor

mcp.json

CONFIG LOCATION

~/.cursor/mcp.json (global) or .cursor/mcp.json (this project)

AUTH

OAuth — Cursor runs the flow itself

A remote server is a url entry. Cursor discovers the authorization server, registers itself and opens the Valmera sign-in — there is no client id, secret or token to fill in. You can also add and toggle servers from Customize in the sidebar.

{
  "mcpServers": {
    "valmera": {
      "url": "https://valmera.io/mcp/server"
    }
  }
}
  • One-click install: the Add to Cursor button on the connect page and the Cursor guide writes this entry for you.
  • Cursor's documented remote shape is url plus optional headers; it does not require a type field.
  • Cursor asks before running each MCP tool by default. Most of an edit is reading — look_at, get_words, project_state — so use a Run Mode with an allowlist or the session becomes a confirmation dialog.
  • Cursor's OAuth redirect URLs are fixed: https://www.cursor.com/agents/mcp/oauth/callback for web and agents, http://localhost:8787/callback on desktop. Both are already accepted by Valmera's dynamic registration.
  • MCP Logs in the Output panel (Cmd+Shift+U) separate an unreachable URL from a rejected sign-in.

Full Cursor guide, including the screen-recording tools →

Verified 2026-08-04 against cursor.com/docs/context/mcp.

VS Code (GitHub Copilot)

mcp.json

CONFIG LOCATION

.vscode/mcp.json in the workspace, or the user profile via MCP: Open User Configuration

AUTH

OAuth — VS Code opens a browser on first connect

VS Code's key is servers, not mcpServers — a config copied from another client's docs will not load. Run MCP: Add Server from the command palette to have it written for you, or paste this. MCP works in agent mode.

{
  "servers": {
    "valmera": {
      "type": "http",
      "url": "https://valmera.io/mcp/server"
    }
  }
}
  • MCP: List Servers shows status; MCP: Browse MCP Servers opens the gallery.
  • For a static token, add a headers object. Do not hardcode it — use the inputs array with ${input:valmera-token} and type promptString with password: true, so VS Code prompts and stores it instead of committing it.
  • An explicit oauth block with a clientId exists for servers that require a pre-registered client. Valmera does not — omit it and let VS Code register dynamically.

Checked 2026-08-04 against code.visualstudio.com's MCP server and MCP configuration reference docs.

Cline

Extension UI or JSON

CONFIG LOCATION

The MCP Servers icon → Remote Servers tab, or ~/.cline/mcp.json for the CLI

AUTH

Bearer token — no documented OAuth flow

Add it from the Remote Servers tab: a name, the URL, and Streamable HTTP as the transport. Cline's documented remote authentication is a header, so mint a Valmera bearer token first — see below. The type field is streamableHttp, camel-cased, which is Cline's own spelling.

{
  "mcpServers": {
    "valmera": {
      "type": "streamableHttp",
      "url": "https://valmera.io/mcp/server",
      "headers": {
        "Authorization": "Bearer vlm_mcp_..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}
  • Cline's docs describe header authentication and do not document an OAuth browser flow for remote servers. If you would rather not hold a token, wrap the endpoint in mcp-remote and add it as a stdio server instead.
  • autoApprove is a per-tool allowlist. Leave it empty until you know which calls you want unattended: renders and pixel repair are real compute.

Checked 2026-08-04 against docs.cline.bot.

Windsurf (Cascade)

mcp_config.json

CONFIG LOCATION

~/.codeium/windsurf/mcp_config.json

AUTH

OAuth is supported; a header also works

A remote server takes serverUrl (url is also accepted). Headers support ${env:VAR} and ${file:/path} interpolation, so the token stays out of the file.

{
  "mcpServers": {
    "valmera": {
      "serverUrl": "https://valmera.io/mcp/server",
      "headers": {
        "Authorization": "Bearer ${env:VALMERA_MCP_TOKEN}"
      }
    }
  }
}
  • Read this before you connect: Cascade uses at most 100 tools at a time across all servers, and Valmera exposes 143. List the tools you don't need in the server's disabledTools array in mcp_config.json. No other client on this page has that ceiling.
  • Windsurf supports OAuth for each transport type, so the headers block above is optional if the sign-in flow works for you.

Checked 2026-10-06 against Windsurf's Cascade MCP docs.

Zed

settings.json

CONFIG LOCATION

~/.config/zed/settings.json (macOS/Linux), %APPDATA%\Zed\settings.json (Windows)

AUTH

OAuth when no Authorization header is set

Zed calls MCP servers context servers. Settings → AI → MCP Servers → Add Server → Add Remote Server writes this for you. When a remote server has no configured Authorization header, Zed runs the standard MCP OAuth flow.

{
  "context_servers": {
    "valmera": {
      "url": "https://valmera.io/mcp/server"
    }
  }
}
  • Native remote-server support is recent. Older Zed builds had no url form at all and the workaround was mcp-remote as a stdio context server — if your settings file rejects url, that is the version you are on, and the fallback at the bottom of this page is the answer.
  • A headers object with Authorization: Bearer works if you would rather use a token.

Checked 2026-08-04 against zed.dev/docs/ai/mcp.

Continue

config.yaml

CONFIG LOCATION

.continue/config.yaml in the workspace, or a file under .continue/mcpServers/

AUTH

Bearer token — OAuth is not documented

The type is streamable-http, hyphenated and case-sensitive — streamableHttp and http are both rejected. Authentication goes in requestOptions.headers, which Continue documents for sse and streamable-http servers.

mcpServers:
  - name: valmera
    type: streamable-http
    url: https://valmera.io/mcp/server
    requestOptions:
      headers:
        Authorization: Bearer vlm_mcp_...
  • MCP is available in agent mode only.
  • Continue's config reference does not mention OAuth for MCP servers, so plan on a token.

Checked 2026-08-04 against docs.continue.dev.

Goose

config.yaml

CONFIG LOCATION

~/.config/goose/config.yaml (macOS/Linux), %APPDATA%\Block\goose\config\config.yaml (Windows)

AUTH

OAuth on a 401 challenge, or a header

Run goose configure → Add Extension → Remote Extension (Streaming HTTP), name it, and paste the endpoint as the URI. Use the interactive path for the first setup — it writes correct YAML — and hand-edit afterwards to change the timeout or add headers.

extensions:
  valmera:
    enabled: true
    type: streamable_http
    name: valmera
    description: Agentic video editor
    uri: https://valmera.io/mcp/server
    timeout: 60
  • Two spellings are Goose's alone: the key is uri where every other client uses url, and the type is streamable_http with an underscore.
  • Goose triggers OAuth when a server answers 401 with a WWW-Authenticate header, which is exactly what Valmera answers. Dynamic client registration is what makes that work without a client id.
  • Raise timeout above the default if you script long sequences; Valmera's own calls return within about 25 seconds regardless.

Checked 2026-08-04 against Goose's extension configuration docs.

LibreChat

librechat.yaml

CONFIG LOCATION

librechat.yaml, under a top-level mcpServers block

AUTH

OAuth with dynamic client registration, or headers

The simple form is a type, a url and a timeout in milliseconds. LibreChat is a multi-user server, so the interesting question is whose Valmera account gets used — see the second block.

mcpServers:
  valmera:
    type: streamable-http
    url: https://valmera.io/mcp/server
    timeout: 60000

PER-USER OAUTH INSTEAD OF A SHARED TOKEN

mcpServers:
  valmera:
    type: streamable-http
    url: https://valmera.io/mcp/server
    oauth:
      authorization_url: https://valmera.io/mcp/oauth/authorize
      token_url: https://valmera.io/mcp/oauth/token
      redirect_uri: http://localhost:3080/api/mcp/valmera/oauth/callback
  • Per-user identity is the right shape here. An oauth block with client_id and client_secret omitted makes LibreChat use dynamic client registration, so each of your users signs into their own Valmera account rather than sharing one.
  • The alternative — one bearer token in a static header — means every LibreChat user edits the same Valmera projects on one account. That is occasionally what you want and usually not.
  • customUserVars prompts each user for their own credential and interpolates it as {{VAR}} in headers, which is the middle path if you are issuing tokens yourself.

Checked 2026-08-04 against librechat.ai's mcp_servers reference. Endpoint paths are Valmera's own, from its authorization-server metadata.

MCP Inspector

Debugging tool

CONFIG LOCATION

Nothing to install — npx, Node 22.19.0 or newer

AUTH

Full OAuth, or --header

This is the one to reach for when a client will not connect and you need to know whose fault it is. The Inspector implements the whole authorization flow, so if it connects and lists Valmera's tools, the server is fine and the problem is the client's config.

npx @modelcontextprotocol/inspector \
  --server-url https://valmera.io/mcp/server --transport http
  • Add --cli for a scriptable client and --tui for a terminal UI; all three share the same OAuth state on disk.
  • List the tools without a browser step, once a token is stored: npx @modelcontextprotocol/inspector --cli --server-url <endpoint> --transport http --method tools/list
  • A static token instead of the browser flow: --header "Authorization: Bearer vlm_mcp_...", repeatable.
  • The CLI and TUI complete OAuth on http://127.0.0.1:6276/oauth/callback; the web client uses http://localhost:6274/oauth/callback. Both are accepted by Valmera's dynamic registration.
  • In CI, pass --stored-auth-only so it fails immediately instead of waiting for a callback nobody will complete.

Checked 2026-08-04 against the MCP Inspector docs.

Gemini CLI

CLI

CONFIG LOCATION

.gemini/settings.json in the project (the default), or ~/.gemini/settings.json with -s user

AUTH

OAuth via /mcp auth

Add the server with one command, then authenticate from inside Gemini CLI. These steps are for Gemini CLI, not the Gemini chat website.

gemini mcp add --transport http valmera https://valmera.io/mcp/server
# then, inside Gemini CLI:
/mcp auth valmera
  • For a token instead of OAuth, add --header "Authorization: Bearer vlm_mcp_..." to the add command.
  • Gemini CLI has a shell, so it can upload local files with upload_start and upload_finish.

Checked 2026-10-06 against the Gemini CLI MCP server docs.

Anything stdio-only: the mcp-remote Bridge

Some clients only know how to launch a local process and talk to it over stdin and stdout. That is not a reason to be locked out of a remote server. mcp-remote is a small npm package that runs as that local process, performs the OAuth flow in your browser, and proxies everything to the HTTP endpoint. To the client it looks like an ordinary stdio server.

{
  "mcpServers": {
    "valmera": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://valmera.io/mcp/server"]
    }
  }
}

Credentials are cached in ~/.mcp-auth, so the browser step happens once. Node 18 or higher is required. If you would rather carry a token than run the flow, the --header flag takes one — and the environment-variable form below is not a style preference. Some clients mangle arguments containing spaces, and Authorization: Bearer … contains one, so the package's own documentation recommends putting the value in env and referencing it:

{
  "mcpServers": {
    "valmera": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://valmera.io/mcp/server",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer vlm_mcp_..."
      }
    }
  }
}

To test the bridge on its own, before blaming your client: npx -p mcp-remote@latest mcp-remote-client https://valmera.io/mcp/server. Transport selection is --transport, which accepts http-first (the default), sse-first, http-only and sse-only; Valmera is streamable HTTP, so the default is right and http-only skips one probe.

Verified 2026-08-04 against the mcp-remote README. Use it when a client has no remote support at all — a client with native HTTP support should use it directly, since every bridge is another process that can fail.

The OAuth Flow: Nothing to Paste

Most instructions for connecting a service to an AI client start with "create an app, copy the client id, copy the secret&quot. There is none of that here, and the reason is worth understanding because it is also how you debug it when it fails.

  1. The client connects and is refused. The server answers 401 with a WWW-Authenticate header carrying a resource_metadata URL. That header is the entire entry point — a connector UI with no field to type a token can only find the authorization server by being told, here, where it lives.
  2. The client discovers the authorization server from /.well-known/oauth-protected-resource (RFC 9728), then reads /.well-known/oauth-authorization-server (RFC 8414) for the endpoints and supported grants.
  3. The client registers itself via dynamic client registration (RFC 7591), inventing its own client id on the spot and declaring the redirect URIs it will use. This is the step that removes the developer-portal detour. Registration accepts any https URI, plus http on localhost or 127.0.0.1 because desktop clients loop back to those — which covers Cursor's https://www.cursor.com/agents/mcp/oauth/callback and http://localhost:8787/callback, and the Inspector's http://127.0.0.1:6276/oauth/callback. No secret is issued: a client that cannot keep one is more honest as a public client with PKCE than as a confidential one whose secret ships inside an app.
  4. You sign in and consent in a browser window the client opens, with PKCE (S256) mandatory on the exchange.
  5. The code is exchanged for tokens and the original request is retried. Refresh tokens rotate, and replaying an authorization code revokes the whole grant rather than quietly issuing a second one.

Two details that decide how it feels day to day. Every project tool takes an explicit project ID, so after a reconnect the model picks up any project by its ID rather than guessing. And an unregistered redirect URI dead-ends on our own page instead of redirecting to it — a misconfigured client fails visibly, which is the behaviour you want from the one hop that carries an authorization code.

The Bearer Token Path

OAuth is the better path when there is a person and a browser. There often is not — a CI runner, a container, a client that never implemented the OAuth half of the spec. Cline and Continue are in that second category today. For those, the server accepts a static token on the standard header:

Authorization: Bearer vlm_mcp_...

A token is minted against your signed-in Valmera account and shown exactly once — it is stored only as a sha256 hash, so a lost token is replaced rather than recovered. Create and manage tokens on the connection page.

Both credential types resolve to the same session inside the server — who you are, and which project is open — so a token session and an OAuth session receive an identical tool registry and identical refusals. Nothing is degraded by choosing the simpler one.

Do not commit it. Every client here supports a way not to: ${VALMERA_MCP_TOKEN} in Claude Code, ${env:VALMERA_MCP_TOKEN} in Windsurf and Cursor, an inputs entry with password: true in VS Code, customUserVars in LibreChat, and an env block with mcp-remote. A token in a repo is a token in everyone's clone.

The First Call, in Order

A connected client has the full toolset and no context. The studio hands Valmera's own agent a project, an upload and an index for free; a headless model has to be handed all three. The order is not optional, and the server enforces it rather than letting a model guess.

1 · A project, first

list_projects shows what exists, open_project resumes one, create_project starts a new one. Every later project tool takes that project_id explicitly; the server never guesses from an "active" project, so a model can't edit the wrong video by accident.

2 · Footage, by presigned URL

MCP arguments are JSON, so video bytes never cross the protocol in either direction. upload_start returns a presigned URL and the literal command to PUT the file to it; upload_finish registers it. Files above 16 MiB upload multipart — one presigned URL per part, with the ETags passed back. A client with a shell runs that command itself, which is the practical difference between Claude Code, Codex or Cursor and a chat app; from a chat app, upload in Studio. fetch_url imports clips, music and images from a link. Limits: 100 GB and 3 hours, MP4, MOV, M4V, MKV or WebM.

3 · Indexing, once

index_status reports progress on the one-time analysis: a word-level transcript with speaker labels, every silence measured, shot boundaries detected, and labeled frame tiles the model reads directly. Until it finishes there are no real timings in existence, and no tool accepts a timestamp the model invented. Every later edit reuses this, which is why a request against a three-hour file is not three hours of work.

4 · Edit, render, look, hand off

The 129 editing tools write to an edit decision list, never to pixels. render_preview produces a fast proxy render, look_at hands the model real frames out of it so it can check its own work, and watch_video hands over the rendered MP4. When the edit is approved, export_final renders the full-resolution final from the original file for that project and version; poll wait_for_job, then download_url(kind="final") returns the link. Studio export also works. Your file is never modified and any cut can be restored.

The complete registry — every tool name, what it does and what it refuses — is the tool reference.

Slow Work Returns a Ticket: wait_for_job

A render is minutes of ffmpeg; an MCP tool call is a request. Something has to give, and what gives is the pretence that the call finished. Preview renders, pixel repainting and browser recording answer like this:

STILL RUNNING — render_preview is job 8814 (running, 12%). Nothing
has failed; call wait_for_job(job_id=8814) to pick the result up.

Every call returns within about 25 seconds. That bound is deliberate: clients put a first-byte timer on HTTP MCP servers — 60 seconds in Claude Code — so a tool that blocked for the length of a render would be killed by the client rather than finished by the server. wait_for_job is meant to be called in a loop. It waits a bounded time too and returns either the finished result or the same line at a higher percentage; there is no penalty for calling it repeatedly, and the job continues server-side whether or not anything is waiting on it.

From a script, poll the job you were given rather than calling the render again: export_final reuses an existing export or its running job, but a fresh render_preview is new work.

One Project, One Editor

If Valmera Studio is editing a project, an MCP edit on that same project is refused until the Studio work finishes, and Studio refuses to start an edit while an MCP edit is running. Two writers on one edit decision list would each read state the other is halfway through changing, so the loser would not be a merge conflict anyone notices — it would be a silently wrong edit, discovered at export.

The fix is to let the active edit finish, or work on a different project. Reading is never blocked.

When It Does Not Connect

  • Prove whose fault it is first. Point the MCP Inspector at the endpoint. If it connects and lists tools, the server and your account are fine and the problem is the client's config. That one check saves most of the guessing below.
  • The server loads but shows no tools. Almost always authentication that has not completed — the client connected, got a 401, and has not run the sign-in yet. Look for the client's authenticate action rather than editing the config again.
  • A url with no type. In Claude Code and VS Code an entry with a url and no type is read as a stdio server and skipped. Claude Code names it precisely: MCP server "valmera" has a "url" but no "type".
  • The wrong field name. Windsurf wants serverUrl, Goose wants uri, VS Code wants servers rather than mcpServers, Zed wants context_servers. A config copied from another client's docs fails quietly.
  • You signed up with Google. The consent page uses your normal Valmera login, Google included. Sign in there and choose Allow connection; no separate password is needed.
  • "Connecting apps to Valmera is not enabled for this account." The sign-in worked but this account has no eligible subscription. Sign in with the account you subscribed with, or see the plans.
  • Fewer tools than expected. A tool whose backing service is unconfigured is hidden from tools/list rather than exposed and failing at call time, so a session can be a few short. Clients also cache the list: refresh or reconnect after Valmera adds tools. Windsurf's 100-tool cap is a separate, larger cut.
  • Every call asks for approval. Most of an edit is reading — look_at, get_words, project_state, get_shots. Allow the read tools in your client and keep approval on render_preview and export_final, which start real compute.

One thing that is never the answer: retrying a tool call because the reply mentioned a job number. That is a receipt, not an error.

What This Does Not Do

Connecting the server does not change what the editor is. The limits, so a model reading this page does not promise them:

  • It edits footage, it does not generate it. Short generated clips and stills can be spliced in; there is no whole-video text-to-video. Upload something real.
  • Nothing renders locally. Only the upload and the download run on your machine. There is no local ffmpeg step to pin or cache.
  • Captions are burned in. No SRT or VTT is accepted or produced, and no chapter metadata — so there is no subtitle file to commit next to the MP4.
  • Review each deliverable. A 16:9 for the docs and a 9:16 for social are two requests, not one matrix build.
  • No NLE interchange, and no multi-cam. No project file for Premiere, Resolve or Final Cut, no true crossfade, and one transition style per video rather than per cut.
  • No team seats, share links or direct publishing. Download the exported MP4 and post it yourself. Also no custom font uploads, no motion-tracked overlays, no audio denoise and no AI music generation.
  • No delegation to Valmera's in-house agent. Over MCP, your assistant edits with the tools directly.

The connected assistant chooses the tool calls and writes its own replies, so judge the edit by the tool results and the rendered preview. Read more about this workflow on the agentic video editor page, and the field of alternatives is on video editing MCP servers.

Frequently Asked Questions

Every MCP client keeps a config file with a map of servers, and a remote server is one entry containing a URL. The three things that differ between clients are the file's location, the name of the top-level key (mcpServers in most, servers in VS Code, context_servers in Zed, extensions in Goose), and the spelling of the transport (http, streamable-http, streamableHttp, streamable_http, or nothing at all). For Valmera the URL is https://valmera.io/mcp/server, the transport is streamable HTTP, and authentication is OAuth 2.1 with dynamic client registration — so in most clients the whole config is the URL and one sign-in.
For Cursor: {"mcpServers": {"valmera": {"url": "https://valmera.io/mcp/server"}}} in ~/.cursor/mcp.json. For VS Code the key is servers and the entry needs a type: {"servers": {"valmera": {"type": "http", "url": "https://valmera.io/mcp/server"}}} in .vscode/mcp.json. For Claude Code the same shape lives in .mcp.json with "type": "http", and an entry with a url and no type is read as a stdio server and skipped. Those three cover most of what people mean by mcp.json.
In the Claude app, open Settings → Customize → Connectors, click + and choose Add custom connector, then paste https://valmera.io/mcp/server and save. Claude discovers the authorization server from the endpoint, registers itself, and opens a Valmera sign-in and consent page — there is no token, client id or secret to paste. Custom connectors work on Free, Pro, Max, Team and Enterprise, with free accounts limited to one. Add it on claude.ai and it syncs to the desktop and mobile apps; mobile can use connectors but cannot add them.
Any client that can reach a remote streamable-HTTP MCP server. This page has the exact configuration for Claude, ChatGPT, Claude Code, Codex, Cursor, VS Code, Gemini CLI, Cline, Windsurf, Zed, Continue, Goose, LibreChat and the MCP Inspector, each with the date its own documentation was checked. Clients that only speak stdio can use the mcp-remote bridge.
Prefer OAuth. Valmera implements OAuth 2.1 with RFC 9728 protected-resource discovery, RFC 8414 authorization-server metadata, RFC 7591 dynamic client registration and mandatory PKCE, so a client that supports it needs nothing but the URL — no app to register, no client id, no secret. A bearer token exists for the clients that never implemented the OAuth half of the spec (Cline, Continue) and for headless environments like CI where no browser will open. Both credentials resolve to the same session inside the server, so a token session and an OAuth session get an identical tool registry and identical refusals.
Sign in at valmera.io/mcp/connect and open Advanced setup · bearer token. The token is minted against your Valmera account and shown exactly once — it is stored only as a sha256 hash, so a lost token is replaced rather than recovered, and you can revoke it on the same page. Tokens carry the prefix vlm_mcp_. Never commit one: every client on this page supports either an environment variable in the config (${VAR} in Claude Code, ${env:VAR} in Windsurf and Cursor, ${input:...} in VS Code) or a prompt.
If it speaks streamable HTTP, almost certainly — this is a standard MCP server with no client-specific behaviour. If it only speaks stdio, put mcp-remote in front of it: {"command": "npx", "args": ["-y", "mcp-remote", "https://valmera.io/mcp/server"]}. mcp-remote runs the OAuth flow in your browser, caches credentials in ~/.mcp-auth, and proxies stdio to the remote endpoint. It needs Node 18 or higher.
The MCP server is the API. It speaks JSON-RPC 2.0 over Streamable HTTP, so a script can call it with curl or an MCP client library and a bearer token, no LLM required. Its catalog is generated from Valmera's live engine registry, adds session tools for projects, uploads, jobs and export, and hides capabilities whose backing service is unconfigured. There is no separate REST API; the video editing API page has curl, TypeScript and Python examples.

Made with Valmera: real exports

Connect It and Edit Something

Create a free Valmera account, paste the endpoint into your client, sign in — then upload footage and describe the edit from the chat you are already in.

Create a free account →
See pricing →

Related Articles

Valmera MCP Server
What the server does, quick configs, capabilities, export flow and limits.
MCP Tool Reference
Every tool grouped by job, with what each one does.
Video Editing API
Call the same server from your own code: curl, TypeScript and Python.
Connect Claude to Video Editing
The Claude app's connector UI in full, with the errors worth recognising.
Edit Video from Claude Code
Scopes, a committed .mcp.json, permissions, and a session from local file to reviewed preview.
Video Editing in Cursor
The Cursor path, plus the screen-recording tools that fit a release-notes workflow.
ChatGPT and MCP Video Editing
How to connect Valmera in developer mode, authenticate, test action tools, and handle the upload and verification limits.
What Is MCP Video Editing?
The protocol, the category, and why an editor is a good thing to expose over it.
Video Editing MCP Servers
Every MCP server that edits video, compared — including where another one is the better answer.