MCP server

CueFrame Official

ai.cueframe/cueframe

Checked 26 Oct 2026, 08:29 UTC · Connected to it and listed its tools

Turn footage into finished video: reframing, captions behind the subject, motion graphics, renders.

Website Source

At a glance

Type

MCP server

Publisher

cueframe.ai (verified by the MCP Registry)

Status

Working at last check

Tools

95

Token cost

About 377,286 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

26 Oct 2026, 08:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

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

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.cueframe]
url = "https://api.cueframe.ai/v1/mcp"

Gemini CLI

{"mcpServers":{"cueframe":{"httpUrl":"https://api.cueframe.ai/v1/mcp"}}}

Cursor

{"mcpServers":{"cueframe":{"url":"https://api.cueframe.ai/v1/mcp"}}}

VS Code

{"servers":{"cueframe":{"type":"http","url":"https://api.cueframe.ai/v1/mcp"}}}

Antigravity

agy mcp add cueframe https://api.cueframe.ai/v1/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"cueframe","server_url":"https://api.cueframe.ai/v1/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"cueframe","server_url":"https://api.cueframe.ai/v1/mcp"}

Tools

• apply_composition ~43530 tokens
  Atomically apply an array of CompositionOps to a project composition. All ops succeed or none do (transactional). Call describe_composition_ops without type for the compact operation list, then with a type for its exact JSON Schema. For negotiated component execution, read get_composition with compo
• apply_template ~802 tokens
  Insert a resolved builtin component package into an existing project. Pass template as the selected builtin id and body with projectId, the resolved documentSha256, insert:{startTime,idPrefix}, parameter values and explicit media bindings. Read get_composition first and retain expectedRevision, comm
• cancel_compose ~213 tokens
  Cancel an in-flight compose job (stop a runaway/mis-priced ensemble). Needs projectId + composeJobId (from compose). The director cancel is confirmed before the row flips; any linked charge is released. No-op-reject (422) if already terminal.
• cancel_export ~181 tokens
  Cancel an in-flight NLE export (fcpxml/premiere). Needs projectId + exportId (from the export enqueue). No-op-reject (422) if already terminal.
• cancel_job ~192 tokens
  Cancel a running async job (verify / preview / brand-kit-extract) returned by an enqueue call — abort a mis-priced job instead of waiting out its TTL. For box-backed jobs the warm box is reaped best-effort; cancel never meters. No-op-reject (422) if already terminal.
• cancel_render ~178 tokens
  Cancel an in-flight render (stop a runaway/queued job). Needs projectId + renderId (from create_render). No-op if already terminal.
• compose ~1355 tokens
  Start an async Director compose job: it authors an ensemble of full composition candidates, verifies each, and saves the winner to the project. Body must set EXACTLY ONE source (mutually exclusive): `briefId` — author FROM a persisted Brief (the PLANNED path: create_brief first; every Brief field is
• consult ~649 tokens
  Ask the Director for editing advice on the project's CURRENT composition — it NEVER writes your composition (you stay the decider). Async: returns a consultJobId; then wait_job(kind="consult", id=consultJobId, projectId=...) surfaces the advisory envelope (assessment / proposals / principles / plan)
• create_brand_kit ~2911 tokens
  Create or UPSERT a brand kit (re-POSTing the same kitId updates it in place — this is also the brand-kit UPDATE path). Sets fonts/colors/logo. This is brand step 0 of the workflow: author the kit, then bind it to a PROJECT so colors/fonts/motion theme the output AUTOMATICALLY — pass its kitId as bra
• create_brief ~7847 tokens
  Persist the video's INTENT as a Brief — the Director's rich input contract (spec: the storyboard skill's output lands here). Fields: goal (required), audience, platform, format, durationSec, tone, cta, locale (output language — all on-screen copy + captions), hook, caption, beats[] (each with an edi
• create_checkout Moves money · ~394 tokens
  Top up the CURRENT org's credit wallet. Body { plan: "credit_pack_10"|"credit_pack_30"|"credit_pack_100" } → returns { url }: a hosted Stripe checkout page to open in a browser and confirm payment. There are no subscription tiers — a pack is a one-off top-up, and it is also the only thing that raise
• create_component ~3528 tokens
  Create and store a custom component for the tenant: a native scene that arranges its declared images and videos as tiles in 3D space. Returns the ComponentResponse (id + metadata) you can then reference from a composition. No project arg — components are tenant-scoped. SOURCE CONTRACT (version 4; th
• create_project ~483 tokens
  Create a new project — the unit you compose and render into. compose / apply_composition / create_render / the preview family all require a projectId; this mints one. Pass name (required) plus optionally a format (aspectRatio/fps/resolution) and brandKitId. brandKitId binds a brand kit to the PROJEC
• create_render ~626 tokens
  Queue an MP4 render of a project's composition (in a compose session, the session's scratch). Returns { id (renderId), status, warnings? } — `warnings[]` carries non-fatal advisories (omitted when none). The render themes from the project's brand kit (bind one via create_project / update_project wit
• create_upload ~489 tokens
  Ingest a LOCAL file — bytes you hold, when there is no public URL to hand import_media (prefer import_media whenever the bytes already sit at an https URL). TWO steps: (1) this tool reserves a media item and returns { id, uploadUrl, expiresAt } — a short-lived PUT URL. PUT the raw file bytes to uplo
• create_webhook ~554 tokens
  Register a webhook so long-running jobs notify you instead of blocking on wait_job — the right pattern for fan-out/async agents. Pass url + events — ONE terminal event per job kind with status INSIDE the payload (render.completed, compose.completed, media.completed, suggest.completed) plus checkpoin
• delete_brief Deletes data · ~140 tokens
  Delete a brief. Compose jobs already run from it are unaffected (they snapshot).
• delete_composition Deletes data · ~204 tokens
  Delete a composition (and its version history) from a project. REFUSES the ACTIVE composition (409) — make another one active first, or delete the project. Use list_compositions to see which is active.
• delete_critic Deletes data · ~152 tokens
  Delete a registered critic by its criticId. It stops running in the Director gates and score_composition immediately.
• delete_media Deletes data · ~170 tokens
  Permanently delete a media item from your library (cleanup). Irreversible. Compositions referencing it will fail to render — only delete media no composition still needs.
• delete_project Deletes data · ~166 tokens
  Permanently delete a project you created (cleanup). Removes its composition and render history. Irreversible — only call on a project you own and no longer need.
• delete_webhook Deletes data · ~152 tokens
  Delete a webhook subscription (stop receiving its deliveries). Irreversible — the signing secret is invalidated.
• derive_composition ~629 tokens
  Derive a reframed SIBLING composition for a different aspect ratio (the agent-native Auto-Reframe / Magic-Resize). Pass projectId + body { fromCompositionId, targetFormat: { aspectRatio, fps?, resolution? } }. CueFrame copies the source composition's authored intent and content-aware-reframes every
• describe_composition_ops ~150 tokens
  Discover the exact CompositionOp vocabulary accepted by apply_composition. Omit type for a compact list of operation names and descriptions; pass type for only that operation's JSON Schema. Read this before authoring edits or captions.
• download_media ~253 tokens
  Get a presigned download URL for a media item's stored SOURCE file — the bytes CueFrame composes from (the raw upload, or its conformed transcode). This is how you copy media OUT of a library: fetch the URL directly (no auth header) and PUT the bytes elsewhere with create_upload, or hand it to impor
• editorial_apply ~43062 tokens
  Commit an integrated editorial edit to the saved project composition with both runExpectedRevision and guarded composition fields. Preserve the observed concurrency basis and the composition journal identity: nested composition.commandId must equal composition.clientId + ":" + composition.sequence.
• editorial_create_brief ~220444 tokens
  Persist an authored brief for the selected project. The projectId belongs in body.brief; use the returned briefId to start an editorial run.
• editorial_create_run ~736 tokens
  Start an editorial run from a persisted brief and explicitly selected certified source ranges. Read editorial_run_source for each project media source first; use its exact identity, revision, frame count and fps ratio. Never invent a source pin or infer inspection from an index.
• editorial_findings_append ~714 tokens
  Persist one evidence-backed observation. A nothing_useful outcome may cover only what the cited evidence actually inspected; sparse stills do not certify an unsampled interval.
• editorial_findings_list ~156 tokens
  Read durable observations, including useful, nothing-useful and uncertain outcomes, in bounded pages. Pass nextCursor as cursor until done; retain evidence IDs, supersession and uncertainty when recovering decisions.
• editorial_get_run ~126 tokens
  Read a persisted editorial run, including its revision, state, inputs, outline, selected finding IDs, omitted reasons and unresolved integration gaps. Read findings and evidence separately for complete coverage.
• editorial_inspect_audio ~473 tokens
  Deliver a bounded 16 kHz source audio interval and save an audio evidence receipt. The interval must lie inside a certified run input.
• editorial_inspect_source ~274 tokens
  Deliver one exact decoded source frame as JPEG and save its evidence receipt. Only that sampled frame is visually inspected; preserve the returned evidenceId and coverage.
• editorial_inspect_transcript ~542 tokens
  Deliver at most 100 verified transcript words with their mapped certified decode interval and save a transcript evidence receipt.
• editorial_integrate ~486 tokens
  Save selected finding IDs, explicit omitted reasons and unresolved gaps with the observed run revision. Read the run and findings before deciding.
• editorial_list_briefs ~131 tokens
  Recover persisted authored briefs for a project. Read bounded pages; pass nextCursor as cursor until done. Brief IDs link to editorial runs.
• editorial_list_evidence ~144 tokens
  Read delivered evidence and inspection coverage for a run in bounded pages. Pass nextCursor as cursor until done; an empty page does not prove the whole source was inspected.
• editorial_list_runs ~142 tokens
  Recover persisted editorial runs for a project in bounded pages. Pass nextCursor as cursor until done, then read each relevant run for its integration decisions and unresolved gaps.
• editorial_run_source ~178 tokens
  Read the certified decode representation for media selected in this project before starting an editorial run. Supply projectId and mediaId; a null representation means this source cannot be pinned. The response omits internal storage paths. Select a bounded range from the returned frameCount and exa
• editorial_sample_motion ~473 tokens
  Deliver bounded sampled motion frames and save their evidence receipt. The sampled frames do not certify continuous visual coverage.
• extract_brand_kit ~332 tokens
  Queue brand-token extraction from a website URL — ASYNC: returns a jobId immediately; then wait_job(kind="brand_kit_extract", id=jobId) for the tokens (colors/fonts/title/description, fetched + regex-parsed from the site's HTML/CSS — NOT a screenshot/vision pass). It does NOT persist — review the to
• finalize_upload ~360 tokens
  Finalize a direct upload once you have PUT the bytes to the uploadUrl from create_upload. Confirms the bytes landed and starts ingest: image/asset become ready immediately (status "complete"); audio/video enter processing (status "processing"). Returns { id, status, processingPhase }. 400 if no byte
• forget_taste ~158 tokens
  Delete one entry from the org's learned taste by its id (from get_profile `taste` or remember_taste). This is how the user's "undo" works.
• generate_media ~562 tokens
  Generate one first-class Library media item from a prompt. Choose generator: text-to-video | text-to-image | image-to-video | text-to-music | text-to-speech | text-to-sfx | auto. Put supported presentation controls in body.style and first/last/image references in body.refs. Returns { id, status:"gen
• get_account ~490 tokens
  ORIENT FIRST — show THIS key's account before you spend a metered call: the org it is bound to, the current plan, a per-feature entitlements map, and per-call cost ceilings. READ `balance`, NOT `included`. CueFrame is credit-funded: rendering (entitlements.exports), generation (generate), preview st
• get_brief ~92 tokens
  Read a brief by id — the persisted intent plus its current quote (compose + estimated render).
• get_checkpoint ~269 tokens
  Read a checkpoint packet — the durable approval unit a held compose pauses at (wait_job reports awaiting_input with {checkpointId, stage, version}). Carries the stage artifact, presigned storyboard stills (REVIEW THE EVIDENCE, not raw JSON), critic verdicts, the money triple {thisStepUsd, jobSpendSo
• get_component_source ~359 tokens
  Read an exact component source as complete JSON. Supply sourceVersionId from the selected catalog card to read that immutable revision, retaining sourceSnapshot with its complete versioned definition, manifest and template beside its exact pin and schema metadata. For an explicitly selected builtin,
• get_composition ~969 tokens
  READ BACK a composition as JSON — the edit itself: tracks, clips, card HTML, reframe segments, captions, markers, format. This is what create_render encodes, so it is also what you hand to validate_composition (which needs a full inline composition body), what you diff after an edit, and what you ar
• get_media_context ~287 tokens
  Fetch bounded authoring context for a media item: dimensions/thumbnail, compact face roster, transcript counts/sample, temporal grids, and fact readiness. Transcript and word-grid counts cover one page only (default 20 utterances); pass transcript.data.pagination.nextCursor as after to get_media_con
• get_media_facts ~346 tokens
  Read prepared subject tracks and behind-subject mattes for one media item. For an exact readiness check, pass kind + startSec + endSec together using the same SOURCE window sent to prepare_media; exact.state is pending | ready | failed | available | unavailable. If subjectTrack was prepared without
• get_profile ~193 tokens
  The org's legible taste in ONE read: brand kits, registered critics (the machine-checkable standard both the Director's gates and score_composition enforce), their reference media (presigned thumbnails), the recent checkpoint-decision log, and the learned `taste` (style preferences saved with rememb
• get_render ~274 tokens
  Read ONE render's record without waiting on it: status, progress while it runs, outputUrl + outputExpiresAt once complete, the typed failure (errorCode / category / retryable) if it failed, and WHAT RENDERED — compositionId (the composition it froze), format (aspect/fps/resolution it encoded at), en
• get_template ~256 tokens
  Read a saved organization template by id or a known public catalog template by slug. The answer is a summary: the media and value parameters with their kinds and options, presets with their values and brand kit, the brand kit, rubric, components (id, version, asset slots) and an outline of the track
• get_transcript ~260 tokens
  Read exact source-time transcript words in bounded utterance pages. Word start/end values are seconds from the source media start. Default limit is 20; pass pagination.nextCursor as after for later pages. The formatter omits the unbounded fullText duplicate.
• get_usage ~381 tokens
  The A2 usage ledger: every metered billing event newest-first with attribution — featureId, amount, the project/job that produced it, and the event's LIST price in USD (a plan allowance may zero it on the invoice). Answer "what did project X cost this period?" with a query instead of summing your ow
• import_media ~485 tokens
  Import a media item into your library from a public URL — the agent-friendly ingest path (single call, no upload protocol). Pass url (https) + filename (+ optional contentType). Returns { id, status:"importing" }. Processing is async: call wait_job(kind="media", id=mediaItemId), or register a webhoo
• import_resource ~455 tokens
  Import a stock candidate (candidateId from search_resources) into a project as an ORG-OWNED media item — provider/externalId/license provenance preserved, bytes deduped across orgs. Pass projectId + candidateId. Returns { id, status:"importing"|"ready" }; processing is async — call wait_job(kind="me
• list_briefs ~262 tokens
  List briefs. DEFAULT shows human-authored briefs only; kind:"clip" shows the machine-minted clip briefs (suggest_briefs output), kind:"all" shows everything. Each carries its quote.
• list_catalog ~1116 tokens
  Use projection:'component-library' for the unified source-free library page, returned as complete JSON with exact scoped definition/preset/recipe cards and pagination. Choose origin:'builtin' for the maintained builtins or origin:'library' for the authenticated serving home; use libraryKind, categor
• list_checkpoints ~246 tokens
  List checkpoint packets newest-first (filter with composeJobId for one run's v1→vN gate history, or projectId). The version stack with per-version status + decisions IS the review history — nothing is deleted.
• list_compositions ~130 tokens
  List every composition (video) in a project, with its format and which one is active. Use a returned compositionId with create_render(compositionId=...) to render a specific video, or apply_composition to edit it.
• list_critics ~107 tokens
  List registered critics: criticId, label, tier (rules|rubric|evaluator), phase, floor, referenceMediaIds. Rubric text / rules / evaluator URLs are write-only — never echoed. Manage with register_critic (upsert) / delete_critic.
• list_media ~334 tokens
  List the media in your CueFrame library. Filter a real library with kind (video|audio|image|gif|asset|source|stock), source (upload|generated|import-url|stock), or tag — so you find YOUR footage, not e2e debris. Returns media item IDs and metadata; use an ID with get_media_context, suggest_briefs, o
• list_plans ~98 tokens
  List the plan catalog (tiers, intervals, product ids, prices) BEFORE a checkout, so create_checkout requests a real {plan, interval} instead of guessing an id. No args — reads the platform catalog.
• list_projects ~165 tokens
  List your projects — re-orient in an existing workspace instead of minting duplicates (steady-state entry, A9). Each row carries the id every other tool needs.
• list_render_fonts ~353 tokens
  The fonts the RENDERER can actually draw — read this BEFORE authoring type, not after a refusal. Per family: the exact family name authoring accepts, the weight RANGES a shipped file declares (a static face has min===max; a variable face gives its axis range), the caption default weights, and whethe
• list_taste ~119 tokens
  Read the org's learned taste: whether the owner has it on (`enabled`) and its saved entries, oldest first. While `enabled` is false, do not apply the entries. Learned taste is advice: the current request, brief, project, brand kit, exclusions and critics take precedence.
• list_templates ~179 tokens
  List this organization's saved templates. Follow pagination.nextCursor with after to read further pages. Public catalog slugs are not enumerated here; read a known public slug with get_template.
• new_composition ~488 tokens
  Create a NEW composition (a new video) inside a project — a project is a workspace that holds many videos. Returns { compositionId, format, etag }. Pass an optional name and format (aspectRatio/fps/resolution); format defaults to the project's compositionFormat. The first composition becomes the pro
• prepare_media ~590 tokens
  Prepare the perception artifact an authored edit needs BEFORE sighted review. Pass body.kind="subjectTrack" for face/active-speaker reframing, or body.kind="matte" for a true zPlane:"behind-subject" graphic. Pass body.intent {startSec,endSec} using SOURCE time (the media trim, not timeline time); it
• preview_card ~449 tokens
  Render ONE authored card on its own and SEE it, before placing it in a composition. Pass the same `html` (+ optional `tokens`) you would put in a {kind:"card"} clip; you get the still back as an image. Use this while writing a card — it is the fast loop for catching type that overflows the frame, a
• preview_clip ~414 tokens
  Render a scoped, cheap MOTION preview — ONLY body.fromSec→body.toSec of the composition (max 60s) at preview quality (capped resolution, lighter encode) through the real render pipeline. THE way to judge motion — a cut, a transition, a component's animation — at full fidelity BEFORE paying for a ful
• preview_component ~698 tokens
  Queue a typed preview artifact for ONE org-installed component — ASYNC: returns a jobId immediately; then wait_job(kind="preview", id=jobId). The preview and production compositor consume the same content-addressed component bundle and verified artifact contract. `body.componentId` selects the compo
• preview_frame ~787 tokens
  Queue durable still-frame evidence for layout/copy judgment. Returns immediately with {jobId, kind:'preview_frame', status}; then call wait_job(kind="preview_frame", id=jobId) to receive every presigned frame as an image. The immutable snapshot records geometry, layers, warnings, and whether the tar
• refresh_render_url ~267 tokens
  Re-sign a COMPLETE render's output URL. A render's presigned MP4 link lasts ~7 days, so wait_job / getRender on an old render hands back a link that 403s; this mints a fresh one for the same file and returns { outputUrl, outputExpiresAt }. Needs projectId + renderId (from create_render). 422 render_
• register_critic ~808 tokens
  Register a custom eval into the compose critic panel — the critic contract is { rubric (or rules/evaluator), referenceMediaIds?, floor }. Three tiers: rules (declarative constraints — keep-out regions, required elements, max overlays, brand colors), rubric (a text criterion scored by the judge as an
• remember_taste ~416 tokens
  Save one durable style preference to the org's learned taste, with its source (the job, checkpoint or chat, plus the date). Only for a preference the user stated: a revise comment, a chat correction or an explicit "remember this"; never one-off brief content, footage facts or secrets. Tell the user
• repin_component ~470 tokens
  Move clips stored in a retired form to their native (version 4) successors: a clip pinning a retired TSX (version 3) component, or one stored before execution pins (`needsUpgrade` kind `unpinned-component`), moves to the `successorSourceVersionId` that get_composition's `needsUpgrade` (or a `compone
• resolve_builtin_component ~222 tokens
  Resolve a selected builtin component-library card using its exact collection, id and revision. Returns the canonical pinned document and source snapshots for a preset or recipe, or the exact source for a definition. Preserve documentSha256 and all identities; a missing revision refuses without falli
• resume ~860 tokens
  Answer the checkpoint packet wait_job reported as awaiting_input (its {checkpointId} — read the packet FIRST with get_checkpoint and relay the stills + money triple to your human). ONE `body.decision` per gate: 'approve' (proceed; comments allowed — they record as taste without gating), 'revise' (th
• retry_render ~362 tokens
  Re-render an existing render job's FROZEN composition snapshot — it inherits that job's exact composition/intent/priority and queues a fresh renderJob; it does NOT re-read the project's current composition. So it only helps a TRANSIENT failure (the failed render's `retryable:true` / `category:"trans
• score_composition ~471 tokens
  Queue the durable server-side judge — it snapshots the exact authored target, samples eval beats, captures frames asynchronously, and grades editorial/spatial/brand/caption. Then wait_job(kind="verify", id=jobId) for per-criterion scores, weighted composite, worst-first critique, and checkpointId. `
• search_fonts ~324 tokens
  Search web font families by name/style — returns family names to use in composition/component params. Pass query (+ optional perPage ≤50). Read-only + free; surfaces the Google Fonts catalog (family + category + variants + css2 stylesheet URL). IMPORTANT: this searches the GOOGLE catalog, not what t
• search_resources ~645 tokens
  Search licensed stock media to compose with across video, photo, sound effects, and GIFs. Pass query for ONE search, or queries[] (≤10) to run them all in a SINGLE call — strongly prefer the batch when you know several things you need. A batch returns results[], one per query in order, each with its
• select_candidate ~458 tokens
  Select one candidate from a finished compose/consult ensemble as the project's saved composition (whole-candidate replace). Body REQUIRES both fields: { candidateIndex, selectStrategy: "agent-authoritative" } — candidateIndex from wait_job(kind="consult") proposals (mode=amend) or the compose winner
• start_template ~409 tokens
  Create a new project from a catalog or org template. The server prepares media and verified mattes before the project is ready. Pass the returned jobId to wait_job(kind="template").
• suggest_briefs ~296 tokens
  Run AI clip-suggestion analysis on a long-form media item — the CLIPPING path (find the best short-form moments). Returns { status, alreadyRunning? }; then wait_job(kind="suggestions", id=mediaItemId) — its terminal lists each suggestion WITH its briefId. When the media belongs to a PROJECT, each fi
• update_brief ~7652 tokens
  Edit a brief (partial). REFUSED with 409 while an ACTIVE compose job references it — finish, resume, or abandon the job first (the Director never has its input edited mid-run). Edits apply to the NEXT compose.
• update_component ~3954 tokens
  Update an authored component's complete version-4 source/metadata IN PLACE (same id) — the correct verb for the author→preview→fix loop (preview_component returns the admission or runtime error; fix the template here and re-preview, instead of creating a new component each iteration). Pass component
• update_project ~372 tokens
  Update a project's mutable fields (e.g. name, format, brandKitId). Pass projectId + the changed fields as `body`. Setting brandKitId binds/changes the project brand kit so every render of this project themes from it. Returns the updated ProjectResponse.
• update_webhook ~329 tokens
  Update a webhook subscription (its url or event list). Pass webhookId + changed fields as `body`. The signing secret is NOT rotated here.
• validate_composition ~11250 tokens
  Dry-run a full Composition object against the SAME pure, DB-free authoring guards saveComposition enforces, WITHOUT persisting it (no project needed). Checks: wire shape (Zod), primitive membership (unknown_primitive / custom_missing_sourcecode), required-param shape (invalid_primitive_params), clip
• verify_webhook ~267 tokens
  Re-run ownership verification on a PENDING webhook — one whose endpoint did not echo the challenge at create time (check its verification.reason: token_not_echoed / non_2xx_<code> / unreachable / ssrf_blocked). After you fix the receiver to reply 2xx echoing data.token, call this to re-send the sign
• wait_job ~362 tokens
  Wait for a long-running job and return the resolved result — a bounded long-poll. Includes template preparation (kind="template", id=jobId), media import, render, compose, consult, suggestions and preview. If still running, call wait_job again with the same arguments; work continues server-side.

Browse

• Stripe tools
• Website monitoring
• Payments
• Hiring and jobs
• Travel and flights

Related MCP servers

• PageToVid
  Turn any web page into a narrated video: films the real site, writes, voices and captions it
• UGC Fans
  Make ads, images and video from a URL; every paid generation is quoted in credits first
• Keptbits
  Turns long videos into captioned vertical clips, cut at the moments that stand on their own.
• Clypmint
  Edit videos with AI: cuts, captions, B-roll and motion in a style you pick or copy from any video.
• BlitzReels Video Editor
  Create, edit, reframe, caption, organize, generate, and export short-form videos with BlitzReels.
• Slice
  Turn long podcast episodes, video or audio, into captioned vertical clips and transcripts.
• PromptFrenzy
  Find a tested AI image or video prompt — toy, LEGO, plushie, portrait, poster — and render it.
• ShearQuery — Barber & Beauty Industry Data
  Barber & cosmetology exam pass rates, booth rent with open chairs, and Texas licensee counts

Badge for your README

[![AptLynx](https://aptlynx.net/badge/ai.cueframe/cueframe.svg)](https://aptlynx.net/servers/ai.cueframe/cueframe)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents