# Contentdrips MCP MCP

> Contentdrips MCP turns text into ready-to-post social media carousels and graphics. It automates the entire visual content lifecycle: you send text, it handles rendering using templates, monitors job status, and retrieves final PNG or PDF assets for any platform.

## Overview
- **Category:** marketing-automation
- **Price:** Free
- **Tags:** carousel-generator, graphic-automation, social-content, cloud-rendering, visual-marketing, content-creation

## Description

You can use this connection to automate graphic design at scale. Instead of manually building slides or designing individual posts, your agent sends a simple request—like 'Create a carousel about the top 5 marketing trends.' It handles the complexity: picking the right template, rendering the entire batch, and managing the job status until you get the final files. This capability means your content pipeline stays running without someone having to click through dashboards at 2 AM. When building multi-step workflows across different services, Vinkius makes connecting this automated graphic generation straightforward.

Your agent acts as a dedicated coordinator, ensuring every asset is rendered correctly and that you get the final URLs for scheduling tools.

## Tools

### check_contentdrips_status
Verifies if your API key and connection to ContentDrips are working properly.

### get_account
Retrieves basic information about the connected ContentDrips account.

### get_job_result
Fetches the final hosted URL for a completed graphic render job.

### get_job_status
Checks the current status of an asynchronous content rendering job (e.g., Pending, Processing).

### get_template
Gets detailed information about a specific design template ID.

### list_templates
Retrieves a list of all available graphic templates in your ContentDrips account.

### render_batch
Submits a request to render multiple graphics or carousels at once using specified templates and content.

### render_carousel
Generates an entire multi-slide carousel graphic from text input and a template ID.

### render_image
Creates a single, stand-alone graphic post using a specified template and content.

### render_pdf
Renders the designed content into a multi-page PDF document format.

## Prompt Examples

**Prompt:** 
```
Render a carousel with template '148872' and text: 'Top 5 AI Tools'.
```

**Response:** 
```
Render orchestrated! I've successfully submitted the generation request for template 148872. The job ID is job_abc123. The carousel will be ready shortly. Shall I notify you once the status is 'Completed'?
```

**Prompt:** 
```
Check the status of render job 'job_abc123'.
```

**Response:** 
```
Job intelligence orchestrated! For job_abc123, the current status is 'COMPLETED'. The asset was generated successfully at 2:00 PM today. Need help retrieving the final export URL?
```

**Prompt:** 
```
Retrieve the final PNG URL for job 'job_abc123'.
```

**Response:** 
```
Asset directory orchestrated! I've successfully retrieved the PNG URL for job_abc123. The image is now ready for your social media schedule. Shall I list the technical metadata for this render?
```

## Capabilities

### Generate full graphical carousels
Submit text inputs to create multi-slide carousels using defined templates.

### Render single images or PDF batches
Create standalone graphic posts or render entire sets of assets as PDFs in a single operation.

### Manage content job status
Check if a rendering job is pending, processing, or completed without having to wait on the dashboard.

### Retrieve final asset URLs
Access hosted links for finished graphics (PNG) and technical metadata needed for archives.

### Manage content templates
List available design templates or fetch specific template details to ensure the correct format is used.

## Use Cases

### Batching out monthly tips
A content manager needs to publish 12 slides of 'Top Tips' every month. Instead of running 12 manual renders, they use `render_batch` with the main template ID and a list of text inputs. The agent then checks the status using `get_job_status` until all 12 assets are ready.

### Creating a client report
A growth engineer needs to take raw data points and visualize them in a PDF format for a client meeting. They use `render_pdf`, specifying the template, so the agent generates a polished document instead of just dumping text into an email.

### Verifying assets before schedule
Before running a major campaign, a coordinator uses `get_template` to pull details on a specific design style. They then use `render_image` with dummy content and check the result via `get_job_result` to confirm the output quality.

### Debugging rendering failures
If a scheduled job fails, instead of waiting for support, the agent first runs `check_contentdrips_status` and then uses `get_account` to verify API connectivity before attempting to re-render.

## Benefits

- Stop designing graphics piece by piece. You can use `render_carousel` or `render_batch` to submit a single request and generate an entire set of slides instantly.
- Never worry about missing assets again. Use `get_job_status` to programmatically monitor rendering jobs, so your content pipeline stays coordinated even if the backend is slow.
- You get immediate access to final files. When a job finishes, use `get_job_result` to pull the hosted PNG or PDF URL directly into your scheduling tool.
- No more guessing which templates exist. Use `list_templates` and `get_template` together to programmatically discover every design option available in your account.
- It handles all formats. Whether you need a single image (`render_image`), a multi-slide carousel, or an entire document as a PDF (`render_pdf`), this MCP covers it.

## How It Works

The bottom line is: You talk to your AI client, and it handles the entire multi-step rendering and retrieval process in the background.

1. First, your agent verifies connectivity using `check_contentdrips_status` and retrieves account info via `get_account`.
2. Next, you tell the agent exactly what to create (e.g., 'Render a carousel with this text'). The system submits the job and returns a job ID.
3. Finally, your agent polls the status using `get_job_status` until it confirms completion, then fetches the finished file link using `get_job_result`.

## Frequently Asked Questions

**How do I make sure my Contentdrips API key is working?**
Run `check_contentdrips_status`. This tool verifies the connection and confirms that your MCP can talk to the ContentDrips platform.

**What's the difference between render_carousel and render_batch?**
`render_carousel` is for a single, defined multi-slide piece. `render_batch` allows you to submit multiple different graphics or carousels in one go.

**Why do I need the get_job_status tool?**
Rendering jobs are asynchronous; they don't finish instantly. You must use `get_job_status` to poll the job ID and wait until it reports 'COMPLETED' before trying to download the file.

**Can I get metadata for a render?**
Yes, after confirming completion with `get_job_result`, you can request the technical metadata. This helps build your archive and understand exactly how the asset was generated.

**If I suspect connectivity issues, how do I use the `check_contentdrips_status` tool?**
It immediately verifies your API connection status. Running this is a quick diagnostic check to confirm your agent can successfully communicate with ContentDrips before you start any rendering jobs.

**What key information does the `get_account` tool provide for managing usage?**
This tool pulls critical account details, including current usage quotas and operational limits. You use this data to plan your content volume and ensure you don't accidentally hit rate caps.

**How do I find out what templates are available using `list_templates`?**
The tool returns a full catalog of Template IDs and metadata. You run this when you need to discover which structural designs exist in your account before selecting one for rendering.

**When should I use `render_image` instead of creating a carousel?**
Use this tool when you need one standalone graphic, like a single quote card or header image. It’s designed for singular assets rather than multi-page narratives.

**How do I find my Contentdrips API Key?**
Log in to your account, navigate to **Settings** > **API**, and copy your unique Bearer Token from the credentials section.

**Can I check the status of a render job via AI?**
Yes! The `get_job_status` tool allows your agent to poll the real-time status of any generation request.

**How do I retrieve the final graphic URL?**
Use the `get_job_result` tool and provide the Job ID to retrieve the hosted URL for your PNG or PDF asset.