Developer

API Reference

Give an agent a brief. Get back a finished video. The Future Video Studio API exposes the same production workflow used in the app, including uploads, defaults, and account-scoped billing.

Getting started

Authentication

Managed API keys are created inside the product settings panel. Every render inherits the defaults and billing identity of the account that owns the key, which keeps model choices, stage behavior, and credit reservations aligned with the same production environment your team uses in the UI.

!
Keys belong to user accounts, not synthetic API wallets. No-key paid quotes are available through Link and return a claim-token status URL.
  • Create a managed agent API key from your Future Video Studio account settings.
  • Send that key as `X-FVS-Agent-Key` on every request.
  • When model or resolution fields are omitted, the API uses the defaults saved on the owning user account.
  • Credits are reserved and settled against that same user wallet, including project creation and stage generation charges.

Base URL and current routes

Submit a render request, then poll the returned `status_url` until the response includes a signed `final_video_url`.

https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent
POST/api/agent/renders

Submit a screenplay-driven production request and receive `project_id`, `status_url`, and `cancel_url`.

GET/api/agent/renders/{project_id}

Poll the current project status and final signed video URL.

POST/api/agent/renders/{project_id}/cancel

Cancel an in-flight production run.

No-account payment

Link paid quote mode

Agents can request a quote without creating an FVS account or API key. The quote uses the same credit math as the app, returns a Stripe MPP 402 challenge for Link, and includes a claim-token URL for result retrieval.

  • Call `POST /api/agent/render-quotes` without an FVS API key.
  • Read the returned HTTP 402 `WWW-Authenticate: Payment` challenge and `payment_url`.
  • Pay the quote with Link for agents using the Stripe MPP flow.
  • Poll the returned `status_url` with the `claim_token` until `final_video_url` is ready.

Quote request

{
  "request": {
    "name": "Paid quote test",
    "project_mode": "scene",
    "screenplay": "Shot 1: A glass airship drifts over a frozen city.",
    "shot_count": 1,
    "scene_target_duration_seconds": 4,
    "video_resolution": "720p"
  },
  "upload_urls": [
    {
      "url": "https://example.com/reference.jpg",
      "filename": "reference.jpg"
    }
  ]
}

402 response

HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment id="...", realm="app.future.video", method="stripe", intent="charge", request="...", expires="..."

{
  "type": "https://paymentauth.org/problems/payment-required",
  "title": "Payment Required",
  "status": 402,
  "payment_method": "stripe_mpp",
  "quote_id": "quote_...",
  "amount_cents": 120,
  "currency": "usd",
  "credits_quoted": 120,
  "payment_url": "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent/render-quotes/quote_.../pay?claim_token=...",
  "status_url": "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent/paid-renders/quote_...?claim_token=...",
  "claim_token": "...",
  "expires_at": "2026-04-30T12:30:00Z"
}
MCP access

Give agents a native Future Video Studio toolset.

The hosted MCP server exposes the same account-scoped render API through Streamable HTTP. Connect your MCP client to the endpoint below and pass your managed FVS agent key as a secret header for account mode. Omit the key for paid quote mode. Agents submit asynchronously, poll status, and download the completed signed video URL.

https://mcp.future.video/mcp

Client config

Use this shape for account mode. For paid quote mode, omit `headers`.

{
  "mcpServers": {
    "future-video-studio": {
      "type": "streamable-http",
      "url": "https://mcp.future.video/mcp",
      "headers": {
        "X-FVS-Agent-Key": "fvs_live_replace_me"
      }
    }
  }
}

Tools

  • `fvs_submit_render` submits a new render request and returns status links.
  • `fvs_create_paid_render_quote` returns a Link-compatible no-account quote.
  • `fvs_get_render_status` polls by `project_id` or `status_url`.
  • `fvs_get_paid_render_status` polls a paid quote by `status_url` or claim token.
  • `fvs_cancel_render` cancels an in-flight render.
  • `fvs_download_final_video` downloads a completed signed video URL to a local path.
  • `fvs_example_render_request` returns a starter request body.
  • `fvs_open_chatgpt_app` opens the ChatGPT app widget without creating a render.

ChatGPT App

Future Video Studio can be added in ChatGPT developer mode as a ChatGPT App. Create a connector with the MCP endpoint below. Account mode uses the same managed agent key as the API. Pay-per-render mode works without an FVS account and returns a Link payment URL plus a claim-token status URL.

Connector name: Future Video Studio
Connector URL: https://mcp.future.video/mcp
Optional secret header: X-FVS-Agent-Key = fvs_live_replace_me
Pay-per-render mode: omit X-FVS-Agent-Key or set X-FVS-Billing-Mode = pay-per-render
Widget resource: ui://future-video-studio/render-console-v1.html
  • `https://mcp.future.video/chatgpt-app.json` returns the ChatGPT app setup manifest.
  • The widget is served as `text/html;profile=mcp-app` through the MCP resource `ui://future-video-studio/render-console-v1.html`.
  • The render tools advertise MCP Apps `ui.resourceUri` metadata and the ChatGPT `openai/outputTemplate` compatibility key.

Discovery routes

  • `https://mcp.future.video/server.json` returns the MCP server manifest.
  • `https://mcp.future.video/.well-known/mcp-server.json` returns the same manifest for clients that prefer well-known discovery.
  • `https://mcp.future.video/chatgpt-app.json` returns the ChatGPT app setup manifest.
  • `https://mcp.future.video/health` returns service health.

Example MCP tool call

For hosted MCP, use public `upload_urls` for external assets. Local file path uploads are not exposed by the hosted tool surface. The hosted tool call does not require render timeout fields; use `fvs_get_render_status` for progress.

{
  "request": {
    "name": "Kling 3 opening shot",
    "project_mode": "scene",
    "screenplay": "A surreal fantasy landscape opens beneath a glass sky. An emerald mountain glows in the distance. A water drop hits a pond and reveals a high elf face in the ripples.",
    "instructions": "Create three cinematic shots totaling about 30 seconds. No text overlays. Keep the motion slow, majestic, and suitable for a website hero background.",
    "shot_count": 3,
    "scene_target_duration_seconds": 30,
    "image_model": "gemini-3-pro-image-preview",
    "video_model": "kling-v3-pro-image-to-video",
    "video_resolution": "4k",
    "ingredients_mode_enabled": true,
    "stage_voice_briefs_enabled": false
  }
}

Downloading final renders

Use `fvs_download_final_video` only after a status tool returns a completed `final_video_url`. The tool performs an unauthenticated HTTPS GET to that signed URL and writes the bytes to `output_path` on the MCP server filesystem. It does not call the FVS Agent API, spend wallet credits, require `X-FVS-Agent-Key`, cancel jobs, or modify the remote render.

  • `final_video_url` must be the HTTPS signed URL from `fvs_get_render_status` or `fvs_get_paid_render_status`.
  • `output_path` is local to the MCP server process. Parent directories are created.
  • `overwrite` defaults to `false`; existing files are refused unless it is set to `true`.
  • Large videos may take minutes to download. The request timeout is 600 seconds.
  • If a signed URL expires, poll status again and retry with the refreshed URL.
{
  "final_video_url": "https://app.future.video/projects/proj_api_60c90c0841464675_final.mp4?...",
  "output_path": "C:/Users/me/Videos/fvs-render.mp4",
  "overwrite": false
}

Example paid quote tool call

The tool returns `payment_url`, `status_url`, `claim_token`, and the raw `www_authenticate` challenge. Pay the URL with Link, then poll the status URL.

{
  "request": {
    "name": "No-account paid render",
    "project_mode": "scene",
    "screenplay": "Shot 1: A glass airship drifts over a frozen city.",
    "shot_count": 1,
    "scene_target_duration_seconds": 4,
    "video_resolution": "720p"
  }
}
Supported inputs

Everything the studio already knows how to ingest.

  • Text-only briefs with screenplay, instructions, lore, style controls, and shot targets.
  • Uploaded image references for characters, environments, props, and mood boards.
  • Uploaded audio tracks for `uploaded_track` music workflows.
  • Uploaded video, PDF, and document assets using the same asset-analysis path as the studio UI.

Content type

  • `multipart/form-data` with `request_json` as a JSON string.
  • `files` can be repeated for image, audio, video, and document uploads.
  • `assets[]` inside the payload labels and classifies those uploaded files.
Parameter groups

Creative brief

FieldNotes
`name``name`, `screenplay`, `instructions`, `additional_lore`
`visual_style_preset``visual_style_preset`, `visual_style_custom_instructions`
`project_mode``project_mode`, `shot_count`, `scene_target_duration_seconds`

Model selection

FieldNotes
`orchestrator_model``orchestrator_model`, `critic_model`
`image_model``image_model`, `image_resolution`
`video_model``video_model`, `video_resolution`
`music_model``music_model`, `stage_voice_briefs_enabled`

Music and timing

FieldNotes
`music_workflow``music_workflow`, `lyrics_prompt`, `style_prompt`
`music_min_duration_seconds``music_min_duration_seconds`, `music_max_duration_seconds`
`music_start_seconds``music_start_seconds`, `use_first_audio_asset_as_music`

Asset manifest

FieldNotes
`assets[]` entries with `filename``assets[]` entries with `filename`, `label`, and `purpose`
Repeated `files` upload fields in the multipart form bodyRepeated `files` upload fields in the multipart form body
Submitted renders return a `status_url`; poll that URL until completionSubmitted renders return a `status_url`; poll that URL until completion
!

`critic_model` default is `gemini-3.5-flash`; legacy `gemini-3-flash-preview` requests are normalized forward.

`image_model: gemini-omni-flash-image` and `video_model: gemini-omni-flash-video` are recognized for Gemini Omni Flash.

Gemini Omni Flash render and edit calls require Google API model IDs to be configured on the backend once Google's public API rollout reaches developers.

Reference payload

A complete request can be just one multipart POST.

{
  "name": "Archive corridor test",
  "project_mode": "scene",
  "screenplay": "Shot 1: A young woman enters a glowing archive corridor lined with suspended photographs. Shot 2: She reaches toward one moving photograph and the corridor bends into a luminous tunnel around her. Shot 3: She steps through the tunnel and arrives in a sunlit memory chamber as the photographs orbit overhead.",
  "instructions": "Create exactly three cinematic shots totaling about 24 seconds. Keep the subject visually consistent across all shots. Favor strong camera motion, realistic lighting, and clean transitions. No subtitles or text overlays.",
  "shot_count": 3,
  "scene_target_duration_seconds": 24,
  "image_resolution": "1K",
  "video_model": "veo-3.1-fast-generate-001",
  "video_resolution": "720p",
  "stage_voice_briefs_enabled": false
}
{
  "project_id": "proj_api_60c90c0841464675",
  "name": "Archive corridor test",
  "status": "completed",
  "current_stage": "completed",
  "is_running": false,
  "run_id": null,
  "final_video_url": "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/projects/proj_api_60c90c0841464675_final.mp4?...",
  "last_error": null,
  "asset_count": 1,
  "clip_count": 3,
  "status_url": "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent/renders/proj_api_60c90c0841464675",
  "cancel_url": "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent/renders/proj_api_60c90c0841464675/cancel"
}
Examples

Python

import json
import requests

BASE_URL = "https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent"
AGENT_KEY = "replace-with-your-managed-key"

request_payload = {
    "name": "Archive corridor test",
    "project_mode": "scene",
    "screenplay": "Shot 1: A young woman enters a glowing archive corridor lined with suspended photographs. Shot 2: She reaches toward one moving photograph and the corridor bends into a luminous tunnel around her. Shot 3: She steps through the tunnel and arrives in a sunlit memory chamber as the photographs orbit overhead.",
    "instructions": "Create exactly three cinematic shots totaling about 24 seconds.",
    "shot_count": 3,
    "scene_target_duration_seconds": 24,
    "video_model": "veo-3.1-fast-generate-001",
    "video_resolution": "720p",
    "stage_voice_briefs_enabled": False,
}

response = requests.post(
    f"{BASE_URL}/renders",
    headers={"X-FVS-Agent-Key": AGENT_KEY},
    files={"request_json": (None, json.dumps(request_payload))},
)
response.raise_for_status()
job = response.json()

while True:
    status_response = requests.get(job["status_url"], headers={"X-FVS-Agent-Key": AGENT_KEY})
    status_response.raise_for_status()
    status = status_response.json()
    if status["status"] == "completed":
        print("Video ready:", status["final_video_url"])
        break
    if status["status"] == "failed":
        raise RuntimeError(status.get("last_error") or "Render failed")

JavaScript

const form = new FormData();
form.append("request_json", JSON.stringify({
  name: "Archive corridor test",
  project_mode: "scene",
  screenplay: "Three-shot cinematic archive corridor sequence.",
  instructions: "Keep the lead visually consistent and total runtime near 24 seconds.",
  shot_count: 3,
  scene_target_duration_seconds: 24,
  video_model: "veo-3.1-fast-generate-001",
  video_resolution: "720p"
}));

const submit = await fetch("https://fmv-studio-frontend-t7cat7yhuq-uc.a.run.app/api/agent/renders", {
  method: "POST",
  headers: {
    "X-FVS-Agent-Key": "replace-with-your-managed-key"
  },
  body: form
});

const job = await submit.json();
const status = await fetch(job.status_url, {
  headers: {
    "X-FVS-Agent-Key": "replace-with-your-managed-key"
  }
}).then((res) => res.json());

Need higher-throughput access?

We can help with agent onboarding, multi-project usage, managed key rollout, and enterprise production workflows on top of the same API surface.

PricingTerms