# Transloadit MCP

> Transloadit handles complex file pipelines right inside your conversation. Need to resize an image, convert a video to MP4, or run a batch process? This MCP lets your AI agent manage everything—from creating new processing templates to triggering full assemblies and checking status in real time. It’s the single point for all media encoding and file manipulation.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** file-processing, media-encoding, file-upload, image-resizing, video-transcoding, api-pipeline

## Description

This MCP connects your AI client directly to Transloadit's massive file processing engine. You can treat complex workflows like simple conversations. Instead of jumping through a web UI, you tell your agent what needs doing: 'Take these three files, resize them, encode the video, and give me the status.' The system handles starting a new assembly, monitoring its progress, and even canceling it if something goes wrong. You can also manage reusable workflows by creating or updating templates first, so you don't have to rebuild the process every time. Being housed in the Vinkius catalog means your agent gets access to this powerful pipeline management capability alongside thousands of others.

## Tools

### cancel_assembly
Stops a background file processing job immediately if it needs to be aborted or corrected.

### create_assembly
Starts a brand new, multi-step process for transforming and encoding one or more files.

### create_template
Defines a reusable blueprint of file transformations so you can run the same complex process repeatedly.

### delete_template
Permanently removes a processing template that is no longer needed in your system.

### get_assembly
Checks the current status and retrieves the final output link for a specific file job ID.

### get_bill
Retrieve billing information for a specific month

### get_me
Check API connectivity and get account context

### get_template
Retrieve details for a specific template

### list_assemblies
List all file processing assemblies

### list_templates
List all reusable processing templates

### replay_assembly
Re-run a completed assembly

### update_template
Update an existing template

## Prompt Examples

**Prompt:** 
```
List all available Transloadit templates.
```

**Response:** 
```
You have 2 templates: 'Video to MP4' (ID: 99a1) and 'Image Resize 500px' (ID: 99a2).
```

**Prompt:** 
```
Check the status of Assembly ID 88392.
```

**Response:** 
```
Assembly 88392 is 'COMPLETED'. The processed file is available at the output URL.
```

**Prompt:** 
```
Cancel the processing for Assembly ID 99120.
```

**Response:** 
```
Assembly ID 99120 has been successfully canceled and removed from the queue.
```

## Capabilities

### Start and Monitor Processing Jobs
Your agent can launch a file assembly, track its status (running, complete, failed), and retrieve the final results directly through conversation.

### Manage File Templates
You can build and store reusable processing blueprints by creating or updating templates so your agents run consistent workflows repeatedly without manual setup.

### Control Running Assemblies
If a job goes off track, you can tell the agent to stop it immediately using the cancel_assembly tool.

## Use Cases

### Processing Campaign Assets
A marketing manager needs 50 images resized and optimized for Twitter, Instagram, and Facebook. They ask their agent to use the MCP with a pre-defined template, which executes `create_assembly` for all five sizes simultaneously. The agent reports back when every single file is complete.

### Handling Video Content
A video editor finishes a raw 4K video and needs it converted to MP4 for web use. They tell their agent, which uses the MCP to `create_assembly` with an encoding template. The agent then monitors the job using `get_assembly`, providing a link once the file is ready.

### Debugging Pipeline Failures
A data engineer runs a complex batch job and it fails halfway through. Instead of manually checking logs, they ask their agent to use `list_assemblies` to find the failing ID, then use `get_assembly` to diagnose exactly where the process stopped.

### Standardizing User Uploads
A system needs user-submitted profile pictures to be resized and watermarked. The agent uses `create_template` to define this exact process once, and then any time a new file arrives, it simply calls `create_assembly` against that template.

## Benefits

- Automate repetitive file tasks. Instead of manually resizing images or encoding videos, your agent can create and manage entire assemblies using `create_assembly` in a single chat prompt.
- Ensure consistency across all assets. Use the `create_template` tool to define standard processing rules—like 'all logos must be 500px'—so every new file follows the exact same steps.
- Maintain control over resources. If an assembly gets stuck or uses too many resources, you can use `cancel_assembly` to stop it immediately without having to navigate a dashboard.
- Track everything instantly. When you need to know if a large batch job finished correctly, simply call `get_assembly` and get the status and results back in text form.
- Re-run jobs when needed. If the source files change slightly or an assembly fails for a minor reason, use `replay_assembly` instead of starting from scratch.

## How It Works

The bottom line is that you define a complex workflow once using templates and let the AI handle the execution and status checks.

1. First, your agent uses `list_templates` or `create_template` to define the exact file processing steps needed (e.g., 'resize image and convert video').
2. Next, you invoke `create_assembly`, passing the files and the template ID; this starts the actual background work.
3. Finally, your agent uses `get_assembly` or `replay_assembly` to check if the job succeeded, retrieve the output file link, or re-run it.

## Frequently Asked Questions

**How do I start a file processing job with Transloadit?**
You use the `create_assembly` tool. You need to provide the files you want processed and specify which template defines the steps.

**Can Transloadit handle video encoding?**
Yes, it handles media tasks including video transcoding, allowing your agent to encode videos into formats like MP4 through assembly creation.

**What if a job fails? How do I fix it with Transloadit?**
First, use `get_assembly` to check the failure reason. If the source files are okay, you can try running the process again using `replay_assembly`.

**Does Transloadit require me to manage templates manually?**
No, while you use tools like `create_template`, your agent manages the storage and retrieval of these reusable blueprints for you.