# Kapwing MCP MCP

> Kapwing automates video and image rendering pipelines directly from your agent. Instead of manual uploads or clicking through web interfaces, you define complex media projects using structured JSON data. Your AI client initiates the render job, monitors its progress in real-time, and retrieves final assets—all without leaving your coding environment.

## Overview
- **Category:** marketing-automation
- **Price:** Free
- **Tags:** video-automation, media-rendering, content-creation, video-api, automated-editing

## Description

You're automating video production via natural conversation. This MCP lets your agent handle the entire rendering workflow for you, from project definition to final file download. You feed it a JSON structure describing layers, text placements, and dimensions. It kicks off the render job and provides a unique ID for tracking. Your agent then polls that status until the asset is ready, giving you immediate notification or the direct URL to the completed media. Need to check what assets you've already made? You can list all previous renders in one shot. This saves time when scaling content production—whether you’re building a feature into an app or just churning out localized social media videos. It brings professional media rendering power into your command line, and Vinkius makes connecting it to any of your agents simple.

## Tools

### create_render
Starts the render process for a new project based on provided dimensions and layers.

### get_render_status
Checks the current status of a specified asset ID and returns the download URL if processing finished.

### list_renders
Retrieves an account history containing all previously created media assets.

## Prompt Examples

**Prompt:** 
```
List all my recent Kapwing renders.
```

**Response:** 
```
I've retrieved your render history. You have 3 recent renders: 'render_abc123' (Completed), 'render_def456' (Processing), and 'render_ghi789' (Completed). Would you like the download link for any of these?
```

**Prompt:** 
```
Check the status of render ID 'render_550e8400'.
```

**Response:** 
```
The render 'render_550e8400' is currently completed. You can download the final file here: [URL].
```

**Prompt:** 
```
Create a new 1080x1920 render with a text layer saying 'New Collection' and a video background.
```

**Response:** 
```
I've initiated the render with your specifications. The new Render ID is 'render_998877'. I'll monitor it for you, or you can check back in a few minutes.
```

## Capabilities

### Initiate complex renders
Send a project definition (including dimensions, text, and video layers) to start an automated render job.

### Check job status
Get the current processing state of any specific media asset ID and download link when complete.

### Review asset history
List all previously created and archived renders associated with your account.

## Use Cases

### Need to update 50 social media ads with new branding?
The Content Manager asks the agent: 'Run `create_render` five times, changing only the text layer and image asset for each market.' The system processes the JSON definitions, starts all jobs, and then polls using `get_render_status` until every ad is ready.

### Building a new feature that needs dynamic video assets.
The developer uses the MCP to call `create_render` when the user clicks 'Generate Video Preview.' The agent monitors the status, and once finished, it passes the download URL back to the frontend for display.

### Auditing all past media output.
The ops team runs `list_renders` to generate a manifest of every asset created in the last month. This helps them identify which templates are being used most often and where assets were stored.

## Benefits

- Start renders with `create_render` using structured JSON. You don't need to manually upload files or set dimensions; you just pass the data.
- Track job progress reliably. Use `get_render_status` to poll for updates, so your agent knows exactly when the asset is ready for download.
- Maintain a complete record of all work. Run `list_renders` anytime to see every project generated and manage your media history in one place.
- Write content pipelines that scale. Instead of repeating manual steps for different markets, define template renders once and automate the loop.
- Integrate rendering into code. Developers can treat video generation like any other backend service call, making complex assets part of a simple workflow.

## How It Works

The bottom line is, your AI client manages the entire state machine for you; you just tell it what media to build.

1. Connect the MCP to your preferred AI client and provide the required Kapwing API Key.
2. Tell your agent what media you need. The agent sends a JSON project definition using `create_render`.
3. Your agent tracks progress by calling `get_render_status` until the asset is marked 'Complete,' then retrieves the download URL.

## Frequently Asked Questions

**How can I check if my video render is finished?**
You can use the `get_render_status` tool by providing your unique Render ID. The agent will return the current status (e.g., 'completed') and the download URL if it's ready.

**Can I start a new render using a JSON project definition?**
Yes! Use the `create_render` action. You just need to provide the project object containing dimensions and layers. You can also specify a `webhookUrl` for automated notifications.

**Is it possible to see a history of all my renders?**
Absolutely. The `list_renders` tool fetches all renders associated with your authenticated account, allowing the AI to summarize or find specific past projects.

**How do I authenticate my account when using list_renders or create_render?**
You must provide your Kapwing API Key in the initial setup. This key authorizes every operation, whether you're listing existing assets or starting a brand new render job.

**If my project JSON structure is incorrect, how does create_render handle the error?**
The MCP will return a specific error code detailing exactly what went wrong. You need to check the API documentation for required formatting details regarding dimensions or layer definitions.

**Can I set up webhooks when managing my media assets?**
Yes, you can provide a specific URL for notifications. This means Kapwing sends an alert directly to your endpoint the second processing finishes, eliminating the need for manual status checks.

**Does create_render support multiple video and text layers simultaneously?**
Yes, the project definition handles complex layering within one call. You define dimensions, background videos, and any number of text or visual overlays in a single JSON payload.

**After running list_renders, what is the next step to check a specific render's status?**
First, use `list_renders` to get the unique ID for your asset. Then, pass that specific ID into the `get_render_status` tool to track its progress or retrieve the download link.