Turn an e-commerce product into a short-form vertical video ad — import the product, draft and edit the creative plan, render it, and collect the result.
Manage brands — list the account's brands and brand limit (list_brands), create a brand from a detected storefront identity (create_brand), or attach a product to an existing brand, optionally overwriting that brand's voice/market/keywords (set_product_brand).
Import products — scrape a product page URL (import_product_from_url), or build a product from hosted photo URLs plus a name when there's no page (create_product_from_images).
Read a product — poll import status, see the detected facts, current video direction, credit cost, and all videos generated from it (get_product).
Write and edit the plan — draft a fresh creative direction from the product facts and brand voice (redraft_video_direction), or edit fields directly: creative direction, creator note, aspect ratio (9:16, 3:4, 16:9, 1:1), resolution (480P–1080P), audio on/off, target market (update_video_direction).
Render the video — launch a render using the current direction and settings, which spends credits (generate_video).
Collect the output — poll render status and get the MP4 download URL plus a public share link, or the failure reason (get_video).
Free until render — importing, drafting and editing cost nothing; only generate_video charges, and failed renders are refunded.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@instantclips Turn this product link into a short vertical video"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
InstantClips turns an e-commerce product into short-form vertical video for TikTok, Instagram Reels and Stories. It runs a hosted MCP server, so Claude Code, Codex, Cursor, VS Code, the Claude app, ChatGPT or any other MCP client can do what the web app does: import a product, draft the plan, and generate the video.
This is not a text-to-video generator. InstantClips reads the product page — photos, price, details — and builds the ad from what is actually there. The plan is written first and shown to you; the video follows the plan. That is why it is cheap enough to run across a catalogue, and why the result is the product you sell rather than a guess at it.
Free to start: the welcome credits cover the first video, and there is no card to enter. After that, one-time credit packs, or an Agency membership for anyone running several brands. See pricing.
Where it fits. Beside a scheduler (Postiz, Buffer) that posts what comes back. Beside an attribution tool that tells you which hook worked. Instead of an editor when you have a product page and no footage.
Not for. Cinematic hero films. A presenter reading your script. Horizontal 4K. Products with no page and no photos.
Built for. Shopify sellers, dropshippers, brands and agencies running social for several stores at once.
The product server stays hosted. This repository contains its connection guide, registry metadata, example HTTP client and a small open-source stdio adapter for clients that cannot connect to a remote server directly. The adapter answers initialization, ping and tool discovery from a generated snapshot, then sends authenticated tool calls to the hosted endpoint. The hosted server remains the source of truth; the product implementation is not duplicated here.
Endpoint |
|
Transport | Streamable HTTP, stateless |
Method |
|
Auth | Sign in when your client asks (OAuth 2.1), or |
Paste one address into your assistant and sign in when it asks. That is the whole setup. The first time it calls, the server sends you to sign in to InstantClips and approve the assistant; there are no keys to copy. Every assistant you approve is listed under Authorized apps in settings, where you can disconnect it.
The connection is to your own account: same brands, products, credits and plan limits as the web app. Signing in creates an account if you do not have one, with credits for the first video.
Opening the endpoint in a browser returns the setup page rather than a protocol error, with one-click install buttons for Cursor and VS Code.
Related MCP server: fortax-demo-shoot
Connect to the hosted endpoint directly whenever your client supports Streamable HTTP; it takes you through sign-in on first use. Use a token and the stdio adapter (under "No browser?" below) only for scripts and automated runners that cannot open a sign-in page.
Paste this into Claude Code, Codex or any agent that runs commands. It adds InstantClips itself, then tells you how to sign in:
Set me up with InstantClips by following the instructions at https://app.instantclips.ai/mcp.mdThe instructions it follows are app.instantclips.ai/mcp.md: the commands below, one section per client.
claude mcp add --transport http --scope user instantclips https://app.instantclips.ai/mcpThen run /mcp inside Claude Code and choose instantclips to sign in. --scope user adds it to
every project; without it, Claude Code adds a server only to the folder you run the command in.
codex mcp add instantclips --url https://app.instantclips.ai/mcpIt adds InstantClips to ~/.codex/config.toml, which the Codex CLI, the Codex IDE extension and the
ChatGPT desktop app all read, and opens your browser to sign in. codex mcp login instantclips
starts the sign-in again.
One-click install buttons are on the setup page. They open the app, add InstantClips, and sign you in on first use.
In Customize › Connectors, select + › Add custom connector, paste
https://app.instantclips.ai/mcp and select Add.
Select Connect and sign in to InstantClips.
In a conversation, turn InstantClips on under + › Connectors.
On a Team or Enterprise plan, an owner adds it first under Organization settings › Connectors, and each member then connects it in Customize › Connectors.
On chatgpt.com, turn on Developer mode in Settings › Security and login.
Open chatgpt.com/plugins, select + and create an app for
https://app.instantclips.ai/mcp with OAuth, then sign in to InstantClips when asked.
In a conversation, choose Developer mode from the + menu and select InstantClips.
On a Business, Enterprise or Edu workspace, an admin creates the app under Workspace settings › Apps › Create and publishes it for the workspace.
In ChatGPT, attach the product photos to the conversation and ask for the video: the plugin takes
attachments directly (image_files on create_product_from_images, add_image_files on
update_product), so photos need no adapter and no token there.
Menu names are the apps' own as of September 2026. If they have moved, Claude's custom connector guide and OpenAI's developer mode guide have the current ones.
OpenClaw, Hermes, or an agent you wrote yourself: point it at the address over Streamable HTTP. The server announces its sign-in flow the standard way, so a client that follows the spec needs nothing else. Anything that cannot open a sign-in page uses a token instead, below.
Scripts, CI jobs and agents that cannot open a sign-in page authenticate with a long-lived token instead. Mint one at app.instantclips.ai/settings#ai-access. It gives full access to your account, so keep it out of anything you commit.
With a token, the same clients look like this:
# Claude Code
claude mcp add --transport http --scope user instantclips https://app.instantclips.ai/mcp --header "Authorization: Bearer YOUR_TOKEN"# Codex, in ~/.codex/config.toml
[mcp_servers.instantclips]
url = "https://app.instantclips.ai/mcp"
http_headers = { Authorization = "Bearer YOUR_TOKEN" }To keep the token out of the Codex file, swap the header for bearer_token_env_var = "INSTANTCLIPS_TOKEN"
and export it in your shell instead. Any other client sends an Authorization: Bearer header.
Nothing on the wire is InstantClips-specific. The chat apps always have a browser to sign in with,
so they use the steps above rather than a token.
The instantclips-mcp npm package is a thin stdio-to-HTTPS adapter. It serves initialization and
tool discovery locally for a fast, credential-free cold start, then reads the token from the
environment and sends tool calls to InstantClips:
{
"mcpServers": {
"instantclips": {
"command": "npx",
"args": ["-y", "instantclips-mcp"],
"env": {
"INSTANTCLIPS_TOKEN": "YOUR_TOKEN"
}
}
}
}For an automated connectivity check, including the live tool names:
INSTANTCLIPS_TOKEN="your-token" npx -y instantclips-mcp --check --jsonThe token is accepted only through INSTANTCLIPS_TOKEN, never as a command-line argument, so it
does not appear in the process list. It is required for tool calls, but not for initialize,
ping, or tools/list. Node.js 20 or newer is required.
Photos on this machine: the adapter can upload them itself, so a video can be made from files
that never left your laptop. Through the adapter, create_product_from_images takes image_paths
(paths to the files, up to 9, 8 MB each) in place of image_urls, and update_product takes
add_image_paths. The files are packaged and posted straight to InstantClips as the product's
photos — nothing is downloaded from anywhere. Drag the files into a client that hands the
assistant their paths (Claude Code, Cursor, VS Code, terminal agents) and say what you want made.
Send image_paths on its own: with hosted image_urls in the same call the adapter refuses
rather than dropping the URLs; add hosted photos afterwards with update_product.
Five to begin with. Swap in a link or a product name.
"Make a video ad for this product: [URL]"
"Import every product on this collection page and draft plans for all of them. Don't generate anything yet."
"Show me the plan for [product] and rewrite the hook to lead with the price."
"Make three videos for [URL] with three different hooks, so I can test them."
"Which of my brands is this product for? Then make the video."
The workflow, in order:
Import — import_product_from_url for a store page, or create_product_from_images when
there is no page to read.
Wait for the import — poll get_product until import_status is "imported".
Choose the idea, then read the plan — offer the product's ideas, as the website does. The
user's pick, or their own words, goes in update_video_direction's creator_note, which writes
the plan; redraft_video_direction with no idea picks one for them. The plan comes back as
text for the user to review, and update_video_direction changes anything in it.
Generate — generate_video, passing expected_credit_cost: the cost the user was told, as
get_product reported it. A mismatch is refused without charging.
Collect — poll get_video until it is done, then give the user download_url, the video's
own page and its public share link.
Another video for the same product is the same flow on that product: editing or redrafting opens the
next video's draft, and generate_video with no draft renders another take of the last plan. A
generated video itself cannot be changed. Every get_product response carries next_step: what to
do now. Once the user has watched a video, rate_video records their verdict; send_feedback sends
the team a note about the tools themselves, with the user's OK.
Brands work the same way: list_brands, create_brand, set_product_brand. Every video is
drafted in a brand's voice, so an import whose storefront matches no existing brand stops and asks
rather than guessing.
Each tool's exact parameters are published by the hosted server. The generated
manifest/instantclips-mcp.json snapshot lets stdio clients and
registries inspect those same schemas without a credential. Maintainers refresh it with
npm run sync:manifest, no token needed, since the hosted server lists its tools without signing in;
npm run check:manifest fails, naming what drifted, when the committed snapshot differs from the
live server. Run python example.py tools below when you specifically
want to print the live schemas over HTTP.
Importing a product, drafting the plan and editing it are all free. generate_video is the
only tool that spends credits, and it requires your explicit go-ahead — the tools report the cost
first, and generate_video takes that number back as expected_credit_cost, refusing a launch whose
cost has changed. An agent cannot quietly run up a bill. See pricing.
A dependency-free MCP client — Python 3.9+, standard library only, no pip install. It
authenticates with a token, since a script has no browser to sign in with.
export INSTANTCLIPS_TOKEN="your-token"
python example.py tools # every tool, with its live input schema
python example.py call list_brands '{}' # call one tool with JSON argumentstools is the one to run first: it prints the real parameter names and types for every tool, which
is what you need before scripting the workflow above.
instantclips.ai/automate — what the automation is for: a real result made from a store page, starter prompts, the tools in order, and the rules. It does not repeat the setup; this file and the app's setup page are where that lives.
app.instantclips.ai/llms.txt — machine-readable description of the product and the tool sequence
server.json is this server's entry in the official MCP registry,
which the other directories ingest from. One ai.instantclips/instantclips entry carries both the
hosted endpoint in remotes and the stdio adapter in packages, so a host can choose the transport
it supports without creating two identities for the same tool surface.
The npm package's mcpName must exactly match that registry name. The repository link points to the
open-source adapter; the hosted product implementation is not in this repository.
The ai.instantclips namespace is the reverse-DNS of the domain, which requires publishing under
DNS or HTTP domain auth rather than GitHub auth. Authenticating with GitHub instead would force the
entry into io.github.instantstudioai/... and give up the branded namespace.
Publish the npm package first, then re-publish this same registry entry with
mcp-publisher publish after bumping its version. Domain authentication keeps the branded
ai.instantclips namespace; do not replace it with an io.github.* name. The signing key stays out
of the repository — .gitignore covers *.pem, and a committed private key is a published one.
npm is published from GitHub Actions, not from a laptop. Commit the version bump (package.json,
server.json, and the pins in test/shim.test.js), then push a tag named for it
(git tag v1.7.2 && git push origin main v1.7.2); .github/workflows/publish.yml runs the tests
and publishes through npm's trusted publishing, with no npm token and no browser confirmation. The job stops if the tag does not match package.json's version. The package's
trusted publisher on npmjs.com names this repository and publish.yml, so renaming the workflow
file breaks publishing.
A new version can take several minutes to appear on npm, and the registry refuses an entry whose
npm version it cannot find ("version … was not found"; nothing changes). Run the mcp-publisher
step once https://registry.npmjs.org/instantclips-mcp/<version> answers.
Log in and publish in one command — the registry token expires five minutes after login — and the
domain is verified over HTTP, not DNS: instantclips.ai/.well-known/mcp-registry-auth on the marketing site
serves this key's public half (v=MCPv1; k=ed25519; p=…), and there is no TXT record, so
login dns fails with "no MCP public key found".
mcp-publisher login http --domain instantclips.ai \
--private-key "$(openssl pkey -in key.pem -text -noout | awk '/priv:/{f=1;next} /pub:/{f=0} f' | tr -d ' :\n')" \
&& mcp-publisher publishtest/shim.test.js pins the snapshot's server version and server.json's version; a release
moves both.
glama.json is the separate, Glama-specific file that claims the listing there. A server under an
organisation rather than a personal account can only be claimed with that file present.
It carries ownership only. In Glama's Dockerfile form, use build steps
["npm install --omit=dev"], CMD arguments ["node", "./bin/instantclips-mcp.js"], and any dummy
value for the required INSTANTCLIPS_TOKEN placeholder. Glama's initialization and tool-quality
checks use the bundled manifest and never transmit that placeholder upstream. Do not put a real
account token into a third-party build sandbox.
MIT — see LICENSE. The license covers this repository's contents; use of the hosted service is governed by the Terms of Service.
Create a new brand from the identity detected on a product that is
waiting on brand_decision_required, and attach the product to it.
Use this when the product belongs to a company the account has no brand
for yet — the usual case when someone brings a new store. The brand's
voice, target market and keywords are taken from what the storefront
scrape drafted; the user can rename it with name.
Ask the user before calling this. It consumes one of the plan's brand
slots, and on a plan that has run out this fails with a brand-limit
error — at which point the choices are to attach the product to an
existing brand with set_product_brand, to re-point an existing brand
at this identity with set_product_brand and replace_identity: true,
or to upgrade.
Once this returns, the video direction starts drafting: poll
get_product until video_direction.drafting is false.
This does not spend credits.
Inputs: product_id (required), name.
Start a new InstantClips product from hosted product photos, for a product that has no public page to scrape.
Images must be publicly reachable URLs — this endpoint cannot read files from the caller's machine. Images larger than 8MB are skipped; at most 9 are used in a render.
Returns immediately with a product_id; the downloads and the first
video-direction draft run in the background. Poll get_product until
import_status is "imported".
Prefer import_product_from_url when a product page exists — the scrape
also collects the name, description, price and brand identity, which
make for a far better direction draft than images alone.
This does not spend credits. Only generate_video does.
Inputs: name (required), image_urls (required), brand_id, description, +1 more.
Render the video. THIS SPENDS THE USER'S CREDITS.
Ask the user before calling this, every time. Tell them the cost first —
get_product reports it as video_direction.credit_cost, and the
user's balance as credits_remaining. Credits are charged at launch,
not on completion; a failed render is refunded automatically.
Show the user the creative direction and let them approve or edit it before you call this. Do not call it to "see what happens", to retry a render that is still in progress, or as part of a batch you decided on your own.
Returns as soon as the render is queued. Poll get_video with the
returned video_request_id every 20-30 seconds until its status is
"done" (a few minutes), then give the user output_url and
share_url.
If the account cannot afford it, nothing is charged and the response says so — tell the user to top up at the credits page rather than retrying.
Inputs: product_id (required).
Read a product: what the import found, the current video direction and settings, and every video generated from it.
Use this to poll after import_product_from_url or
create_product_from_images. The product is ready to work with when
import_status is "imported" AND video_direction.drafting is false.
Poll every 20-30 seconds; the whole thing normally settles inside a
minute.
import_status values: "pending" and "importing" mean keep polling;
"imported" means done; "failed" means it did not work and
import_failed_reason says why.
video_direction.credit_cost is what generate_video will charge for
the current settings.
Inputs: product_id (required).
Check one video's render.
status values:
"generating" — still rendering, keep polling every 20-30 seconds.
"done" — finished; output_url is the MP4 and share_url is a
public page to send someone.
"failed" — failed_reason says why. The credits were refunded
automatically; the user can retry from the product page.
"insufficient_credit" — never launched; nothing was charged.
"pending" — not launched yet; call generate_video.
A render normally takes a few minutes. Tell the user what you are waiting on rather than polling silently in a tight loop.
Inputs: video_request_id (required).
Start a new InstantClips product from a product page URL (a storefront listing, e.g. a Shopify product page).
Returns immediately with a product_id — the scrape, the image download
and the first video-direction draft all run in the background. Poll
get_product until import_status is "imported" and
video_direction.drafting is false, which usually takes under a minute.
Pasting a URL that was already imported on this account returns that existing product instead of creating a duplicate.
If the storefront name does not exactly match a brand this account has
already reviewed, the import stops on a brand decision instead of
guessing: get_product will report brand_decision_required, and no
video direction is drafted until it is resolved with create_brand or
set_product_brand. Do not assume the account's existing brand — a
product from a different company drafted under the wrong brand's voice
is the failure this prevents. Pass brand_id only when the user has
told you which brand this product belongs to.
This does not spend credits. Only generate_video does.
Inputs: url (required), brand_id.
List the brands on this account, with the plan's brand limit and whether another brand can be created.
A brand carries the identity every video is drafted against: its voice, its target market and its keywords. A product must belong to the brand it actually comes from — a product drafted under another company's voice is wrong even though it renders fine.
Call this before answering a brand_decision_required from
get_product, and whenever the user needs to choose or name a brand.
This does not spend credits.
Inputs: no named parameters.
Ask InstantClips to draft a fresh creative direction for this product's next video, using the product's facts, its images and the brand's identity. Use it to get a first draft, or to try a different angle when the user does not like the current one.
This OVERWRITES the current direction — including any edits. Confirm with the user before re-rolling a direction they have already worked on.
The draft runs in the background: this returns with drafting true, and
you poll get_product until video_direction.drafting is false (a few
seconds). Rolling a fresh angle is the point, so calling it twice gives
two different drafts, not the same one.
This does not spend credits.
Inputs: product_id (required), format.
Attach a product waiting on brand_decision_required to one of the
account's existing brands. Use list_brands to see them.
Only do this when the user has confirmed the product really belongs to that brand. Attaching a product to an unrelated brand is not a cosmetic mislabel: every video is drafted in that brand's voice, to its target market, with its keywords.
By default the brand's existing identity is left untouched. Pass
replace_identity: true to instead overwrite that brand's voice, target
market and keywords with the identity detected on this product — the
"re-point my brand at a different company" move, for an account at its
brand limit. This rewrites a brand every other product on it shares, so
confirm it with the user explicitly first.
Once this returns, the video direction starts drafting: poll
get_product until video_direction.drafting is false.
This does not spend credits.
Inputs: brand_id (required), product_id (required), replace_identity.
Edit the creative direction and render settings for a product's next video. Only the fields you pass are changed; everything else keeps its current value.
creative_direction is the plan the render is built from. It is free
text, but the drafts follow a six-section shape that works well and is
worth preserving when editing:
Hook: ... Content Focus: ... Format: ... Execution Guidelines: ... Strict Guidelines & Restrictions: ...
Do not invent a direction from nothing when one has not been drafted
yet — call redraft_video_direction and edit what comes back. Leaving
it empty is also valid: generation works without a direction.
creator_note is different and smaller: the user's own short note to
the director ("mention it is machine washable", "for Father's Day"). It
is carried through to the render verbatim, so put the user's words in
it, not your paraphrase.
Only works before generation starts. This does not spend credits.
Inputs: product_id (required), ratio, resolution, creator_note, +3 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 10 tools
Each tool targets a distinct resource/action: URL import vs image import, product read, direction edit vs direction redraft, brand list/create/assign, and video generate/poll. Even the two direction tools are clearly separated by 'edit existing' vs 'draft new' semantics.
All tool names follow a consistent snake_case verb_noun pattern, e.g. import_product_from_url, create_product_from_images, set_product_brand, generate_video. The convention is uniform and predictable across the entire set.
Ten tools is well-scoped for the product-video generation workflow. Each tool covers a distinct step in the pipeline without redundancy or bloat.
The core lifecycle is covered end-to-end: create/import a product, resolve brand decisions, draft/edit direction, generate a video, and poll for results. Minor gaps exist—no list_products or brand update/delete—but they do not create dead ends in the primary workflow.
Generate AI short-form videos and auto-publish them to TikTok, YouTube, Instagram, Facebook and X.
AI video editing + publishing: turn clips into vertical shorts, post to TikTok/Instagram/YouTube.
Make motion-design video ads and AI videos for e-commerce products from your AI assistant.
AI editor to build, animate & export layered short-form video projects via one tool catalog.
