# RenderMe MCP

> RenderMe connects your video production workflow to your AI client. You use this server to manage automated rendering jobs, track media assets, and control deployments for professional videos using natural conversation. Trigger a render job, check stats, or list available templates—all without leaving the chat.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** video-automation, motion-graphics, video-rendering, media-production, template-engine, content-creation

## Description

Your agent connects RenderMe (re.video) to your workflow, giving you full control over automated video production. You use this server to manage rendering jobs, track assets, and handle deployments just by talking to it. 

**Triggering Video Rendering:**
You start a new render using `create_video_render_job`. Just give your agent a template ID and the dynamic data—like specific text or colors—and it kicks off the job. You can also check what variables a template needs by calling `get_template_details` for a specific deployment.

**Checking Job Statuses:**
When you send that render command, you need to know where it stands. Use `get_render_job_status` with a job ID to see if the video is queued, actively rendering, or if it failed. If you want an overview, run `list_recent_render_jobs` to check out history. To monitor your account's overall usage this month, grab stats using `get_account_render_stats`. You can also verify that your connection to the RenderMe API is actually working by running `check_api_health`.

**Managing Templates and Assets:**
Before you render anything, you gotta know what you're working with. To see all the available video templates you can use for a job, call `list_video_templates`. If you need to organize your source material, run `list_asset_folders` to see all the project folders set up in RenderMe. You can also check which specific images and media files are uploaded and ready to go by using `list_uploaded_assets`. To get a rundown of every video project that's been built out on the account, use `list_video_projects`. Finally, if you need external systems notified when things change, list all active webhooks connected through `list_configured_webhooks`.

**Account Information and Context:**
Your agent can pull basic profile info for the user making the request by calling `get_current_user`. You'll also want to know what other data is floating around. Use `list_video_templates` to see all available deployments, which you might then check with `get_template_details` if you need specific variable requirements. This whole setup lets your agent handle complex media workflows—from starting the job to tracking every piece of source material—without forcing you to jump between a dashboard and this chat window. It's everything in one place.

## Tools

### check_api_health
Verifies if your connection to the RenderMe API is working correctly.

### create_video_render_job
Sends a command to start rendering a new video project using an available template.

### get_account_render_stats
Retrieves usage data, including total renders and API call counts for the month.

### get_current_user
Pulls basic profile information for the authenticated user making the request.

### get_render_job_status
Checks and reports the current status (queued, rendering, failed) of a specific job ID.

### get_template_details
Fetches technical details for one specific video template, including its required dynamic variables.

### list_asset_folders
Displays a list of the organizational folders set up to store your media projects and assets.

### list_configured_webhooks
Lists all active webhooks connected to your RenderMe account for external notifications.

### list_recent_render_jobs
Shows a list of the last few video rendering jobs that were run on the account.

### list_uploaded_assets
Displays all images and media files currently uploaded to your RenderMe project for use in templates.

### list_video_projects
Shows a list of every video project that has been set up on the account.

### list_video_templates
Lists all available, active video templates (deployments) you can use for rendering content.

## Prompt Examples

**Prompt:** 
```
List all my video deployments in RenderMe.
```

**Response:** 
```
I've retrieved your deployments. You have 3 active video templates: 'Social Intro', 'Ad Campaign v1' (ID: dep_123), and 'Product Showcase'. Which one would you like to render?
```

**Prompt:** 
```
Render a batch of 50 personalized certificate images for our training program graduates.
```

**Response:** 
```
Batch rendering initiated: 50 personalized certificates. Template: "Professional Certificate Gold". Dynamic fields: graduate name, course title, completion date, instructor signature, unique certificate ID. Progress: 50/50 completed (100%). All certificates generated in PDF (print-ready, 300 DPI) and PNG (web) formats. Average render time: 1.2 seconds per certificate. Download link generated for the ZIP archive (124 MB). Email delivery option available for direct distribution to graduates.
```

**Prompt:** 
```
Show me the rendering statistics and API usage for my account this month.
```

**Response:** 
```
Monthly rendering statistics. Total renders: 3,456. Successful: 3,421 (99.0%). Failed: 35 (1.0%, mostly timeout on complex templates). API calls: 4,890. Average render time: 2.1 seconds. Peak usage: Tuesday at 2 PM (234 renders/hour). By format: PNG 58%, PDF 32%, JPG 10%. Storage used: 2.3 GB of 10 GB. Plan limit: 5,000 renders/month (69.1% used). Estimated overage at current pace: none.
```

## Capabilities

### Trigger Video Rendering
Initiates a new video rendering job by specifying a template ID and providing dynamic data like text or colors.

### Check Job Statuses
Retrieves the current state of any render job, telling you if it's queued, rendering, or finished.

### Manage Templates and Assets
Lists all available video templates (deployments) and organizes your source material by listing asset folders and uploaded media.

### Monitor Account Health
Checks the overall connection status of the RenderMe API or retrieves usage statistics for your account this month.

## Use Cases

### Batching Personalized Ad Sets
A marketing team needs 50 versions of a testimonial video, each with a different name and date. They prompt their agent: 'Run `create_video_render_job` for the 'Testimonial v2' template using dynamic fields: {{name}}, {{date}}.' The agent executes the batch render, and they get a link to the finished ZIP archive.

### Pre-Flight Check on Assets
Before kicking off a major campaign, an ops engineer runs `list_asset_folders` and then `list_uploaded_assets`. This confirms that all necessary logos, hero images, and background tracks are correctly organized and uploaded before spending money on rendering.

### Debugging a Failed Campaign
A social media manager notices a job failed. They immediately run `list_recent_render_jobs` to get the ID, then use `get_render_job_status` with that ID. The result tells them it was a template variable error, saving 15 minutes of manual debugging.

### Auditing Usage Before Year-End
The finance team needs to prove media usage for Q2. They run `get_account_render_stats` to get total renders and API calls, providing a single data point that was previously buried in three different dashboard sections.

## Benefits

- Check usage limits and performance stats instantly. Run `get_account_render_stats` to know exactly where you stand without leaving the conversation window. This prevents unexpected overage charges.
- Never guess a template ID again. Use `list_video_templates` to pull up every active video deployment name and its unique ID, making job creation reliable and fast.
- Manage your content source material easily. Run `list_uploaded_assets` to see every image and piece of media you've stored, ensuring the assets needed for a render are actually there.
- Keep track of history without clicking tabs. `list_recent_render_jobs` gives you an immediate rundown of what was processed minutes ago, making troubleshooting fast.
- Pinpoint job progress immediately. If a rendering job is stuck, use `get_render_job_status` to confirm if it's truly failed or just taking time on the backend.

## How It Works

The bottom line is: You talk to your agent like a person, and it runs the complex API calls for you.

1. Subscribe to the RenderMe server and input your API Key from your re.video dashboard settings.
2. Use a natural language prompt with your AI client (e.g., 'List all my video templates').
3. The server executes the necessary tool call, returns structured data to your client, and you get your answer back in chat.

## Frequently Asked Questions

**How do I check if my video rendering job succeeded using get_render_job_status?**
You provide a Job ID, and `get_render_job_status` tells you the current state. It'll report 'complete' or 'failed,' giving you immediate visibility into the result.

**Do I need to run list_video_templates before creating a job?**
Yeah, you should. Running `list_video_templates` gives you all the active deployment IDs and details for templates, which prevents you from running a render using an outdated or non-existent ID.

**What if I need to know my monthly usage limit? Can get_account_render_stats do that?**
Yes. `get_account_render_stats` pulls your total renders, API calls, and storage used for the month, letting you monitor quota consumption at a glance.

**How does RenderMe help me manage my assets? Does list_uploaded_assets work with it?**
It lets you see everything. `list_uploaded_assets` lists all media files in the project, and `list_asset_folders` shows how those files are organized for easy retrieval.

**Before I create a job, how can I check if my connection to RenderMe is working?**
Run `check_api_health` right away. This validates the API connectivity and confirms your agent has working credentials before you trigger expensive render jobs.

**How do I verify what external systems will receive notifications when a video job finishes?**
Use `list_configured_webhooks`. This shows all active hooks, verifying that RenderMe will notify your other services—like Slack or databases—when the rendering completes.

**I need to know what dynamic variables a specific video template requires; should I use `get_template_details`?**
Yes, run `get_template_details` with the deployment ID. This retrieves crucial metadata, like required placeholders (e.g., [Name] or [Date]), so your AI client can prepare inputs correctly.

**How do I confirm which user account is initiating the rendering process?**
Call `get_current_user` to retrieve the authenticated profile details. This confirms the session context for your agent and is key for auditing or billing purposes.

**Can my AI automatically find my RenderMe templates?**
Yes! Use the `list_deployments` tool. Your agent will respond with complete metadata for all your video templates, including their IDs and technical specifications in seconds.

**How do I find my RenderMe (re.video) API Key?**
Log in to your RenderMe account at app.re.video, navigate to the **Settings** or **API** section, and you will find your unique secret token there.