# Clipwright [Health: Active]

**Category:** 🎥 Multimedia Process  
**Repository:** https://github.com/seocombat/clipwright-mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 5618  
**Views:** 2  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/clipwright-2

## Description
Talking-actor and faceless short videos from your AI agent, with a free quote before each render

## Tools
Capabilities this server exposes over MCP:

- **list_workflows** — List seven workflow methods and their current availability. Free and read-only. Five methods use native executors; website-proof-demo and kinetic-launch remain execution_blocked. Availability is not account-specific permission to buy.
- **get_workflow** — Read one workflow method by method_id: required inputs, script rules, evidence, limitations and current availability. Free and read-only. Use the returned method and capability digests in a plan.
- **prepare_workflow_plan** — Create or save a workflow plan without paying or starting a run. Supply the complete document. Omit both plan_id and base_version to create; supply both to save a revision. The document is strict and bounded to 256000 JSON bytes. Preserve exact accepted narration. After a lost save answer, read and compare the saved document; do not automatically approve or purchase.
- **plan_reference_remake** — Compile a reference remake into a new workflow plan without paying or starting a run. Free. Pass the reference_profile of the ad to remake, the accepted script (copied unchanged), actor_id, a voice and optional ready ast_* assets. The server lays the script on the reference beats and picks templates, captions and sounds; its warnings name everything the plan does not reproduce. Nothing is generated: make missing media separately with generate_image or generate_video, each with its own quote, and compile again. Then approve, quote and run the plan as any other.
- **get_workflow_plan** — Read the current account-owned plan, revision, content digest, readiness issues and warnings. Free and read-only. The document is intent; it is not a delivered video or creative acceptance.
- **approve_workflow_plan** — Explicitly approve the chosen plan revision and content_digest. Free; it stores approval but starts no run. Read all issues and warnings first. Approval is separate from a quote and a paid launch.
- **quote_workflow_plan** — Quote the approved current plan without spending credits. Free and read-only. Show the native price and every warning before requesting a paid launch. The returned quote_id expires and binds the exact revision and semantic input. Its launch is the ready run_workflow_plan body, with a fresh idempotency_key.
- **run_workflow_plan** — Start one explicitly approved paid workflow run: pass the launch object of its quote unchanged (revision, content_digest, semantic_input_digest, quote_id and idempotency_key). Over REST, send the header Idempotency-Key equal to launch.idempotency_key; this tool sets it for you. Returns immediately with its captured receipt and native run_id; poll get_run. Never auto-approve, auto-quote or invent a new key. If delivery is uncertain, recover with the original request and key; a new key can pay twice. Technical evidence is separate from human creative acceptance. Price: the price of the native run it starts, make_ugc or make_faceless, as its quote states it. Quote first with quote_workflow_plan; list_prices names every price.
- **make_ugc** — Start generation of a lip-synced UGC video. Give a script within the selected speech model's text limit; the actor comes from actor_id (a saved actor from list_actors) or image, otherwise the default actor is used. Format and resolution follow the request and the source, defaulting to 1080x1920. Captions are OPT-IN: ask the user first. Fields the renderer does not honor yet carry a NOT HONORED YET note in their own description — read it instead of guessing. Call quote_ugc before generating and show the cost. This does NOT wait for the video: it starts the run and returns a run_id IMMEDIATELY. You MUST then poll get_run with that run_id until the state is 'succeeded' (video_url) or 'failed'. A 'failed' run whose paid vendor job we still hold can go back to 'queued' and reach 'succeeded' later; whenever that happens it is named in warnings[]. Pass attempt=2,3,… to deliberately start a NEW run for the same input (retry after a failure). Price: HeyGen presenter: presenter, HeyGen Avatar IV 12 credits per second the presenter is in the video, covered or not plus production (voice and render) 1 credits per second of video plus live avatar on a call 400 credits per call still in the video, at least 50; OmniHuman presenter: presenter, OmniHuman 2.0 22 credits per second the presenter is in the video, covered or not plus production (voice and render) 1 credits per second of video plus live avatar on a call 400 credits per call still in the video, at least 50. Quote first with quote_ugc; list_prices names every price.
- **get_run** — Check the status of a video generation started by make_ugc or make_faceless, or of a generate_image or generate_video run. Pass the run_id. While the run is still working it returns status IN_PROGRESS with a next_action telling you to poll again; repeat every ~5 seconds until it reaches a terminal state — SUCCEEDED (with video_url, or generation.url for generate_image and generate_video) or FAILED.
- **get_run_shots** — Read the shots of a video made by make_faceless or make_ugc. Pass the run_id. Free and read-only: it changes nothing and starts nothing. With planned=true the answer holds the frame size, the frame rate, the narration words with their timing, and for each shot its id, its span in frames, its kind, the words it covers, its description and preview_url, a signed link to the shot's source picture or clip. That link is a large file and it expires: read the shots again for a fresh one, never store it. A field named in `withheld` is null on every shot. planned=false is a normal answer, not an error: the run has no shots to show, and editable.state with editable.reason says why. editable.media_available_until is how long the media of the run are stored. paid_edits.enabled says whether a video can be made from an edit; while it is false, none can.
- **quote_revision** — Price a revision of a run WITHOUT spending credits: what it would change (summary) and what it costs (billing.total_credits). Pass run_id and exactly one of changes or document, the same as revise_run. Always call this first and show the user the price before revise_run. A revision that delivers is charged its quoted total; one that fails is charged nothing, even when its paid work was already done. While paid edits are closed it answers editing_disabled and charges nothing.
- **revise_run** — Start a revision of a run made by make_faceless (paid): a NEW run that renders the video again with the shots you change, by changes (a shot and what to generate for it) or by document (the whole edited document); pass exactly one. Call quote_revision first and show the user the price. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to start a second revision with the same request on purpose, pass attempt 2. A revision that delivers is charged its quoted total; one that fails is charged nothing, even when its paid work was already done. An original has a limit on revisions running at once and on revisions failed or unfinished, and paid edits of it close some days after it finished; a refusal names which. While paid edits are closed it answers editing_disabled and charges nothing. The result is a new run: poll it with get_run; once it succeeded it is editable under its own run_id. Price: each shot generated anew: picture 7, clip 49, clip with a new picture 56; plus 13 to render. A revision that generates nothing: 13. A kept candidate adds nothing. Quote first with quote_revision; list_prices names every price.
- **quote_candidate** — Price one shot candidate of a run WITHOUT spending credits: one picture or clip made for one shot, to keep or discard in a revision. Pass run_id, shot_id and operation, the same as create_candidate; the answer names the unit, its credits and usable_until, the last moment the candidate can enter a revision. Always call this first and show the user the price before create_candidate. A delivered candidate is charged its one unit whether it is kept or discarded; one that fails is charged nothing, even when its paid work was already done. While shot candidates are closed it answers editing_disabled and charges nothing.
- **create_candidate** — Make a shot candidate of a run made by make_faceless (paid): a NEW run of skill edit_shot that generates one picture or clip for one shot, to keep or discard in a later revision. Call quote_candidate first and show the user the price. A delivered candidate is charged its one unit whether it is kept or discarded; one that fails is charged nothing, even when its paid work was already done. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to make another candidate with the same request on purpose, pass take 2. An original has a limit on candidates running at once and on candidates failed or unfinished, apart from its revisions; a refusal names which. While shot candidates are closed it answers editing_disabled and charges nothing. The result is a new run: poll it with get_run; once it succeeded, its candidate.preview_url shows what was made. Price: picture: 7 credits per image; clip: 49 credits per clip; clip with a new picture: 56 credits per clip. Quote first with quote_candidate; list_prices names every price.
- **list_generation_models** — List the models generate_image and generate_video take, each with its modes, aspect ratios, resolutions, durations, output width and height, and unit_credits: credits per image, or per second of a clip. Only measured combinations are listed; any other is refused with unsupported_combination before any charge. Free.
- **quote_image** — Price one generate_image call WITHOUT spending credits: its credits (one image at its model's unit_credits), its width and height, and warnings. Always call this first and show the user the price before generate_image. A reference is {upload_id, rights_confirmed: true} for a picture from upload_image or create_upload (rights_confirmed states you may use the people and works in it), {run_id} of a succeeded generate_image run of this account until its reusable_until, or {asset_id} of a picture asset from create_asset, whose rights were confirmed when it was made. A generation that fails is charged nothing, even when the vendor was already paid. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to make another one with the same request on purpose, pass attempt 2. While generations are closed it answers generations_disabled or generations_marking_pending and charges nothing.
- **generate_image** — Generate one image from a prompt (paid): a NEW run of skill generate_image, charged the quoted credits per image once it is delivered. Call quote_image first and show the user the price. Poll the run with get_run; once it succeeded, generation.url is the image and its run_id can be a reference of a later generation. A reference is {upload_id, rights_confirmed: true} for a picture from upload_image or create_upload (rights_confirmed states you may use the people and works in it), {run_id} of a succeeded generate_image run of this account until its reusable_until, or {asset_id} of a picture asset from create_asset, whose rights were confirmed when it was made. A generation that fails is charged nothing, even when the vendor was already paid. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to make another one with the same request on purpose, pass attempt 2. While generations are closed it answers generations_disabled or generations_marking_pending and charges nothing. Price: seedream-5.0-flash: 6 credits per image; flare: 8 credits per image. Quote first with quote_image; list_prices names every price.
- **quote_video** — Price one generate_video call WITHOUT spending credits: its credits (unit_credits per second of duration_s), its width and height, and warnings. Always call this first and show the user the price before generate_video. A reference is {upload_id, rights_confirmed: true} for a picture from upload_image or create_upload (rights_confirmed states you may use the people and works in it), {run_id} of a succeeded generate_image run of this account until its reusable_until, or {asset_id} of a picture asset from create_asset, whose rights were confirmed when it was made. A generation that fails is charged nothing, even when the vendor was already paid. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to make another one with the same request on purpose, pass attempt 2. While generations are closed it answers generations_disabled or generations_marking_pending and charges nothing.
- **generate_video** — Generate one silent clip (paid): a NEW run of skill generate_video, charged unit_credits per second of duration_s once it is delivered. Modes: text; first_frame (first_frame, optional last_frame, of the requested aspect ratio within 2%); reference (1 to 4 references). Call quote_video first and show the user the price. Poll the run with get_run; once it succeeded, generation.url is the clip. A reference is {upload_id, rights_confirmed: true} for a picture from upload_image or create_upload (rights_confirmed states you may use the people and works in it), {run_id} of a succeeded generate_image run of this account until its reusable_until, or {asset_id} of a picture asset from create_asset, whose rights were confirmed when it was made. A generation that fails is charged nothing, even when the vendor was already paid. An identical request returns the same run it started before, so a call repeated after a lost answer starts nothing new; to make another one with the same request on purpose, pass attempt 2. While generations are closed it answers generations_disabled or generations_marking_pending and charges nothing. Price: 6 to 173 credits per second of clip, by model and size. Quote first with quote_video; list_prices names every price.
- **quote_ugc** — Estimate the credit cost of a make_ugc call WITHOUT spending credits. Always call this first and show the user the price before make_ugc.
- **upload_image** — Get an upload_id and a signed https url for a PNG or JPEG up to 10 MB: from a LOCAL file (`path`, only when this server runs on your machine) or from a public https `url` that the server downloads (up to 20 seconds; redirects are followed up to 3 times). Pass the url as `image` to quote_ugc / make_ugc, and the upload_id as {upload_id, rights_confirmed: true} in references, first_frame or last_frame of quote_image, generate_image, quote_video and generate_video. The url is signed for 24 hours; the upload_id stays usable for 30 days. For workflow assets, use the upload_id as asset_id and content_digest directly: it is the SHA-256 of the original bytes. Set `aspect_ratio` EXPLICITLY to match the picture. For a file on your disk while this server is remote, use create_upload. Free: spends no credits; 20 uploads per day per account, and at most 30 url downloads per hour.
- **create_upload** — Upload a LOCAL PNG or JPEG (up to 10 MB) through a one-time presigned PUT; use it when this server is remote and you have a shell. Pass media_type, the exact size in bytes and the file's sha256 (`sha256sum <file>` or `shasum -a 256 <file>`). Within 15 minutes run: `curl -X PUT -H 'content-type: <media_type>' --data-binary @<file> '<put_url>'` (curl sends the content-length itself; both headers must match what you declared). Once the PUT finished, the upload_id works as {upload_id, rights_confirmed: true} in quote_image, generate_image, quote_video and generate_video; before that they answer upload_not_finished. Call get_upload to confirm and to read content_digest, width and height; other tools that take an upload_id need that call first. Use the upload_id within 24 hours. Free; counts toward 20 uploads per day.
- **get_upload** — Read one upload by upload_id: a freshly signed https url, content_digest, media_type, bytes, width, height and usable_until. After create_upload it also confirms the PUT: it answers upload_not_finished until the file is there and upload_expired after 24 hours. Free.
- **create_asset** — Save a picture or a clip as an asset of this account, kept until you delete it: a character, location, style, prop or other, with a name. source is {run_id} of a succeeded generate_image or generate_video run of this account, {upload_id} of an upload from upload_image or create_upload, a public https {url} the server downloads (add kind: "video" for an MP4), {base64, media_type} of a PNG or JPEG up to 700000 bytes, or {put: {media_type, bytes, sha256}} to PUT a local file yourself: the answer carries upload.put_url and put_headers; run `curl -X PUT -H 'content-type: <media_type>' --data-binary @<file> '<put_url>'` within 15 minutes, then call get_asset. On a server running on your machine also {path} of a local PNG, JPEG or MP4. A clip is an MP4 in h264 or hevc, up to 120 seconds and 100 MB; a url clip or a PUT is checked in the background, so the answer says state: "processing" (or "awaiting_upload") and get_asset says ready or failed within minutes. For your own material (upload_id, url, base64, put, path) pass rights_confirmed: true, which states once that you may use the people and works in it. A reference you only want analysed, such as someone else's ad for analyze_reference, takes analysis_only: true instead: no rights claim, and no render or generation ever takes it. Use a picture's asset_id as {asset_id} in references, first_frame or last_frame of quote_image, generate_image, quote_video and generate_video; clips are kept for assembly and are no generation reference yet. Assets are free: creating, storing and using one spends no credits. An account keeps up to 2000 assets and 20 GB, and makes up to 100 new ones per day.
- **list_assets** — List the assets of this account, newest first, each with a freshly signed url, its role, name, size and content_digest; filter by role and kind, and pass next_cursor as cursor for the next page. pending lists assets still awaiting their upload or processing, and those that failed today with the reason. usage says how much of the 2000 assets and 20 GB is used. Free.
- **get_asset** — Read one asset by asset_id with a freshly signed url (valid for an hour), its role, name, media_type, bytes, width, height, content_digest and, for a clip, duration_frames, fps, codec and pix_fmt. An asset still in progress answers state awaiting_upload (PUT the file, then read again) or processing (read again in a few seconds); a refused one answers state failed with error.code. A deleted asset answers asset_not_found. Free.
- **update_asset** — Rename an asset or change its role; the picture itself does not change. Free.
- **delete_asset** — Delete an asset by asset_id. It leaves the list at once and a new generation can no longer use it; its file is removed from our storage by a daily cleanup once 7 days have passed. Runs already made with it stay as they are. Free.
- **quote_analysis** — Price analyze_reference for an asset before starting it: credits_estimate is what a start holds and charges once it succeeds, 0 when the asset already has an analysis that a start would answer (replays_analysis_id). Free; starts nothing.
- **analyze_reference** — Read a reference ad into a reference_profile: its beats (role, timing as shares of the clip, whether the presenter speaks, listens or is off screen), the graphics in our template vocabulary, captions, pacing, palette and music. What we cannot draw is in unmapped with a substitute and in warnings. Pass asset_id of an MP4 asset (create_asset with kind: "video"), at most 120 s and 100 MiB; there is no url input. 70 credits are held at the start and charged once it succeeds; a failed analysis costs nothing. 10 new analyses per hour per account. Answers at once with state queued; call get_reference_analysis every 10 seconds until succeeded (about a minute) or failed. The same asset returns the same analysis, free, unless it failed. The asset is not changed. The profile names techniques; it copies no face, voice, music or brand of the reference. Price: 70 credits per call. Quote first with quote_analysis; list_prices names every price.
- **get_reference_analysis** — Read an analysis started by analyze_reference: state queued or analyzing, succeeded with reference_profile and warnings, or failed with error.code and error.message (timed_out, analysis_failed, asset_gone, enqueue_failed); credits_charged is the price once succeeded, 0 once failed. Free.
- **list_voices** — List the voices for the `voice` field of make_ugc, or of make_faceless with skill=make_faceless. Without `skill` the list holds the make_ugc voices only. Each voice names the one skill that speaks it in `skill`, and the other skill refuses it before any charge. skill=make_faceless lists the 17 narration voices of make_faceless (kind faceless_voice, each with a language and a gender; without voice it speaks narrator_en_wise_lady; it takes no voice_id). The rest of this text is about the make_ugc voices: the presets first, then the 30 voices of gemini-3.8-flash-tts (kind model_voice), then catalog voices in 31 languages. Filter by `language` (the voice's native language; any voice speaks any supported language), `gender`, `age`, `use_case` and `model`; an unknown filter value is refused with the allowed values. Pick a voice by `name` (e.g. voice="george"); a name always means the same voice. A model_voice voice is spoken only by its `model`: naming it selects that model, it has no language of its own and matches the languages measured on the model, and its gender is listed only where it is known. `voice_id` is an escape hatch for a raw vendor voice id that is not listed, such as a cloned voice. Without voice or voice_id the default voice follows the actor's gender: sarah for a woman, george for a man, taken from actor_id or from actor_gender next to image. With image and no actor_gender the voice is george and a warning says so: pass the gender of the person in the photo as actor_gender (ask the user only when you cannot tell), or pick a voice here. Keep any voice the user chose. A voice with `preview_url` has a short-lived audio sample spoken by that voice with that model; play it to the user before a paid render instead of judging a voice by its description. A model_voice sample is in English, or in the language you filter by. It expires at `preview_expires_at`: call this tool again for a fresh link, never store it. A voice without `preview_url` has no sample yet. `words_per_second` is an English voice's measured pace; eleven_v4 has no speed setting, so to match a reference presenter pick the voice nearest its pace. Free. Script limits by speech model: eleven_v3: 5000 characters; eleven_flash_v2_5: 10000 characters; eleven_turbo_v2_5: 10000 characters; eleven_v4: 5000 characters; gemini-3.8-flash-tts: 5000 characters. Count includes spaces, audio tags and stress marks; emoji may count as two characters. Break tags are cut from the text sent to eleven_v4 and gemini-3.8-flash-tts and are not counted there. There is no word-count limit. Duration and price are estimates until measured.
- **list_template_sounds** — List the sounds make_ugc templates play, by beat: where each beat plays, its default and every name it takes. A run plays the defaults; template_sounds { beat: name } swaps a beat's sound, and template_sounds=false plays none. The edit beat plays on every cut only with make_ugc edit_sounds=true. Sounds never change the price. Free.
- **list_actors** — List saved Clipwright actors with stable IDs, gender, age and verified image formats. Choose actor_id for quote_ugc and make_ugc. Preview URLs expire; actor IDs remain reusable. Do not combine actor_id with image, person or actor_gender. Without voice, the actor speaks the default voice of their gender.
- **get_actor_defaults** — Read this account actor's saved B-roll default. Saved policy for B-roll: anyone allows people including the actor; no_actor excludes the actor; no_people excludes all people, including hands. Segmented media generation is closed. This setting is stored only and has no effect on actor-only videos. Run override wins over the account actor default; otherwise no_people.
- **set_actor_defaults** — Save this account actor's B-roll default without spending credits. Saved policy for B-roll: anyone allows people including the actor; no_actor excludes the actor; no_people excludes all people, including hands. Segmented media generation is closed. This setting is stored only and has no effect on actor-only videos. Run override wins over the account actor default; otherwise no_people.
- **create_actor** — Create a personal actor for this account from words describing a fictional adult: a 9:16 portrait with exactly one face, plus the other requested formats edited from it. Returns a run_id immediately; poll get_run until 'succeeded' (created_actor.actor_id, then pass it as actor_id to make_ugc) or 'failed'. Each published image is charged at the price quote shows; refused descriptions and unusable portraits cost nothing. When generation is switched off the call fails with actor_generation_disabled. With from_actor_id it derives a new personal actor from a library or own actor: the same face (checked; a mismatch costs nothing), with framing wide, objects in holding or a new setting. A held object's picture is an image asset (upload, URL import or a found picture, rights_confirmed). Price: medium portrait: 4 credits per image; medium other format: 8 credits per image; high portrait: 12 credits per image; high other format: 18 credits per image. Quote first with quote_actor; list_prices names every price.
- **quote_actor** — Estimate the credit cost of create_actor WITHOUT spending credits. Call this first and show the price before create_actor: each requested format is a separate charged image.
- **make_faceless** — Start a paid finished faceless video from a script or brief. You select 30–90 seconds; the video ends with its narration, runs at least 25 seconds and at most a quarter past the selection, never beyond 90. The video has an opening animated clip and image scenes. Captions are on by default and can be turned off. Call quote_faceless first and show the user the price. This does NOT wait for the video: it starts the run and returns a run_id IMMEDIATELY. Then poll get_run with that run_id until the state is 'succeeded' (video_url) or 'failed'. Pass attempt=2,3,… to deliberately start a NEW run for the same input. Price: generated picture 7 credits per image plus opening clip 49 credits per clip plus production (story, voice and render) 1 credits per second of video, at least 50. Quote first with quote_faceless; list_prices names every price.
- **quote_faceless** — Estimate the credit cost of make_faceless WITHOUT spending credits. Always call this first and show the user the price before make_faceless.
- **delete_actor** — Delete a personal actor of this account by actor_id. Videos already made with it stay as they are, and new runs can no longer use it. An actor used by a run that has not finished is refused until that run ends. Catalog actors belong to Clipwright and are not deletable.
- **get_account** — Read this account's credits. Free, spends nothing. debt_credits above zero means make_ugc is refused with debt_outstanding whatever the balance, until the account buys credits; with no debt, balance_credits is what a new run can spend. holds_credits are reserved for runs still in progress and settle when they finish. grants lists unexpired credit grants. quote_ugc already warns when make_ugc would be refused; this tool gives the numbers behind it.
- **list_prices** — List what every Clipwright tool costs in credits. Free, spends nothing. Each entry names the tool, its REST route and its price: lines of credits per unit (call, second of video, second the presenter is in the video, image, clip, second of clip), added up, with minimum_credits when there is one; or, where the price depends on the input, a formula. Free tools cost 0. For the exact number of a paid call, use the quote tool the entry names.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "clipwright": {
    "command": "npx",
    "args": ["-y","-p","@clipwright/mcp-server","clipwright-mcp"],
    "env": {
      "CLIPWRIGHT_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `CLIPWRIGHT_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What Clipwright MCP server does

Clipwright turns a script into either a talking-actor video or a faceless short video. Actor-led generation uses a selected or default actor, speech settings, and optional source imagery. Faceless workflows combine narration with an opening animated clip and image scenes. The API returns the finished file rather than publishing it to a social platform.

The server also supports standalone image and silent video generation, reusable account assets, uploads, reference-based remake planning, and inspection of the shots used in a completed video. Quotes, workflow plans, approvals, and status checks are free; generation and rendering consume credits when successful.

## How it works

Paid operations follow a quote-first sequence. For UGC, image, video, workflow, revision, and shot-candidate operations, the agent requests a quote, presents the cost, and starts the paid action only after the required approval step. Workflow plans add explicit revision, approval, content-digest, and idempotency checks before a paid launch.

Generation is asynchronous. Tools such as `make_ugc`, `make_faceless`, `generate_image`, and `generate_video` return a run ID immediately. The agent then calls `get_run` repeatedly, typically about every five seconds, until the run succeeds with a URL or reaches a failed state. Failed or uncertain requests should be recovered with the original idempotency information rather than a newly invented request key.

## Setup and configuration

The published MCP package runs over stdio and requires Node.js 20 or newer. Add it to an MCP host with the Clipwright API key:

```bash
claude mcp add clipwright -e CLIPWRIGHT_API_KEY=cw_... -- npx -y -p @clipwright/mcp-server clipwright-mcp
```

Replace the example value with a key from the Clipwright account. The repository also provides a Claude Code plugin that connects to the hosted endpoint at `https://mcp.clipwright.io/mcp`, and a Cursor plugin configuration. Claude Code, Claude Desktop, Cursor, Cline, and other MCP hosts can use the stdio package.

## Tools and capabilities

- Inspect workflow methods, requirements, evidence, limitations, and availability with `list_workflows` and `get_workflow`.
- Create, revise, approve, quote, and launch workflow plans with the workflow planning tools.
- Quote and start UGC or faceless renders, then inspect their runs and shots.
- Generate images and silent clips using supported models, modes, aspect ratios, resolutions, and durations.
- Upload PNG or JPEG files, create reusable assets, list or update them, and delete them.
- Create shot candidates or paid revisions for eligible faceless runs.
- Read signed media URLs, content digests, dimensions, frame data, narration timing, and generation results.

## Limitations and notes

Credits are spent by successful paid renders and other paid generation operations, so the quote tools should be called first. Supported model combinations are explicitly listed; unsupported image or video combinations are refused before charging. Captions for UGC are opt-in, and renderer fields marked as not yet honored should not be assumed to affect output.

Uploads have size, format, expiry, and rate limits. Local files require the appropriate upload method when the MCP server runs remotely. References containing people or creative works require rights confirmation for generation; analysis-only assets are not usable for rendering. Signed URLs expire and should be refreshed by reading the relevant upload, asset, or shot again. Clipwright returns generated files but does not publish them.

_Full upstream README: https://allmcps.com/mcp/clipwright-2/readme_