A Shotstack MCP for rendering video on a schedule, not by hand
Connect one Shotstack API key and 20 nodes land on the canvas across all three of its APIs: save and render templates, submit an edit and poll it to done, pull the durable CDN copy rather than the temporary one, ingest footage from a URL, and mint a signed upload URL for a browser. An agent can fill a template's merge fields from a record, submit the render, wait for it, and hand the finished link to the next step.
What the Shotstack MCP connector does
The Shotstack connector for Mattering Automations is 20 nodes: 10 read and 10 act, of which three are flagged destructive. They span all three of Shotstack's APIs. Edit carries templates (list, get, create, update, delete), the two render submissions, the render status poll, and media inspection. Serve carries the hosted assets, reachable by render, by source or by rendition, plus a transfer into hosting and an asset delete. Ingest carries source files, a server-side fetch from a URL, a signed direct-upload URL and a source delete. One credential covers all three, and nothing in any config panel asks which API a node belongs to, because choosing the node has already chosen it.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. That matters more here than on a typical connector, because video rendering is the kind of job nobody wants to sit and watch. An agent can pick the template with Shotstack: List Templates, submit it with merge fields through Shotstack: Render Template, and a scheduled branch can poll Shotstack: Get Render Status until it reads done and then collect the durable file with Shotstack: Get Assets By Render.
Two structural facts shape the whole connector and both are worth knowing before the first workflow. The first is that Shotstack runs two environments, a sandbox called stage and a production one, with a SEPARATE key for each. A key issued for one environment does not authenticate against the other. So the environment is part of the credential rather than a field on each node: a per-node setting could disagree with the key it is used with, and the only symptom would be a 401 that reads as a broken connector rather than as two settings contradicting each other. The default is the sandbox, because a wrong default that produces a watermarked test video costs nothing while a wrong default that spends production credits is not recoverable.
The second is that renders are asynchronous, and this connector models that honestly rather than hiding it inside a node that blocks. Shotstack: Render Video and Shotstack: Render Template return a render id immediately and the file does not exist yet. Shotstack: Get Render Status is what a workflow polls and branches on: the status moves from queued through fetching, rendering and saving to done, and any of those can become failed instead. Only done populates the output URL and only failed populates the error. There is no wait node here on purpose, because a node that blocked for minutes would hold a worker and would have to invent its own timeout policy, while a poll loop built from the platform's own scheduling and branching keeps its interval visible and adjustable.
One connection, three surfaces
- Visual automations. Drag Shotstack nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Shotstack node, ready to drop on the canvas
20 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 10
Shotstack: Get Asset
Look up one hosted asset by its own id and read its CDN url, filename, region and status. Asset status is ready or deleted. Reach for this when you already hold an asset id; if you hold a render id instead, Shotstack: Get Assets By Render is the node you want.
Shotstack: Get Assets By Render
Get the CDN-hosted files a render produced. This is the honest last step of a render workflow: the url on the render status response is a temporary file, and the url here is the durable CDN copy. Returns an ARRAY, because one render can emit several files - the video plus a poster image or thumbnail if the output asked for them. Note the Serve API uses the JSON:API envelope, so paths read data.data[].attributes.url, not data.response. Only meaningful once the render status is done.
Shotstack: Get Assets By Rendition
Get the hosted asset for one rendition - a transcode produced from an ingested source, such as a 720p copy of a 1080p upload. Use it when a workflow needs the smaller version's CDN url rather than the original's.
Shotstack: Get Assets By Source
Get the hosted assets belonging to an ingested source file. Use it to turn a source id from the Ingest API into the CDN url a clip should point at. Returns an array in the JSON:API envelope.
Shotstack: Get Render Status
Check where a render has got to. This is the node a workflow polls and branches on. data.response.status moves queued -> fetching -> rendering -> saving -> done, and any state can become failed instead; only done means data.response.url holds a playable file, and only failed populates data.response.error. Poll on an interval of several seconds rather than continuously: the Edit API allows 300 requests per minute in production and 150 in the sandbox, and a tight loop on one long render can spend a real share of that. The url returned here is a TEMPORARY file (Shotstack documents 24-hour storage) - take the durable CDN copy from Shotstack: Get Assets By Render.
Shotstack: Get Source
Get one ingested source file: its Shotstack-hosted url, the original input url it came from, its width, height, duration and frame rate, and any renditions produced from it. Poll this after Shotstack: Fetch Source File until data.data.attributes.status is ready - the lifecycle is queued, importing, ready, failed, and a source that is not ready cannot be used in an edit. Renditions carry their own per-rendition status, which lags the source's.
Shotstack: Get Template
Fetch one template in full, including the entire stored edit at data.response.template. Use this to read a template's timeline before rendering it, or to copy an existing edit into a new template.
Shotstack: Inspect Media File
Read the technical metadata of a media file at a public URL, using FFprobe: duration, width and height, frame rate, codecs, bitrate and the audio and video streams it contains. Renders nothing and costs nothing. Run it before building a timeline so clip lengths can be computed from the real duration instead of guessed. The file must be reachable by Shotstack without authentication.
Shotstack: List Sources
List the source files ingested into this account, with each file's hosted url, dimensions, duration, frame rate and ingest status. This is the node the source pickers in other Shotstack nodes read from. Sources persist until deleted, unlike render output. Uses the JSON:API envelope, so paths read data.data[].attributes.source.
Shotstack: List Templates
List every saved template on the account, with its id, name and timestamps. This is the node the template pickers in other Shotstack nodes read from, and it is also the cheapest way to confirm a credential works: no parameters, no ids, and it renders nothing. Templates are per environment, so a sandbox credential lists sandbox templates only.
Action nodes 10
Shotstack: Create Direct Upload URL
Get a signed URL that a browser or script can PUT a file straight to, without ever seeing the API key. This node does NOT upload anything: it returns the signed url and its expiry at data.data.attributes, and something else does the PUT. Use it when the file lives on a user's machine rather than at a public URL; when it already has a URL, Shotstack: Fetch Source File is simpler. After the PUT completes, poll Shotstack: Get Source with the returned id until the status is ready.
Shotstack: Create Template
Save an edit as a reusable template. Creating a template renders nothing and costs nothing; it just stores the JSON. Put handlebars placeholders such as {{ FIRST_NAME }} in the timeline and Shotstack: Render Template can then fill them in per render, which is how one design becomes many personalized videos. Returns the new template's id at data.response.id.
Shotstack: Delete Asset
DESTRUCTIVE AND IRREVERSIBLE. Delete a hosted asset from Shotstack storage. The CDN url stops working immediately, which breaks every page, email or post already pointing at it, and there is no trash and no undo. The only way back is to render the video again, which costs credits again. Returns 204 with an empty body.
Shotstack: Delete Source
DESTRUCTIVE AND IRREVERSIBLE. Delete an ingested source file and the renditions made from it. There is no trash and no undo: the footage has to be uploaded or fetched again, and any saved template or timeline referencing its hosted url starts failing at render time rather than at delete time, which is the worst place to find out. Videos already rendered from it are unaffected. Returns 204 with an empty body.
Shotstack: Delete Template
DESTRUCTIVE AND IRREVERSIBLE. Delete a template and the edit stored in it. Shotstack keeps no version history and no trash, so the JSON is gone unless you saved a copy, and any workflow that renders by this template id starts failing. Videos already rendered from it are unaffected. Returns 204 with an empty body.
Shotstack: Fetch Source File
Pull a video, image, audio or font file from a URL into Shotstack storage so edits can use it without refetching it every render. Shotstack downloads the URL server-side. ASYNCHRONOUS: the response carries only the new source id at data.data.id, and the file is not usable until Shotstack: Get Source reports status ready. Optionally asks for renditions (smaller transcodes) at the same time. Ingested files are stored until deleted.
Shotstack: Render Template
Render a saved template, optionally substituting merge fields into its placeholders. ASYNCHRONOUS in exactly the same way as Shotstack: Render Video: it returns a render id at data.response.id and nothing else, and the workflow polls Shotstack: Get Render Status from there. This is the node a bulk personalization workflow loops over: one template, one merge array per recipient. SPENDS PLAN CREDITS per render, and there is no cancel.
Shotstack: Render Video
Submit an edit to be rendered into video, audio or an image. ASYNCHRONOUS: this returns a render id immediately and the file does not exist yet. Feed data.response.id to Shotstack: Get Render Status and poll until the status is done or failed, then take the durable CDN copy with Shotstack: Get Assets By Render. SPENDS PLAN CREDITS: on a production credential this consumes render minutes and can bill the account, generative AI clip types cost extra credits even in the sandbox, and Shotstack documents no way to cancel a queued render, so a mis-triggered render is money spent rather than a mistake undone. Sandbox renders are watermarked and capped at ten minutes.
Shotstack: Transfer File To Hosting
Copy a file from a URL into Shotstack hosting or on to a configured destination, without rendering anything. Shotstack fetches the URL server-side, so the file never passes through this automation. ASYNCHRONOUS: the response comes back with status queued, and Shotstack: Get Asset reports when it is ready. Useful for putting a finished third-party file behind the same CDN as your renders.
Shotstack: Update Template
Replace a template's name and stored edit. This is a PUT, so it OVERWRITES: send the whole edit, not a fragment, because whatever is omitted is gone. Shotstack keeps no version history, so fetch the current template first if you need to be able to put it back. Renders already submitted from the old version are unaffected.
Connecting Shotstack takes one credential
Keys come from the Shotstack dashboard, and signing up issues one for each environment. Shotstack sends the key in its own header rather than as a bearer token, and there is no signature, no account id and no OAuth step. The credential therefore has two parts: the key itself, and a choice of environment, sandbox or production, which defaults to sandbox. That second field is not a convenience. Shotstack issues a separate key per environment and a key issued for one does not authenticate against the other, so the environment is a property of the key, and pairing the wrong two produces a 401 that looks like a broken integration. Plan and environment gating are worth reading before you design around this catalog. In the sandbox, output is watermarked and a render is capped at ten minutes, Shotstack's own key documentation states that only AI assets are charged there, and its limits documentation notes that at least one credit is required to use the sandbox at all. Renders in production spend plan credits on every submission, generative AI clip types cost extra credits even in the sandbox by Shotstack's own note, and Shotstack documents no way to cancel a queued render, so a mis-triggered render is money spent rather than a mistake undone. Rate limits are per key and per sixty-second window and differ by API and environment: Shotstack documents 300 in production and 150 in sandbox on Edit, 600 and 300 on Serve, and 300 and 120 on Ingest, answering over the limit with HTTP 429. The realistic way to hit that is a tight poll loop on a long render, so leave several seconds between polls.
Sign in to the Shotstack dashboard and copy the API key for the environment you want to start in. The sandbox key is the safe place to begin: its output is watermarked, so nothing you render by accident is publishable, and nothing standard is charged there.
In Mattering Automations, open Connectors, click Add Connector, choose Shotstack, and create a credential with that key.
Set the environment on the credential to match the key you pasted. This is the field most worth getting right first time: a key issued for one environment does not authenticate against the other, and a mismatch shows up only as a 401.
Click Test Connection. Mattering lists templates on the Edit API for the credential's own environment, which is the only parameterless read on the surface and costs no render time. A pass proves the key, the header and the environment segment together. Note what it does not prove: Serve and Ingest are separate path prefixes with their own routing, so run one read from each before trusting them.
All 20 Shotstack nodes appear in the canvas palette. Run Shotstack: List Templates first, then Shotstack: List Sources, so you have confirmed two of the three APIs before anything renders.
Common uses for the Shotstack MCP
Personalized video from a template and a record
Shotstack: Create Template stores an edit as reusable JSON with handlebars placeholders in it, which costs nothing and renders nothing. Shotstack: Render Template then substitutes merge fields into those placeholders and submits the job, so one saved edit becomes a per-customer, per-property or per-listing video without the workflow assembling a timeline each time. The template picker on those nodes reads from Shotstack: List Templates and shows each template's name with the time it was last updated underneath, which is the detail that matters when two copies share a name. The rest of the workflow is the usual asynchronous shape: keep the render id, poll, then collect.
A render that finishes without anyone watching it
This is the pattern the whole connector is built around. Shotstack: Render Video submits an edit and returns a render id immediately, then Shotstack: Get Render Status is polled on a schedule until the status reads done or failed. Only done carries the output URL and only failed carries the error, so read the status first and branch, rather than reading the URL on every pass and getting nothing. Two numbers help size the loop: Shotstack documents render time at roughly twenty seconds per minute of video, more with effects, filters or transitions, and its rate limits are per key and per sixty-second window, so a tight loop on a long render is the realistic way to earn a 429. Several seconds between polls is the honest interval.
Collect the durable file rather than the temporary one
The most common way a finished Shotstack workflow still breaks is storing the wrong link. The URL on the render status response is a temporary file, and Shotstack documents temporary storage measured in a day rather than forever, so a workflow that writes it into a CRM record has stored a link that stops working tomorrow. Shotstack: Get Assets By Render is the honest last step: it returns the CDN-hosted files that render produced, which is the durable copy. Shotstack: Get Asset, Shotstack: Get Assets By Source and Shotstack: Get Assets By Rendition reach the same hosting by other routes when you hold an asset, source or rendition id instead.
Bring footage in once and reuse it every render
Shotstack: Fetch Source File pulls a video, image, audio or font file from a URL into Shotstack storage so edits can point at it without refetching it every render, and Shotstack fetches it server-side so no bytes pass through the automation. It is asynchronous like everything else here, so poll Shotstack: Get Source until the ingest status reads ready. That status is worth branching on rather than assuming: a source that is still importing cannot be used in an edit yet, and renditions carry their own status which lags the source's, so a source can be ready while its smaller transcode is not. Shotstack: List Sources is what the source pickers elsewhere in the connector read from, and it shows each file's ingest status on the picker line for exactly this reason.
Let a browser upload straight to Shotstack
Shotstack: Create Direct Upload URL returns a signed URL that a browser or a script can PUT a file to without ever seeing the API key, along with its expiry. The node itself uploads nothing, which is the point: the bytes go from the user's machine to Shotstack directly, and the automation only ever handles the URL. One documented detail belongs in the same breath: text formats such as subtitle and caption files need either a filename on the request or a content type set on the PUT, or the type cannot be detected.
Check a media file before spending a render on it
Shotstack: Inspect Media File reads the technical metadata of a file at a public URL: duration, dimensions, frame rate, codecs, bitrate and the audio and video streams it contains. It renders nothing. Putting it in front of a render is the cheapest guard available on this connector, because it answers the questions that otherwise fail a job late: whether the clip is as long as the timeline assumes, whether the aspect ratio matches the output, and whether the file is reachable at all. That last one matters more than it sounds, because every URL Shotstack fetches has to be publicly reachable without authentication, and a signed or expiring URL that opens fine in your browser can fail server-side.
Example: Render a personalized clip when a record lands, and store the link that lasts
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a new row appears in a Mattering database, or a webhook arrives from your own system, carrying the name, the headline and the image URL for one video.
Shotstack: Inspect Media File checks the image or clip the edit will use. It renders nothing and costs no credits, and a condition stops the run and opens a task if the file is unreachable or the wrong shape, before anything is spent.
Shotstack: Render Template submits the saved template with those merge fields and returns a render id. Nothing exists yet at this point: the response is an id and a queued status, so piping it into an email would email a UUID.
A scheduled branch polls Shotstack: Get Render Status every few seconds. The workflow branches on the status rather than on the URL, since only done populates the output link and only failed populates the error, and it gives up into a task rather than polling forever, because a long edit can take minutes.
Shotstack: Get Assets By Render collects the CDN-hosted file once the status reads done. This is the durable copy; the URL on the status response is temporary and would break the record that stored it.
The CDN URL lands on the originating record and a notification goes out. Nothing in the run deletes anything, so the three destructive nodes stay out of an automated path entirely.
Shotstack MCP questions, answered
What Shotstack operations are supported?
20 nodes across all three APIs: 10 reads and 10 actions. On Edit, list and get templates, create, update and delete a template, submit a render from an edit or from a template, poll a render's status, and inspect a media file at a public URL. On Serve, get the assets produced by a render, by a source or by a rendition, get one asset by its own id, transfer a file into hosting, and delete an asset. On Ingest, list and get sources, fetch a source file from a URL, create a signed direct upload URL, and delete a source. Deliberately not included: a node that blocks until a render finishes, because a poll loop belongs in the workflow where its interval is visible, and the browser-embedded editor SDK, which is not an HTTP API. Generative AI assets do not have separate nodes because Shotstack does not document them as a separate API: they are clip types written into an ordinary render's timeline, so they are reached through Shotstack: Render Video.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.
Shotstack publishes its own MCP server. Why use this connector?
It does, documented in Shotstack's own guide with a tools reference, and for some jobs a vendor server is the better answer. If what you want is an assistant that helps you write Shotstack edits inside your editor or your own client config, use Shotstack's server. This connector is shaped for production instead: the same 20 nodes run as steps on an automation canvas as well as over MCP, so a render can be submitted off a trigger or a schedule with nobody present, polled to completion by the workflow, and its durable URL written straight onto the record that caused it. They chain in one workflow with every other connector in the catalog, hold the credential once in a shared workspace store rather than in each person's local config, and carry destructive flags you can gate on. Neither replaces the other, and nothing here disparages Shotstack's own tooling.
Why does the environment live on the credential instead of on each node?
Because the environment is a property of the key rather than of the job. Shotstack issues a separate key for its sandbox and production environments, and a key issued for one does not authenticate against the other. A per-node environment field would create a state where the node says one thing and the credential holds the other, and the only symptom would be a 401, which reads as a broken connector rather than as two settings disagreeing. So one credential carries both the key and its environment, and the default is the sandbox. The trade-off is worth stating plainly: a connector resolves one credential per organization, so running sandbox and production side by side means switching the environment on the connection rather than picking per node. That is a real friction for a develop-then-ship workflow, and it is the deliberate cost of removing a permanent invisible misconfiguration risk.
Is the sandbox free?
Close, with two conditions worth stating precisely rather than rounding off. Signing up issues keys for both environments, sandbox output is watermarked, and a sandbox render is capped at ten minutes. Shotstack's own key documentation states that in the sandbox only AI assets are charged, so an ordinary render there does not consume plan credits, while generative AI clip types do cost credits even in the sandbox. Separately, Shotstack's limits documentation notes that at least one credit is required to use the sandbox at all. So the sandbox is the right place to build and test, and it is not quite the same thing as an account that has never had a credit on it. Check Shotstack's own pricing page for what your plan includes rather than taking a figure from us.
Can an AI agent delete something I cannot get back?
Three nodes are flagged destructive so you can gate them, and none of them has a trash or an undo. Shotstack: Delete Template removes the stored edit, and since Shotstack keeps no version history the JSON is gone unless you saved a copy, while any workflow rendering by that template id starts failing. Shotstack: Delete Asset stops the CDN URL working immediately, which breaks every page, email or post already pointing at it, and the only way back is to render again, which costs credits again. Shotstack: Delete Source removes ingested footage and the renditions made from it, and that one usually surfaces LATER, at render time, in a saved template that referenced the hosted URL. Keep agents on the read nodes and the render nodes, and put all three deletes behind a condition or an approval task. Two more nodes deserve care without being destructive: the render submissions spend credits on every call and Shotstack documents no cancel endpoint, so a mis-triggered render is money spent rather than a mistake undone.
Why is my render URL broken a day later?
Because you stored the temporary one. The URL on the render status response is a temporary file, and Shotstack documents temporary storage measured in a day. The durable copy is the CDN asset, which is what Shotstack: Get Assets By Render exists to return. The rule that avoids this entirely is to treat the status response as a signal rather than a result: poll it until the status reads done, then make one more call to collect the asset, and write THAT link into whatever record or message the workflow is producing. The same applies to anything published: an asset URL is what belongs in an email or on a page, never the temporary render output.
What are the rate limits, and how do I stay under them?
Shotstack documents its limits per API key, per sixty-second window, and per API, with different figures for production and sandbox: 300 and 150 on Edit, 600 and 300 on Serve, and 300 and 120 on Ingest. Over the limit answers HTTP 429. In practice there is only one realistic way to hit that from an automation, and it is a tight poll loop on a long render. Since Shotstack documents render time at roughly twenty seconds per minute of video and more with effects, leave several seconds between polls and give the loop an overall ceiling that opens a task rather than one that gives up silently. Note that the three APIs have separate buckets, so a busy ingest job does not eat the budget a render poll needs.
Does Mattering receive Shotstack's render callback?
No, and that is worth being explicit about because the failure it causes is silent. The render submissions and the ingest fetch all accept a callback URL, and it is genuinely useful, but it points at an endpoint YOU control, not at anything this connector listens on. Pointing it at a Mattering inbound webhook trigger is the supported way to turn a finished render into the start of another workflow. Otherwise, poll Shotstack: Get Render Status. If you do use a callback, Shotstack documents the retry behaviour and it is aggressive: any response outside the success range, or slower than ten seconds, counts as a failure, and it retries up to ten times with backoff over roughly the following hour.
Put Shotstack to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Shotstack is a product of its respective owner; Mattering is an independent platform.