Video Editing API

Separate the Interface, Editing Decisions and Renderer

These layers can be combined. Your code can analyze footage and submit the resulting composition to a renderer. A model can call a REST API through application tools. A template service can expose MCP. An MCP client can make direct calls without a model choosing the arguments.

For repeatable layouts, consider a renderer that accepts your composition or template data. For decisions that vary with the recording, evaluate the analysis and editing logic as well. Operating your own processing stack gives you control over that work and its maintenance; it does not establish a universal cost or performance advantage.

Four Documented Integration Options

The following is an interface comparison checked September 6, 2026. It describes published contracts and points to their sources; it does not rank rendering speed, editorial quality or overall price.

Shotstack's reference documents tracks, clips, assets and output configuration. Its MCP server is marked beta and exposes rendering and status tools. Having MCP access therefore does not distinguish a footage editor from a composition renderer.

Creatomate's render endpoint accepts a template or direct RenderScript. Its webhook guide describes both render-level and project-level configuration, and says completed renders are hosted for up to 30 days. Establish your own delivery storage when you need a longer handoff.

JSON2Video's create endpoint returns a project for asynchronous work. Its webhook reference describes completion destinations and recommends checking final status. It also documents delivery and verification limitations; do not treat receipt of a callback as proof of a successful render.

Valmera's public server card identifies its remote interface and exclusions. The tool reference distinguishes that discovery data from the authenticated session.

MCP Can Be Called by Application Code

MCP defines tool discovery and invocation; it does not require a particular user interaction model. The tool specification describes the messages, and the official Python client documentation shows application code listing and calling tools.

For Valmera, connect to https://entrepreneur-bot-backend.onrender.com/mcp with a client that supports the documented transport and authorization flow. The public card advertises OAuth metadata, dynamic client registration and PKCE. Confirm your account can access the service; public documentation and a paid Studio plan do not, by themselves, prove that a particular client session is authorized.

The following are message-body examples inside an initialized, authorized MCP session. They are not complete HTTP requests or a standalone login script. Use your client library for authorization, initialization, protocol negotiation and request identifiers.

1. Discover the tools

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

Read the returned names and input schemas. Follow pagination if the server supplies a next cursor. Do not turn a cached public list into hard-coded assumptions about required fields or output shapes.

2. Inspect projects using the advertised schema

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "list_projects",
    "arguments": {}
  }
}

This second example assumes the authenticated catalog exposes list_projects with an empty argument object. Check that schema before calling. Use project identifiers from the returned data; the example does not include an invented project or a reported tool result.

After selecting a project, inspect each editing tool's own schema. Supply project and version information where required. Check whether times refer to the original recording or the edited program. The setup guide and tool reference cover the product workflow.

Integrate Valmera's Documented MCP Workflow

1. 1
   Confirm the required delivery

   Decide whether the integration needs a preview, a completed MP4, a subtitle file or an editable timeline. Valmera's checked public MCP contract does not create final exports; final creation is a Studio step. Confirm account eligibility before building an unattended workflow.
2. 2
   Connect and discover the actual tools

   Use a client with the required Streamable HTTP and authorization support. Initialize the session, list tools and inspect their input schemas. A public server card describes discovery information; it is not the authenticated session or an access grant.
3. 3
   Select the project and prepare media

   Use the session's project and upload tools, keeping project identifiers from actual results. Follow the upload destination and method returned by the service, complete the upload and observe indexing. Main video must meet both the 14 GB and three-hour limits.
4. 4
   Apply one bounded edit

   Read the relevant transcript or project evidence, identify the intended version and call an available editing tool using its current schema. Establish whether timestamps refer to source or edited output. Observe the result before submitting a dependent change.
5. 5
   Follow the returned job and review

   Store the job identifier with its project and operation. Use the documented status or wait tool until the actual work succeeds or fails. A waiting timeout is not proof of job failure. Inspect the returned preview and the recorded edit.
6. 6
   Finish the accepted version

   Review the accepted edit in Studio and create its final MP4 there. Check the downloaded file and complete runtime. If another service will consume it, use a storage and delivery arrangement that remains accessible for that service's queue and render duration.

Test the complete workflow with a small representative recording before estimating capacity or cost. Processing and job completion times are not fixed.

Distinguish a Response, a Tool Result and a Finished Job

Valmera responses can contain text, structured information and media-related content. Check isError when present, but do not infer completion from a false value alone: session text can describe work that is still running or explain why the requested action was not performed.

Store the operation, project, relevant version, job identifier and last confirmed status together. Validate returned data before using it in another request. Keep credentials and signed media URLs out of shared logs; retain identifiers that let you investigate a failed handoff.

Sampled frames can help review layout, but they do not verify continuous audio, every cut or every caption transition. A downloaded preview is review material. Final-export creation is a separate Studio action under the checked public contract.

Plan Recovery Before Sending Repeated Work

An application timeout can occur after the service accepted a request. Retrying immediately may create duplicate work. If a job identifier was returned, follow it. If no identifier reached your client, inspect available project or render state before deciding whether to submit again.

Distinguish a repeated status read from a repeated mutation. Adding an overlay twice can differ from setting a property twice. Do not assume a request identifier, a client-side deduplication key or a cached asset makes every provider operation idempotent.

For example, JSON2Video documents that repeated movie-creation requests create new projects, even when the body is unchanged; caching is a separate mechanism. Verify the equivalent contract for each service you integrate.

Use bounded retries with backoff where the provider allows them. A malformed request needs correction, an expired authorization needs the supported recovery flow, and an unknown job outcome needs reconciliation. Avoid simultaneous edits to the same Valmera project from multiple clients.

A Worked Integration Plan for an Interview Clip

Suppose the brief calls for a vertical clip from an interview, retaining an important qualification and adding readable captions. This is a proposed plan; no media operation is reported as completed.

An application may obtain the ranges from its own analysis, a human decision or an external model. The editing interface does not eliminate that decision. No automatic speaker diarization is claimed for this Valmera workflow, so identify the intended speaker's passage from actual evidence.

If a later service adds a standard intro or end card, transfer the accepted media file through storage that it can read. Confirm codec, aspect ratio, audio, access duration and full final runtime. A playable URL today does not establish that a queued renderer can retrieve it later.

Download the integration checklist to record your own connection, recovery and delivery results. Its checkboxes are blank; it is not a certification or benchmark.

Estimate Attempts and Accepted Outputs

Compare total workload rather than a single subscription price. Record source-analysis charges, rendering units, resolution multipliers, minimum charges, included allowances, retries, storage, transfer and review effort. The relevant unit may be output duration, credits, model work or compute time.

Hypothetical planning example: 100 requested videos at 30 seconds each represent 50 minutes of output. If 20 full renders are repeated, the workload becomes 120 attempts and 60 rendered minutes before any provider-specific rounding or additional processing. That is not a quoted bill, and the number of accepted deliverables remains a separate measure.

Valmera's public information distinguishes free account creation and uploads from paid indexing and AI editing. An external model or host can have its own charges. Confirm MCP access, metering and workload limits for your account rather than assuming Studio credits or a third-party model subscription cover every integration cost. See plans and credits documentation.

A reusable template can reduce editing effort when the layout is settled. An agent can help when each recording needs different choices. Neither observation proves which approach is cheaper for your workload without measured usage and accepted-output counts.

Verify These Valmera Boundaries Before Integration

• Media limits: the public main-video limits are both 14 GB and three hours, with MP4, MOV, M4V, MKV and WebM formats. Accepted size does not prove a successful edit or fixed processing time.
• Session availability: public metadata is for discovery. Check authorization and the actual session's available tools. A capability present in development code is not proof of deployed availability.
• Final creation: use Studio under the checked public contract. Retrieving an existing final link does not create or refresh that final.
• Project handoff: no NLE project/XML/AAF export is documented. Studio captions are burned in; SRT/VTT import and export are unsupported.
• Multiple clips: child clip creation is followed by separate editing, review and final delivery. It does not establish an automatically finished batch.
• Output quality: rendering from original media does not guarantee lossless or byte-identical output. Check the final encoding, crop, effects, soundtrack and captions.
• Notifications and scale: no completion-webhook registration is documented for this public MCP interface. Confirm concurrency, limits, identity and support requirements before depending on unattended production volume.

Use the delivery guide for the final MP4 and the agentic editor guide for evaluating meaning, revisions and preview quality.

Frequently Asked Questions

Sources and Verification Scope

This publisher-authored guide uses the primary documentation below, Valmera's local implementation and its public metadata checked September 6, 2026. Local implementation details do not supersede the checked public contract. No new authenticated integration test, paid render, performance ranking or cost benchmark is claimed.

• Shotstack Edit API
• Shotstack MCP server
• Creatomate render endpoint
• Creatomate webhook guide
• JSON2Video create-movie endpoint
• JSON2Video webhook reference
• MCP tool protocol
• Official MCP Python client documentation
• Valmera public server card
• Valmera public upload limits

Review the Integration Before You Build

Start with the documented MCP tools, account access and required delivery. Paid editing and final Studio export are separate considerations.