How to integrate Shotstack MCP with Claude Agent SDK

Connect Claude Agent SDK to Shotstack MCP. Create a video slideshow from uploaded images, generate a branded video intro with logo, and more using natural language, with authentication handled for you.

Shotstack logoShotstack
Api Key

Shotstack is a cloud platform for programmatically generating videos, images, and audio. Automate creative content production at scale with flexible RESTful APIs.

23 Tools

Introduction

This guide walks you through connecting Shotstack to the Claude Agent SDK using the Composio tool router. By the end, you'll have a working Shotstack agent that can render videos, check render status, create and update templates, upload and inspect media, and fetch generated assets through natural language commands.

This guide will help you understand how to give your Claude Agent SDK agent real control over a Shotstack account through Composio's Shotstack MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Shotstack with

TL;DR

Here's what you'll learn:
  • Get and set up your Claude/Anthropic and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Shotstack
  • Configure an AI agent that can use Shotstack as a tool
  • Run a live chat session where you can ask the agent to perform Shotstack operations

What is Claude Agent SDK?

The Claude Agent SDK is Anthropic's official framework for building AI agents powered by Claude. It provides a streamlined interface for creating agents with MCP tool support and conversation management.

Key features include:

  • Native MCP Support: Built-in support for Model Context Protocol servers
  • Permission Modes: Control tool execution permissions
  • Streaming Responses: Real-time response streaming for interactive applications
  • Context Manager: Clean async context management for sessions

What is the Shotstack MCP server, and what's possible with it?

The Shotstack MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Shotstack account. It provides structured and secure access to powerful video, image, and audio automation features—so your agent can create dynamic media content, edit assets, manage rendering jobs, and retrieve results at scale on your behalf.

  • Automated video and image generation: Let your agent assemble and render videos or images programmatically using templates, custom assets, and dynamic data.
  • Media editing and composition: Enable your agent to cut, trim, overlay, and combine media clips—adding text, transitions, or audio tracks as needed.
  • Batch rendering and job management: Have your agent submit, track, and manage multiple rendering jobs, so you can scale creative automation for campaigns or client deliverables.
  • Asset and template organization: Allow your agent to upload, list, and organize reusable templates and media assets, keeping your creative workflow streamlined.
  • Result retrieval and download: Automatically fetch completed renders and download media files, making finished content instantly available for distribution or review.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and Claude/Anthropic API Key
  • Primary know-how of Claude Agents SDK
  • A Shotstack account
  • Some knowledge of Python
2

Getting API Keys for Claude/Anthropic and Composio

Claude/Anthropic API Key
  • Go to the Anthropic Console and create an API key. You'll need credits to use the models.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

npm install @anthropic-ai/claude-agent-sdk @composio/core dotenv

Install the Composio SDK and the Claude Agents SDK.

What's happening:

  • @composio/core provides Composio integration for Anthropic
  • @anthropic-ai/claude-agent-sdk is the core agent framework
  • dotenv/config loads environment variables
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID identifies the user for session management
  • ANTHROPIC_API_KEY authenticates with Anthropic/Claude
5

Import dependencies

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

dotenv.config();
What's happening:
  • We're importing all necessary libraries including the Claude Agent SDK and Composio
  • The dotenv.config() function loads environment variables from your .env file
  • This setup prepares the foundation for connecting Claude with Shotstack functionality
6

Create a Composio instance and Tool Router session

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });

  // Create Tool Router session for Shotstack
  const session = await composio.create(USER_ID, {
    toolkits: ['shotstack'],
  });
  const mcpUrl = session?.mcp.url;
What's happening:
  • The function checks for the required COMPOSIO_API_KEY environment variable
  • We're creating a Composio instance using our API key
  • The create method creates a Tool Router session for Shotstack
  • The returned url is the MCP server URL that your agent will use
7

Configure Claude Agent with MCP

const options: Options = {
  permissionMode: 'bypassPermissions',
  mcpServers: {
    composio: {
      type: 'http',
      url: mcpUrl,
      headers: { 'x-api-key': COMPOSIO_API_KEY }
    }
  },
  systemPrompt: 'You are a helpful assistant with access to Shotstack tools via Composio.',
  maxTurns: 10,
};
What's happening:
  • We're configuring the Claude Agent options with the MCP server URL
  • permissionMode: 'bypassPermissions' allows the agent to execute operations without asking for permission each time
  • The system prompt instructs the agent that it has access to Shotstack
  • maxTurns: 10 limits the conversation length to prevent excessive API usage
8

Create client and start chat loop

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}
What's happening:
  • The readline interface is created to handle user input and output
  • The query function is used to send the user's input to the agent
  • The chat loop continues until the user types 'exit' or 'quit'
9

Run the application

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}
What's happening:
  • The chat function is the entry point for the application
  • The try-catch block is used to handle any errors that occur

Complete Code

Here's the complete code to get you started with Shotstack and Claude Agent SDK:

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });
  const session = await composio.create(USER_ID, {
    toolkits: ['shotstack']
  });
  const mcp_url = session?.mcp.url;

  const options: Options = {
    permissionMode: 'bypassPermissions',
    mcpServers: {
      composio: {
        type: 'http',
        url: mcp_url,
        headers: { 'x-api-key': COMPOSIO_API_KEY }
      }
    },
    systemPrompt: 'You are a helpful assistant with access to Shotstack tools via Composio.',
    maxTurns: 10,
  };

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}

Conclusion

You've successfully built a Claude Agent SDK agent that can interact with Shotstack through Composio's Tool Router.

Key features:

  • Native MCP support through Claude's agent framework
  • Streaming responses for real-time interaction
  • Permission bypass for smooth automated workflows
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

Every Shotstack action and event your agent gets out of the box.

Create Template

Create a named Shotstack template from timeline and output settings for reuse in media editing and rendering.

Create Template (v2)

Tool to save an Edit as a re-usable template.

Delete Ingested Media

Delete an ingested source file from the production Ingest API by its ingest ID.

Delete Template

Delete a Shotstack template by ID in the stage environment.

Delete Shotstack Workflow

Tool to delete a specific Shotstack workflow.

Fetch Source

Queue a remote media file for ingestion as a source asset in the production Ingest API.

Get Asset

Retrieve details of a hosted asset by asset ID in the Shotstack staging environment, including videos, images, audio files, thumbnails, and poster images.

Get Assets by Render ID

Retrieve hosted assets by render ID in the Shotstack staging environment, including files such as video, thumbnail, and poster images.

Get Render Callback

Request callback details for a specific render job, including the callback URL and delivery status, attempts, response and last-attempt time.

Get Render Status

Retrieve the status and details of a Shotstack render job by render ID in the selected environment.

Get Source Details

Retrieve details and status of a source asset by ID from the production Ingest API.

Get Template

Retrieve a template's details and metadata by ID from the Shotstack staging environment.

Get Template By Version

Tool to retrieve a template by template id and API version.

Get Upload URL

Tool to request a signed URL for direct file upload to Shotstack.

Inspect Media

Tool to inspect media metadata.

List Sources

Request a list of ingested source assets from the production Ingest API, with optional pagination parameters.

List Sources (with Environment)

Tool to list all ingested source files with environment selection.

List Templates

List Shotstack templates for the account in the stage environment.

List Templates with Environment

Tool to list all Shotstack templates for the specified environment.

Request Upload URL

Request a signed URL for direct file upload to the Shotstack staging environment.

Render Video

Tool to initiate a new video render job.

Transfer Asset

Transfer a file from a publicly available URL to one or more production Serve API destinations, including Shotstack hosting or other configured destinations.

Update Template

Update a stage-environment template by ID, providing both its name and complete edit configuration.

FAQ

Frequently asked questions

Start with Shotstack.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Shotstack tool your agent needs.Free to start.

Start building