Video Editing in Cursor over MCP

{
  "mcpServers": {
    "valmera": {
      "url": "https://entrepreneur-bot-backend.onrender.com/mcp"
    }
  }
}

Streamable HTTP · OAuth 2.1 with dynamic client registration and PKCE · 108 tools (97 editing, 11 session). Nothing else goes in the entry — no client id, no secret, no token.

What This Combination Is Actually For

Most video tooling assumes the footage is a face. A developer's footage is a screen: the feature you just merged, working. That video is needed in four places and none of them are worth opening a timeline for — the release post, the PR or changelog entry, the docs page, and the demo someone asked for on Slack.

Valmera has tools that only make sense for that footage. record_website_demo drives a browser through your product with a visible cursor and returns every click timestamped and positioned; showcase_demo uses that track to zoom onto each click and land a sound on the frame of the press; enhance_cursor finds the real pointer in the frames and redraws it bigger and steadier; and set_screen_frame puts the whole thing in the floating rounded window on a gradient that every product launch video uses. The other video-editing MCP servers are mostly clipping and captioning services, and one drives a local copy of DaVinci Resolve — none of them record a browser, which you can check against our comparison of every video editing MCP server.

Cursor adds one thing on its side that matters more than it sounds: a terminal. MCP arguments are JSON, so a local file cannot cross the protocol — Valmera's upload_start answers with a presigned URL and the exact curl command instead. In a chat window that is a step you perform. In Cursor the agent runs it and carries on.

How to Connect Valmera to Cursor

1. 1
   Create a Valmera account

   Sign up free at valmera.io with email or Google. Every account gets 50 credits and no card is required. If you sign up with Google, set a password with “Forgot password” first — the OAuth consent screen needs one.
2. 2
   Add the server to mcp.json

   Global config is ~/.cursor/mcp.json; project config is .cursor/mcp.json inside the repo. Add a mcpServers entry named valmera whose only key is url: https://entrepreneur-bot-backend.onrender.com/mcp. You can also manage and toggle MCP servers from Customize in the sidebar.
3. 3
   Sign in when the browser opens

   Cursor discovers the authorization server from the endpoint, registers itself dynamically, and opens a Valmera sign-in and consent page. Sign in, read what is being granted, and press Allow. Cursor's fixed OAuth callbacks are registered by Cursor itself, so there is nothing to whitelist on your side.
4. 4
   Confirm and start

   Ask the agent to list your Valmera projects. A list — or an empty one on a new account — means the connection is live. Then describe the video: “record a demo of the new dashboard at this preview URL and cut it like a product video”.

Setup is one config entry and one sign-in. The first upload needs a one-time analysis pass that reports progress and is reused by every later edit; a recording Valmera makes itself is indexed the same way.

Where the Config Goes, and the Two Auth Forms

Cursor reads MCP configuration from two places and they answer different questions. ~/.cursor/mcp.json is global — the right home for an editor you use across every repo. .cursor/mcp.json inside a project is workspace scope, and it is the one you commit so that everyone working on the repo gets the same server without being told about it.

The OAuth entry above is the whole thing: a name and a url. Cursor also documents a static auth block carrying a CLIENT_ID and CLIENT_SECRET, for providers that issue fixed credentials or require a redirect URL to be whitelisted. Valmera needs none of it — it implements RFC 7591 dynamic client registration with mandatory PKCE, so the client registers itself and no secret ever sits in a file.

The second form is a bearer token, which is the right answer when you want a committed project config that authenticates without a browser round trip. Mint the token from your Valmera session and keep it in the environment rather than in the file — Cursor interpolates ${env:NAME} inside headers and url:

{
  "mcpServers": {
    "valmera": {
      "url": "https://entrepreneur-bot-backend.onrender.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:VALMERA_MCP_TOKEN}"
      }
    }
  }
}

The token is displayed once and stored only as a sha256 hash. If you lose it, mint another rather than hunting for it.

One key you do not need: type. Cursor's current documentation lists it as required for stdio servers and describes a remote server as a url with optional headers or auth. Older snippets elsewhere add "type": "streamable-http" to remote entries; the minimal form above is what the docs show now.

Worth saying plainly: the Claude app and Claude Code are the two clients we have run end to end. Valmera is a standard streamable-HTTP MCP server with OAuth 2.1 and Cursor is a compliant client, and the config here follows Cursor's documented shapes — but we would rather tell you which paths we have personally driven than imply we have driven all of them.

A First Run

You merged the branch, the preview deployment is up, and the release post needs a video. This is that session, abbreviated — the tool names are real and in the order they would be called.

you    record a demo of the new project screen at
       https://acme-dash-git-feat.vercel.app — click "New project",
       type "acme-api" in the name field, create it, then scroll to
       the activity feed

agent  create_project(title="v0.9-release")
       record_website_demo(url=..., steps=[
         {do:"click", text:"New project"},
         {do:"type", selector:"input[name=title]", text:"acme-api"},
         {do:"click", text:"Create"},
         {do:"scroll", to:"Activity"}
       ])
       -> capture saved as a project asset, plus an event track:
          every click, keystroke and scroll timestamped WITH its
          position in the frame

you    cut it like a product video, put it on a dark gradient, and
       speed up the bit where it spins

agent  showcase_demo(asset_key=..., zoom_strength=0.5)
       -> zoom travels between the buttons; a click sound lands on
          the exact frame of each press
       set_screen_frame(background="#0b0b0b", background2="#1e1e1e",
                        direction="diagonal")
       set_speed(start=..., end=..., factor=3)
       render_preview()            -> STILL RUNNING (job 8421)
       wait_for_job(job_id=8421)
       look_at(output_times=[2.4, 9.1, 17.8])

agent  The push-in on Create arrives before the page reacts. Moving
       that keyframe later by ~0.4s and re-rendering.

you    there's a bearer token visible in the network tab at 0:12

agent  find_burned_text(...)  -> two rectangles measured off the frames
       erase_burned_text(...) -> pixels repainted, background rebuilt
       export_final()         -> STILL RUNNING (job 8437)
       download_url()         -> https://...

Two things in there are the whole point. The agent caught the late push-in because it looked at frames of the preview it had just rendered, not because you told it. And the export came from the original capture at source quality — the preview is a fast proxy and is never the deliverable.

The Tools That Matter When the Footage Is a Screen

That is a slice of the registry aimed at one audience. The rest of it — music and ducking, colour grading, reframing, b-roll, voiceover, loudness mastering, transcript search — is in the same session, and every tool is listed on the MCP tool reference.

Two Cursor Behaviours Worth Knowing First

Cursor renders images returned by MCP tools. That is not cosmetic here. Valmera's look_at returns real frames — of the source, of an uploaded clip, or of the assembled program with each tile labelled by scene, on a faint tenths grid so an aim point is a measurement rather than an impression. In Cursor those frames land in the conversation, so you are looking at exactly what the agent used to decide. Video is handled differently on purpose: watch_video hands back a URL by default and embeds the file only when asked, because a client that cannot use a video content block stringifies it into millions of characters of base64.

Cursor asks before every MCP tool call by default. An edit is mostly looking, so a real pass is dozens of calls and most of them read nothing but state. Set a Run Mode with an allowlist before you start, or the session turns into a confirmation dialog with a video attached. Valmera marks its read-only tools with readOnlyHint and the ones that reach outside your project with openWorldHint for exactly this reason — though annotations are advisory by protocol, so they are a hint to the client, never a security boundary. Authentication is the boundary.

If Something Goes Wrong

Cursor shows the server but no tools

Open the Output panel (Cmd+Shift+U on macOS, Ctrl+Shift+U elsewhere) and select MCP Logs. It shows server initialization, tool calls and errors, which is enough to separate an unreachable URL from a rejected sign-in.

The sign-in page rejects a password you are sure of

An account created with Google sign-in has no password, and the consent screen needs one. Set it with “Forgot password” on valmera.io and reconnect.

It says the account does not have access

That is a different message from a wrong password, on purpose. The password was correct and the account is not permitted — telling you “wrong password” when the password was right sends you round the same loop forever.

Every tool call asks for approval

Cursor asks before running an MCP tool by default, and an edit is mostly looking — look_at, get_words, project_state, get_shots. Use a Run Mode with an allowlist, or the session becomes a confirmation dialog with a video attached. Valmera annotates its read-only tools in the registry, but annotations are advisory by protocol and a client is free to ignore them.

A tool call answers STILL RUNNING with a job number

Correct, not broken. Renders, exports, pixel repainting and browser recording all exceed a sane request timeout, so they return a job id rather than a fabricated completion. wait_for_job is the follow-up.

record_website cannot reach your app

The browser runs on Valmera's side, not on your machine, so the URL has to be reachable from the internet — a preview deployment or a tunnelled URL, not http://localhost:3000. It also loads the page as an anonymous visitor: no logins, and it will not type into password or payment fields.

The file is on disk and MCP will not take bytes

MCP arguments are JSON, so raw bytes never cross the protocol. upload_start replies with a presigned URL and the exact curl command to run — including which stat flag gives the byte size on your platform. This is the part Cursor makes easy: it has a terminal, so it runs the command itself and calls upload_finish.

A tool you expected is missing from the list

A tool whose backing service is unconfigured is hidden from the registry rather than exposed and failing when called, so a live session can be shorter than the published list. Stock footage search and image generation are the usual absences.

Editing is refused because a turn is already running

The same project cannot be edited from the Valmera studio and from Cursor at once. It is refused in both directions instead of letting two editors write the same edit decision list.

What It Will Not Do

A screen recording made on macOS with Cmd+Shift+5 has no speech in it unless you selected a microphone, and with no speech there is no transcript — so silence removal, filler-word removal and captions have nothing to work from. Narrate it, or add a voiceover layer afterwards.

There is no animated GIF export. The deliverable is an H.264 MP4, which GitHub and most documentation platforms accept directly; convert it with ffmpeg if a GIF is genuinely required. Captions are burned into the picture, so there is no SRT or VTT file to ship alongside. Every export closes with a brief Valmera end card, and free-plan exports carry a small mark in the corner that paid plans do not.

And Valmera is not a generator — it edits footage that exists, whether you recorded it or it recorded the browser for you. If you want a video invented from a prompt, that is a different category of tool. The rest of the honest edge list is on the agentic video editor page.

Frequently Asked Questions

Put It in mcp.json and Ship the Demo

A free Valmera account, one config entry, one sign-in — then record, cut and export the release video without leaving Cursor.