How to Use the Shotstack MCP in LangChain

Q: How do I find past video jobs using Shotstack and LangChain?

You can use listrecentrenders to get a history of all completed render jobs. This gives you the job IDs needed to track down assets or check older statuses. It's perfect for building audit trails within your LangChain application.

Q: Can I verify asset availability using Shotstack and LangChain?

Sure thing. Before starting a render, call listingestedsources. This verifies that the necessary source material has been successfully uploaded to the system, preventing job failures down the line.

Q: How do I track a specific video job using Shotstack and LangChain?

Once you have the render ID from rendervideo, just feed it into getrenderstatus. This function tells your agent exactly where the job is in the pipeline—pending, processing, or complete.

Build complex video workflows with LangChain's multi-step reasoning using the Shotstack MCP Server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers — Included with Plan

Connect Shotstack MCP to LangChain

Create your Vinkius account to connect Shotstack to LangChain — we handle the hosting, security, and runtime updates so you don't have to. No server setup required.

GDPR Included with Plan

Setup Shotstack with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity Vinkius runs on Gemini

Gemini

Grok

Orchestrate rendering pipelines with the Shotstack MCP Server

Start by calling `render_video` to initiate a job, which immediately returns a unique render ID. Then, use that ID in subsequent steps—like checking status via `get_render_status` or listing assets with `list_assets_from_render`—to confirm the video is ready. This sequence allows your agent to build a complete workflow: ingest the source using `ingest_media_source`, trigger the render, wait for confirmation, and finally retrieve all outputs. It's pure sequential logic.

Manage asset lifecycle in LangChain

`list_hosted_assets` gives you a full inventory of every media file Shotstack stores. Before rendering, your agent can check `list_ingested_sources` to make sure all necessary assets are uploaded and available. This prevents the whole chain from failing because one source was missing. You've got tools for everything: checking templates with `list_templates`, or seeing what renders were done recently using `list_recent_renders`. It keeps the entire process visible, step by step.

Automate template creation and management

Need a new video style? You can use `create_video_template` to save an existing edit as a reusable blueprint. This means your agent doesn't have to rebuild the same structure every time; it just references the saved template. It also lets you see what templates already exist using `list_templates`. Your multi-step chain can check for a needed template first, and if it fails, then prompt the user to create one instead. Simple dependency handling.

Setup guide

Set up Shotstack MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Shotstack tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "shotstack-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Shotstack transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Shotstack. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Shotstack now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Shotstack MCP in LangChain

You can use `list_recent_renders` to get a history of all completed render jobs. This gives you the job IDs needed to track down assets or check older statuses. It's perfect for building audit trails within your LangChain application.

Sure thing. Before starting a render, call `list_ingested_sources`. This verifies that the necessary source material has been successfully uploaded to the system, preventing job failures down the line.

The primary data type this server touches is media assets and render metadata. Specifically, you are dealing with source files (video/image) and generated content IDs from tools like `render_video`.

Once you have the render ID from `render_video`, just feed it into `get_render_status`. This function tells your agent exactly where the job is in the pipeline—pending, processing, or complete.

Always use the output of one tool as the input for the next. For instance, take the ID from `render_video` and pass it directly to `list_assets_from_render`. Don't hardcode values; chain them.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript