# Reap API: AI Video Clipping, Captions, Reframing & Dubbing API
Source: https://docs.reap.video/api-reference/1_introduction
Reap is an AI video API for automating clipping, captions, reframing, dubbing, transcription, and social publishing. REST + webhooks, 80+ languages, works with any AI agent, MCP server, or backend.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## What is the Reap API?
**The Reap API is an AI video automation API that turns long-form videos into short social clips, adds styled captions, reframes footage for any aspect ratio, dubs audio into 80+ languages, generates transcriptions, and publishes directly to YouTube, Instagram, TikTok, LinkedIn, and X. It runs over a REST interface with Bearer-token auth and webhook callbacks.**
It is the same engine that powers [reap.video](https://reap.video), exposed so developers, AI agents, and content platforms can embed clipping, captions, reframing, and dubbing into their own pipelines without building video infrastructure.
## API Basics
* **Base URL:** `https://public.reap.video/api/v1/automation/`
* **Auth:** `Authorization: Bearer YOUR_API_KEY`
* **Rate limit:** 10 requests / minute / key
Install Reap docs into your AI coding agent, or connect the Reap MCP so your agent can run your workspace for you:
```bash theme={"system"}
npx skills add https://docs.reap.video
```
Connect the MCP server at `https://mcp.reap.video/mcp` to let your agent clip, caption, reframe, dub, and publish for you directly. See [MCP Server](/api-reference/mcp).
Upload a video and get clips in under 5 minutes.
Create an API key and sign requests.
Install Reap into Cursor, Claude Code, Copilot, Codex, and 30+ agents.
Connect your AI agent to your Reap workspace to create clips and publish via Model Context Protocol.
## Agent Entry Points
* Full documentation index: [llms.txt](/llms.txt)
* OpenAPI schema: [openapi.json](/openapi.json)
* Markdown pages: append `.md` to any docs URL, for example `https://docs.reap.video/api-reference/3_quickstart.md`
## What can you build with the Reap API?
Turn long videos into ranked short clips, steered by a natural-language `prompt`. See [Create Clips](/api-reference/create-clips).
Auto-track speakers and subjects to reframe 16:9 into 9:16, 1:1, or 4:5 without cropping off faces. See [Create Reframe](/api-reference/create-reframe).
Voice-dub videos into 80+ languages with lip-aware timing. See [Create Dubbing](/api-reference/create-dubbing).
Styled, emoji-highlighted captions with brand presets. See [Create Captions](/api-reference/create-captions).
Word-level timestamped transcripts for video and audio. See [Create Transcription](/api-reference/create-transcription).
Push clips to YouTube, Instagram, TikTok, LinkedIn, and X from one endpoint. See [Publish Clip](/api-reference/publish-clip).
## Who is this API for?
* **AI agents and coding copilots** (Cursor, Claude Code, Codex, Copilot, Cline, Windsurf, Gemini CLI): install the [Reap Agent Skill](/api-reference/agent-skills) to write integrations, or connect the [MCP server](/api-reference/mcp) so your agent can create clips and publish for you.
* **Creator platforms and SaaS tools** embedding clipping, captions, or dubbing as a feature.
* **Media and publisher workflows** automating short-form output from podcasts, webinars, keynotes, and long-form YouTube.
* **Enterprise content teams** replacing manual editing with batch pipelines driven by webhooks.
* **Developers looking for a video clipping API, caption generation API, or AI dubbing API** with real webhooks and agent support.
## Why teams build on the Reap API
Every feature in the Reap product is exposed as a stable, versioned endpoint. No scraping, no headless browser, no "contact sales for API access."
Get notified the moment a project finishes. No polling loops, no wasted rate limit, no cron jobs. See [Webhooks](/api-reference/webhooks).
Reap ships as an [agent skill](/api-reference/agent-skills) so Cursor, Claude Code, Copilot, and Codex can write integrations for you, and as an [MCP server](/api-reference/mcp) so your agent can create clips and publish for you.
Clipping, captions, reframing, dubbing, transcription, and social publishing. Same auth, same project model, same webhooks.
Push clips to YouTube, Instagram, TikTok, LinkedIn, and X from a single endpoint with per-platform settings.
Upload once, fan out into clipping + reframe + dub jobs, and track everything through webhooks. Creator and Studio plans scale with your volume.
## 60-second example: upload, clip, and poll
```bash theme={"system"}
# 1. Get a presigned upload URL
curl -X POST https://public.reap.video/api/v1/automation/get-upload-url \
-H "Authorization: Bearer $REAP_API_KEY" \
-H "Content-Type: application/json" \
-d '{"filename":"keynote.mp4"}'
# -> { "uploadUrl": "https://...", "id": "upload_abc" }
# 2. Upload the file
curl -X PUT "$UPLOAD_URL" \
-H "Content-Type: video/mp4" \
--data-binary @keynote.mp4
# 3. Create a clipping project
curl -X POST https://public.reap.video/api/v1/automation/create-clips \
-H "Authorization: Bearer $REAP_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "upload_abc",
"genre": "talking",
"exportResolution": 1080,
"exportOrientation": "portrait",
"clipDurations": [[30,60],[60,90]],
"prompt": "Highlight reel of the most quotable moments — keep clips under 60 seconds."
}'
# -> { "id": "proj_xyz", "status": "queued" }
# 4. Poll (or use webhooks, recommended in production)
curl "https://public.reap.video/api/v1/automation/get-project-status?projectId=proj_xyz" \
-H "Authorization: Bearer $REAP_API_KEY"
```
See the full walkthrough in the [Quickstart Guide](/api-reference/3_quickstart).
## Install Reap into your AI coding agent
Reap meets your agent two ways. The **agent skill** gives it full knowledge of the API to write integrations (offline, versioned with your repo). The **MCP server** connects it to your workspace so it can create clips and publish directly (live, over OAuth).
```bash theme={"system"}
npx skills add https://docs.reap.video
```
Works with Cursor, Claude Code, GitHub Copilot, Codex, Cline, Amp, Gemini CLI, and 30+ agents. See [Agent Skills](/api-reference/agent-skills).
Connect your agent to:
```
https://mcp.reap.video/mcp
```
A one-time OAuth sign-in scopes the agent to a workspace you choose. Your agent can then create clips, caption, reframe, dub, and publish. See [MCP setup](/api-reference/mcp).
Point any LLM at the documentation index:
```
https://docs.reap.video/llms.txt
```
Every endpoint page is also available in markdown at `.md`.
## Core concepts
Projects are containers for a video processing job: clipping, captions, reframe, dubbing, or transcription. Each project has a `status` (`queued`, `processing`, `completed`, `cancelled`, `failed`, `invalid`, `expired`) and produces one or more clips, transcripts, or rendered outputs.
Before creating a project you upload a source video via a presigned S3 URL from [`/get-upload-url`](/api-reference/get-upload-url). MP4 or MOV, 2 minutes to 3 hours, up to 5 GB. Files are validated at project creation, not upload.
Clips are the output segments from a clipping project. Each has a `clipUrl` (presigned), `title`, `caption`, virality score, and framing metadata. See [Get Project Clips](/api-reference/get-project-clips).
Pass a natural-language `prompt` to [`/create-clips`](/api-reference/create-clips#prompt) to steer clip count, duration, focus, exclusions, editorial mode, and tone. The prompt overrides generic virality scoring when the two conflict; omit it to fall back to virality-driven selection. Preview feature — schema is stable, AI interpretation may evolve.
Reusable caption styles with font, color, emoji, and highlight settings. List with [Get All Presets](/api-reference/get-all-presets). Used in `create-clips` and `create-captions` via `captionsPreset`.
Connected social accounts (YouTube, Instagram, TikTok, LinkedIn, X) created in the dashboard. The API references them by `integrationId` when publishing. See [Get Integrations](/api-reference/get-integrations).
A publish or schedule action against a completed clip. Use [Publish Clip](/api-reference/publish-clip) for immediate and [Schedule Clips](/api-reference/schedule-clips) for future posts.
Real-time notifications when a project hits a terminal state. Recommended over polling in production. Requires HTTPS, 200 response within 5 seconds. 5 failed deliveries auto-disables the webhook. See [Webhooks](/api-reference/webhooks).
## API limits
* **Rate limit:** 10 requests per minute per API key (headers: `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset`).
* **Concurrent projects:**
| Plan | Concurrent Projects |
| ---------- | ------------------------------------------------ |
| Creator | 3 |
| Studio | 10 |
| Enterprise | Custom, [contact sales](mailto:hello@reap.video) |
The documentation is public. Dashboard links require a Reap account and are only needed for account setup, API key management, integrations, or webhook configuration.
## FAQ
Yes. The Reap Automation API is a public REST API at `https://public.reap.video/api/v1/automation/`. Create a key from your [Reap dashboard](https://app.reap.video/) under Settings → API Keys.
Yes. [`POST /create-clips`](/api-reference/create-clips) accepts an uploaded video and returns ranked short clips with captions, reframing, and metadata. Works for podcasts, webinars, interviews, keynotes, and long-form YouTube.
Yes. Pass a natural-language `prompt` to [`/create-clips`](/api-reference/create-clips#prompt) to control clip count, duration, focus, exclusions, editorial mode (highlight reel, trailer, compilation, etc.), and tone. Prompts override generic virality scoring on conflict. Preview feature — schema is stable, AI interpretation may evolve.
Yes. Connect your agent to `https://mcp.reap.video/mcp` and a one-time OAuth sign-in scopes it to a workspace you choose. Your agent can then create clips, caption, reframe, dub, and publish for you. Full setup in [MCP](/api-reference/mcp).
Yes. Reap is published to [skills.sh](https://skills.sh/site/docs.reap.video/reap). Install with `npx skills add https://docs.reap.video`. Works with Cursor, Claude Code, Copilot, Codex, Cline, Amp, Gemini CLI, and 30+ agents.
80+ languages with lip-aware timing. Get the live list from [`GET /get-dubbing-languages`](/api-reference/get-dubbing-languages).
MP4 or MOV, between 2 minutes and 3 hours, up to 5 GB. Best results on dialogue-rich content (podcasts, interviews, keynotes, streams).
Yes. Configure an HTTPS endpoint in the dashboard. Reap POSTs a JSON payload when a project reaches a terminal state. See [Webhooks](/api-reference/webhooks).
Yes. The Reap API covers the full short-form video pipeline over REST: clipping ([`/create-clips`](/api-reference/create-clips)), captions ([`/create-captions`](/api-reference/create-captions)), reframing ([`/create-reframe`](/api-reference/create-reframe)), dubbing ([`/create-dubbing`](/api-reference/create-dubbing)), transcription ([`/create-transcription`](/api-reference/create-transcription)), and social publishing ([`/publish-clip`](/api-reference/publish-clip)). No UI scraping, no waitlist, no headless browser.
Yes. [`POST /publish-clip`](/api-reference/publish-clip) and [`POST /schedule-clips`](/api-reference/schedule-clips) post to YouTube, Instagram, TikTok, LinkedIn, and X using integrations connected in the dashboard.
The API is plain REST + JSON, so any HTTP client works. Example code in the [Quickstart](/api-reference/3_quickstart) covers curl, Python (`requests`), and Node (`fetch`). Official SDK packages are on the roadmap.
## Resources
Every endpoint with schemas and examples.
Your first project in under 5 minutes.
Install Reap into any AI coding agent.
Let your agent create clips and publish for you over Model Context Protocol.
Tutorials and troubleshooting.
Questions, enterprise, roadmap.
# Authentication
Source: https://docs.reap.video/api-reference/2_authentication
Learn how to authenticate your API requests
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## API Key Authentication
The Reap Automation API uses API key authentication. You'll need to include your API key in the `Authorization` header of every request.
### Getting Your API Key
1. Log in to your Reap dashboard
2. Navigate to **Profile** > **Settings** > **API Keys**
3. Click **Create a Secret Key**
4. Give your key a descriptive name. This is only for your reference.
5. Optionally, set an expiration date for the key. Keys are not expired by default.
6. Click **Create Key** to generate the API key.
7. Copy the generated API key (store it securely - you won't be able to see it again)
Keep your API key secure! Don't commit it to version control or share it publicly. Store it in environment variables or a secure configuration management system.
### Making Authenticated Requests
Include your API key in the `Authorization` header with the `Bearer` prefix:
```bash theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-projects" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
### Authentication Headers
| Header | Value | Required |
| --------------- | --------------------- | -------- |
| `Authorization` | `Bearer YOUR_API_KEY` | Yes |
| `Content-Type` | `application/json` | Yes |
## API Key Management
### Security Best Practices
Store your API key in environment variables rather than hardcoding it in your application.
Rotate your API keys regularly for enhanced security.
Use separate API keys for different environments (development, staging, production).
Monitor your API key usage to detect any unauthorized access.
### Key Expiration
API keys do not expire by default. You can:
* Set custom expiration dates when creating keys
* Create non-expiring keys (recommended for production)
* Monitor expiration dates in your dashboard
* Revoke keys at any time
### Revoking API Keys
To revoke an API key:
1. Go to **Profile** > **Settings** > **API Keys** in your dashboard
2. Find the key you want to revoke
3. Click **Revoke** or **Delete**
Revoking an API key immediately invalidates all requests using that key. Make sure to update your applications before revoking keys.
## Rate Limiting
All API requests are subject to rate limiting:
* **10 requests per minute** per API key
* Rate limit headers are included in all responses
* Exceeding limits returns a `429 Too Many Requests` error
### Rate Limit Headers
| Header | Description |
| ----------------------- | -------------------------------------------- |
| `X-RateLimit-Limit` | Maximum requests per minute |
| `X-RateLimit-Remaining` | Remaining requests in current window |
| `X-RateLimit-Reset` | Time when rate limit resets (Unix timestamp) |
## Error Responses
### Authentication Errors
| Status Code | Error | Description |
| ----------- | ----------------- | ----------------------------------------- |
| `401` | Unauthorized | Missing or invalid API key |
| `403` | Forbidden | API key doesn't have required permissions |
| `429` | Too Many Requests | Rate limit exceeded |
### Example Error Response
```json theme={"system"}
{
"error": "Unauthorized",
"message": "Invalid API key",
"status": 401
}
```
## Testing Authentication
Test your API key with a simple request to get your presets:
```bash theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-presets" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
A successful response indicates your authentication is working correctly.
# Quickstart
Source: https://docs.reap.video/api-reference/3_quickstart
Create your first video project in under 5 minutes
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
This guide walks you through the complete workflow: upload a video, create a clipping project, and retrieve your AI-generated clips.
## Prerequisites
The documentation is public. Dashboard links require a Reap account and are only needed for account setup, API key management, integrations, or webhook configuration.
* A Reap account with API access ([get started](https://reap.video/pricing))
* Your API key from the [dashboard](https://app.reap.video)
* A video file (MP4 or MOV, 2 min - 3 hours)
## Basic Workflow
The typical automation workflow follows these steps:
Request a secure upload URL for your video file
Upload your video file to the provided URL
Create a video processing project (clips, captions, reframe, or dubbing)
Check the project status until processing is complete
Get your processed clips and their URLs
## Step-by-Step Example
Let's create a clipping project that generates short clips from a long video.
### 1. Get Upload URL
First, request a secure upload URL for your video:
```bash theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/get-upload-url" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"filename": "my-video.mp4"
}'
```
Response:
```json theme={"system"}
{
"uploadUrl": "https://upload.reap.video/...",
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"fileName": "my-video.mp4",
"fileType": "video",
"status": "upload"
}
```
### 2. Upload Your Video
Upload your video file to the provided `uploadUrl` using a PUT request:
```bash theme={"system"}
curl -X PUT "UPLOAD_URL_FROM_STEP_1" \
-H "Content-Type: video/mp4" \
--data-binary @/path/to/your/video.mp4
```
### 3. Create a Clipping Project
Now create a clipping project using the upload ID. The request also accepts a natural-language `prompt` field for editorial control over clip count, duration, focus, exclusions, and tone — see [create-clips](/api-reference/create-clips#prompt).
```bash theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-clips" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"genre": "talking",
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"prompt": "Highlight reel of the most quotable moments — keep clips under 60 seconds."
}'
```
Response:
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "my-video.mp4",
"status": "processing",
"projectType": "clipping",
"billedDuration": 300.5,
"createdAt": 1710345600
}
```
### 4. Monitor Project Status
Check the project status periodically:
```bash theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-project-status?projectId=65f1a2b3c4d5e6f7a8b9c0d2" \
-H "Authorization: Bearer YOUR_API_KEY"
```
Response:
```json theme={"system"}
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"projectType": "clipping",
"source": "Upload",
"status": "completed"
}
```
### 5. Get Your Clips
Once processing is complete, retrieve the generated clips:
```bash theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-project-clips?projectId=65f1a2b3c4d5e6f7a8b9c0d2" \
-H "Authorization: Bearer YOUR_API_KEY"
```
Response:
```json theme={"system"}
{
"clips": [
{
"id": "65f1a2b3c4d5e6f7a8b9c0d3",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipUrl": "https://cdn.reap.video/clips/...",
"title": "Engaging Moment 1",
"duration": 30.5,
"viralityScore": 8.7
}
],
"totalClips": 5
}
```
**You did it!** Your clips are ready to download from the `clipUrl` links. Each clip includes captions, reframing, and a virality score.
## What's Next
Add AI-generated captions with customizable styling
Extract accurate transcriptions in multiple formats
Learn how to automatically reframe videos for different aspect ratios
Discover AI-powered voice dubbing in multiple languages
Use custom caption styles for consistent branding
Publish or schedule completed clips to your connected social accounts
## Integration Patterns
### Batch Processing
Process multiple videos in parallel:
```javascript theme={"system"}
const files = ['video1.mp4', 'video2.mp4', 'video3.mp4'];
for (const file of files) {
// Get upload URL
const uploadResponse = await fetch('/automation/get-upload-url', {
method: 'POST',
headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
body: JSON.stringify({ filename: file })
});
// Upload and create project...
}
```
### Webhook Integration
Instead of polling for status updates, you can configure [webhooks](/api-reference/webhooks) to get notified automatically when projects complete or fail. Reap will POST the project status to your endpoint:
```json theme={"system"}
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"projectType": "clipping",
"source": "Upload",
"status": "completed"
}
```
Set up webhooks from your [dashboard](https://app.reap.video) under **Profile** > **Settings** > **Webhooks**. See the full [Webhooks guide](/api-reference/webhooks) for setup instructions and example receivers.
### Error Handling
Always implement proper error handling for API requests:
```javascript theme={"system"}
try {
const response = await fetch('/automation/create-clips', {
method: 'POST',
headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
body: JSON.stringify(projectData)
});
if (!response.ok) {
throw new Error(`API error: ${response.status}`);
}
const project = await response.json();
console.log('Project created:', project.id);
} catch (error) {
console.error('Failed to create project:', error.message);
}
```
## Need Help?
* [API Reference](/api-reference/get-all-presets) - Complete endpoint documentation
* [Authentication](/api-reference/2_authentication) - API key setup and security
* [Contact Support](mailto:hello@reap.video) - We're here to help
# Agent Skills
Source: https://docs.reap.video/api-reference/agent-skills
Add Reap Public API knowledge to your AI coding agents for faster integration
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
Looking to *operate* your workspace from an agent -- create clips, publish, schedule? See the [MCP server](/api-reference/mcp). This skill gives your agent *knowledge* of the Reap Public API so it can write integrations for you.
## Overview
Install the Reap Public API skill into your AI coding agent so it has full context on every endpoint, schema, and workflow. Once installed, your agent can help you build integrations, create automation pipelines, and use the Reap Public API without you having to reference the docs manually.
Supported agents include **Cursor**, **GitHub Copilot**, **Claude Code**, **Cline**, **Codex**, **Amp**, **Gemini CLI**, and [30+ more](https://skills.sh).
## Install the Skill
Run the following command in your project directory:
```bash theme={"system"}
npx skills add https://docs.reap.video
```
The CLI will walk you through four prompts:
Choose which agents to install the skill to. Universal agents (Cursor, Copilot, Claude Code, etc.) are pre-selected. You can also pick from 30+ additional agents.
Select **Project** to install in the current directory (committed with your project), or **Global** to make it available across all projects.
Select **Symlink** (recommended) for a single source of truth with easy updates, or **Copy** to duplicate the skill files into each agent's directory.
Review the installation summary and confirm. The skill is installed instantly.
**Done!** Your agent now has full knowledge of the Reap Public API -- endpoints, request/response schemas, enums, authentication, and workflows.
## What Can Your Agent Do With This Skill?
Once the skill is installed, you can ask your AI agent to:
"Integrate Reap clipping into my Express backend"
"Write a Python pipeline that uploads a video, creates clips, and polls for completion"
"Build me a highlight reel of the funniest moments from this podcast — keep clips under 60 seconds"
"Why is my create-reframe call returning 400?"
## Update the Skill
To pull the latest API changes, re-run the install command:
```bash theme={"system"}
npx skills add https://docs.reap.video
```
If you used the **Symlink** method, the skill updates in place for all agents automatically.
## Uninstall
Remove the skill directory from your project:
```bash theme={"system"}
rm -rf .agents/skills/reap
```
## Learn More
* [skills.sh](https://skills.sh) -- Browse and manage agent skills
* [Quickstart](/api-reference/3_quickstart) -- Get started with the Reap API
* [Authentication](/api-reference/2_authentication) -- Set up your API key
# Cancel Project
Source: https://docs.reap.video/api-reference/cancel-project
POST /automation/cancel-project
Cancel a project that is still processing and refund its credits
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Cancel a project that is still processing. On cancel, the project moves to a `cancelled` status and its credits are **refunded automatically** — there's no separate call to make. A cancelled project stays in your workspace and remains fully readable, but it can no longer be edited, published, or scheduled.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## When a project can be cancelled
You can cancel a project only while it's still **processing**, in either of these cases:
* **Just after you start it** — while Reap is still preparing your video, before any clips or outputs have been generated.
* **If it looks stuck** — it's been processing for more than \~8 hours without finishing.
Once a project has finished (`completed` or `failed`) — or has already been cancelled — it can't be cancelled again, and the API responds with `400`.
Cancelling refunds the project's credits automatically. There's no separate call to make, and credits are refunded only once.
## After cancelling
A cancelled project stays in your workspace and remains fully readable, but it's locked for edits.
**Still available**
* View or list the project and its clips — [Get Project Details](/api-reference/get-project-details), [Get Project Status](/api-reference/get-project-status), [Get All Projects](/api-reference/get-all-projects), [Get Project Clips](/api-reference/get-project-clips)
* [Delete the project](/api-reference/delete-project)
**No longer available** (these return `400`)
* Rename the project — [Update Project](/api-reference/update-project)
* Edit a clip — [Update Clip](/api-reference/update-clip)
* Publish a clip — [Publish Clip](/api-reference/publish-clip)
* Update a post — [Update Post](/api-reference/update-post)
* Schedule clips — in [Schedule Clips](/api-reference/schedule-clips), a cancelled project's clips come back in the `failed` array instead of failing the whole request.
## Response
Unique project identifier
Project title
Thumbnail URL for the project
Duration in seconds that was billed for this project
Current processing status. After a successful cancel, this is `cancelled`.
Type of project
Source of the video content
Video genre used for AI analysis
Array of identified topics in the video
Array of clip duration preferences
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for the project
Output orientation
Caption style preset ID (null if captions disabled)
Whether captions are enabled
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Target dubbing language (null if not applicable)
Whether transcription is translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/cancel-project" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/cancel-project', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
projectId: '65f1a2b3c4d5e6f7a8b9c0d2'
})
});
const project = await response.json();
console.log(`Status: ${project.status}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/cancel-project',
headers=headers,
json=data
)
project = response.json()
print(f"Status: {project['status']}")
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d2'
];
$ch = curl_init('https://public.reap.video/api/v1/automation/cancel-project');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Status: ' . $project['status'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
}
body, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/cancel-project", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CancelProjectExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/cancel-project");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = "{\"projectId\":\"65f1a2b3c4d5e6f7a8b9c0d2\"}";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Podcast Episode",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 1800.5,
"status": "cancelled",
"projectType": "clipping",
"source": "Upload",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 1800.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 450000000,
"codec": "h264"
},
"urls": {
"projectUrl": "https://app.reap.video/project/65f1a2b3c4d5e6f7a8b9c0d2"
},
"createdAt": 1710000000,
"updatedAt": 1710005000
}
```
```json theme={"system"}
{
"detail": "Only a project that is still processing can be cancelled."
}
```
```json theme={"system"}
{
"detail": "This project can't be cancelled at its current stage."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Project not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Create Captions
Source: https://docs.reap.video/api-reference/create-captions
POST /automation/create-captions
Add AI-generated captions to your videos with customizable styling
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Add professional captions to your videos using AI-powered transcription. This endpoint generates accurate captions with various styling options, emoji support, and keyword highlighting. Perfect for making content accessible and engaging on social media platforms.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
You must provide either `sourceUrl` or `uploadId`, but not both.
## Video Requirements
**Minimum:** 3 seconds\
**Maximum:** 15 minutes
**Maximum:** 2 GB
MP4 or MOV with valid video and audio streams
Clear speech produces best transcription results
## Plan Limits
| Plan | Max Resolution | Concurrent Projects |
| ------- | -------------- | ------------------- |
| Creator | 1080p | 3 |
| Studio | 4K (2160p) | 10 |
Higher-tier plans allow you to process more videos simultaneously and export at higher resolutions.
The Automation API requires an active subscription. [View pricing](https://reap.video/pricing) to compare plans.
## Response
Unique project identifier
Project title (usually the filename)
Thumbnail URL for the project
Duration in seconds that will be billed to your account
Current processing status
* `processing` - Video is being transcribed and captions are being generated
* `completed` - Captions have been generated successfully
* `failed` - Processing failed due to an error
Type of project (always "captions" for this endpoint)
Source of the video content
* `Upload` - Uploaded file
* `Generic` - External URL
Caption style preset ID used
Whether captions are enabled (always true for caption projects)
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Whether transcription will be translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets (populated when processing completes)
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL with Upload theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-captions" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"captionsPreset": "system_beasty",
"language": "en",
"enableEmojis": true,
"enableHighlights": true
}'
```
```bash cURL with URL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-captions" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"sourceUrl": "https://example.com/video.mp4",
"captionsPreset": "system_minimal",
"resolution": 1080
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/create-captions', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
captionsPreset: 'system_beasty',
language: 'en',
enableEmojis: true,
enableHighlights: true
})
});
const project = await response.json();
console.log('Caption project created:', project.id);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
'captionsPreset': 'system_beasty',
'language': 'en',
'enableEmojis': True,
'enableHighlights': True
}
response = requests.post(
'https://public.reap.video/api/v1/automation/create-captions',
headers=headers,
json=data
)
project = response.json()
print(f'Caption project created: {project["id"]}')
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d1',
'captionsPreset' => 'system_beasty',
'language' => 'en',
'enableEmojis' => true,
'enableHighlights' => true
];
$ch = curl_init('https://public.reap.video/api/v1/automation/create-captions');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Caption project created: ' . $project['id'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/create-captions"
data := map[string]interface{}{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"captionsPreset": "system_beasty",
"language": "en",
"enableEmojis": true,
"enableHighlights": true,
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CreateCaptionsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/create-captions");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{" +
"\"uploadId\": \"65f1a2b3c4d5e6f7a8b9c0d1\"," +
"\"captionsPreset\": \"system_beasty\"," +
"\"language\": \"en\"," +
"\"enableEmojis\": true," +
"\"enableHighlights\": true}";
try(OutputStream os = conn.getOutputStream()) {
byte[] input = jsonInputString.getBytes("utf-8");
os.write(input, 0, input.length);
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Caption project: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "my-video.mp4",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 180.5,
"status": "processing",
"projectType": "captions",
"source": "Upload",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "landscape",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 180.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 45000000,
"codec": "h264"
},
"urls": {},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
```
```json theme={"system"}
{
"detail": "Missing source URL or upload ID."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Upload not found."
}
```
```json theme={"system"}
{
"detail": "Maximum concurrent projects reached. Please wait for the current projects to complete."
}
```
```json theme={"system"}
{
"detail": "Failed to create project. Please contact support."
}
```
## Processing Workflow
1. **Audio Extraction** - Audio is extracted from the video file
2. **Transcription** - AI transcribes the speech with precise timing
3. **Caption Generation** - Captions are formatted with your chosen style
4. **Enhancement** - Emojis and highlights are added if enabled
5. **Rendering** - Final video is rendered with embedded captions
## Caption Features
Accurate speech-to-text with word-level timing
Multiple caption styles for different content types
Contextual emojis added automatically
Important words highlighted for emphasis
## Best Practices
* **Audio Quality**: Clear audio produces more accurate transcriptions
* **Language Selection**: Specify the language for better accuracy
* **Style Matching**: Choose presets that match your brand and content type
* **Translation**: Use translation for multilingual audiences
## Use Cases
Auto-generate captions for all uploaded content at scale
Meet accessibility requirements with accurate, styled captions
Add caption generation to your social media management platform
Caption educational content for better comprehension and searchability
## Next Steps
After creating a caption project:
1. Monitor progress with [Get Project Status](/api-reference/get-project-status)
2. Retrieve the captioned video with [Get Project Clips](/api-reference/get-project-clips)
3. Download and distribute your captioned content
# Create Clips
Source: https://docs.reap.video/api-reference/create-clips
POST /automation/create-clips
Create AI-powered short clips from long-form videos, steered by natural-language prompts for editorial control over count, duration, focus, and tone
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Transform long-form videos into engaging short clips using AI. This endpoint analyzes your video content and automatically extracts the most engaging moments, creating viral-ready clips optimized for social media platforms.
For finer editorial control, pass a natural-language `prompt` describing what kinds of clips you want — clip count, duration, focus, exclusions, editorial mode, and tone are all under your direction. Without a prompt, the AI falls back to virality-driven selection. See [Prompt](#prompt) below for capabilities and examples.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
You must provide either `sourceUrl` or `uploadId`, but not both.
## Video Requirements
**Minimum:** 1 minute\
**Maximum:** 3 hours
**Maximum:** 10 GB
MP4 or MOV with valid video streams
Works best with dialogue-rich content
## Plan Limits
| Plan | Max Resolution | Concurrent Projects |
| ------- | -------------- | ------------------- |
| Creator | 1080p | 3 |
| Studio | 4K (2160p) | 10 |
Higher-tier plans allow you to process more videos simultaneously and export at higher resolutions.
The Automation API requires an active subscription. [View pricing](https://reap.video/pricing) to compare plans.
## Orientation & Cropping
`exportOrientation` is the single knob for cropping: `portrait` (9:16) and `square` (1:1) automatically crop the source, while `landscape` (16:9) keeps the original framing. Face tracking (`centerStage`) only applies while cropping.
**Behavior change.** The request field `reframeClips` has been removed — cropping now follows `exportOrientation` alone, and legacy payloads still sending `reframeClips` have it ignored. Previously, `exportOrientation: "portrait"` without `reframeClips: true` was silently downgraded to landscape; the same request now crops to portrait as asked. If your integration relied on `reframeClips: false` to keep the original framing, send `exportOrientation: "landscape"` (or omit the field — landscape is the default).
**Preview feature.** `prompt` is available for general use but is still being refined. The field itself, its name, and its 1000-character limit are stable — what may shift is how the AI interprets a given instruction and the set of directives it honors. We recommend treating `prompt` as production-ready for experimentation and internal tooling, and pinning critical workflows to specific prompts you have tested end-to-end.
See [Prompt](#prompt) below for capabilities and examples.
## Response
Unique project identifier
Project title (usually the filename)
Thumbnail URL for the project
Duration in seconds that will be billed to your account
Current processing status
* `processing` - Video is being analyzed and clips are being generated
* `completed` - All clips have been generated successfully
* `failed` - Processing failed due to an error
Type of project (always "clipping" for this endpoint)
Source of the video content
* `Upload` - Uploaded file
* `Youtube` - YouTube URL
Video genre used for AI analysis
Array of identified topics in the video
Array of clip duration preferences
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for the clips
Output orientation for the clips
Caption style preset ID (null if captions disabled)
Whether captions are enabled
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Target dubbing language (null if not applicable)
Whether transcription will be translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets (populated when processing completes)
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL with Upload theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-clips" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"genre": "talking",
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"clipDurations": [[30, 60], [60, 90]],
"topics": ["product launch", "customer testimonials"],
"prompt": "Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing."
}'
```
```bash cURL with YouTube theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-clips" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"sourceUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"genre": "talking",
"exportResolution": 720,
"exportOrientation": "square",
"captionsPreset": "system_minimal",
"clipDurations": [[0, 30]],
"topics": ["highlights"],
"prompt": "Give me 3 short, punchy highlight clips suitable for TikTok."
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/create-clips', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
genre: 'talking',
exportResolution: 1080,
exportOrientation: 'portrait',
captionsPreset: 'system_beasty',
enableEmojis: true,
enableHighlights: true,
language: 'en',
clipDurations: [[30, 60], [60, 90]],
topics: ['product launch', 'customer testimonials'],
prompt: 'Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing.'
})
});
const project = await response.json();
console.log('Project created:', project.id);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
'genre': 'talking',
'exportResolution': 1080,
'exportOrientation': 'portrait',
'captionsPreset': 'system_beasty',
'enableEmojis': True,
'enableHighlights': True,
'language': 'en',
'clipDurations': [[30, 60], [60, 90]],
'topics': ['product launch', 'customer testimonials'],
'prompt': 'Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing.'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/create-clips',
headers=headers,
json=data
)
project = response.json()
print(f'Project created: {project["id"]}')
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d1',
'genre' => 'talking',
'exportResolution' => 1080,
'exportOrientation' => 'portrait',
'captionsPreset' => 'system_beasty',
'enableEmojis' => true,
'enableHighlights' => true,
'language' => 'en',
'clipDurations' => [[30, 60], [60, 90]],
'topics' => ['product launch', 'customer testimonials'],
'prompt' => 'Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing.'
];
$ch = curl_init('https://public.reap.video/api/v1/automation/create-clips');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Project created: ' . $project['id'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/create-clips"
data := map[string]interface{}{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"genre": "talking",
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"clipDurations": [][]int{{30, 60}, {60, 90}},
"topics": []string{"product launch", "customer testimonials"},
"prompt": "Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing.",
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CreateClipsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/create-clips");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{\"uploadId\":\"65f1a2b3c4d5e6f7a8b9c0d1\",\"genre\":\"talking\",\"exportResolution\":1080,\"exportOrientation\":\"portrait\",\"captionsPreset\":\"system_beasty\",\"enableEmojis\":true,\"enableHighlights\":true,\"language\":\"en\",\"clipDurations\":[[30,60],[60,90]],\"topics\":[\"product launch\",\"customer testimonials\"],\"prompt\":\"Highlight reel of the most quotable founder moments — keep clips under 60 seconds and skip any segments about pricing.\"}";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonInputString.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Project created: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Educational Video",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 1800.5,
"status": "processing",
"projectType": "clipping",
"source": "Upload",
"genre": "talking",
"topics": ["product launch", "customer testimonials"],
"clipDurations": [[30, 60], [60, 90]],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 1800.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 450000000,
"codec": "h264"
},
"urls": {},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
```
```json theme={"system"}
{
"detail": "You must provide either sourceUrl or uploadId, but not both"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Upload not found"
}
```
```json theme={"system"}
{
"detail": "Invalid video format or duration. Video must be between 1 minute and 3 hours."
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
```json theme={"system"}
{
"detail": "Maximum concurrent projects reached. Please wait for the current projects to complete."
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Processing Workflow
1. **Upload Analysis** - Video is analyzed for content, speakers, and key moments
2. **AI Clipping** - Our AI identifies the most engaging segments for clips
3. **Processing** - Clips are generated with your specified settings
4. **Completion** - Use [Get Project Status](/api-reference/get-project-status) to monitor progress
5. **Download** - Retrieve clips using [Get Project Clips](/api-reference/get-project-clips)
## Best Practices
* **Content Quality**: Videos with clear speech and engaging content produce better clips
* **Duration**: Longer videos (10+ minutes) typically yield more clip options
* **Genre Selection**: Choose the correct genre for optimal AI analysis
* **Caption Presets**: Use captions for better engagement on social platforms
* **Resolution**: Higher resolutions are better for professional content but take longer to process
* **Clip Durations**: Combine multiple ranges (e.g. `[[30,60],[60,90]]`) to get a variety of clip lengths suited to different platforms. Use shorter for Reels/TikTok, longer for YouTube Shorts
* **Prompt**: Reach for `prompt` when you have specific editorial intent — clip count, duration caps, focus, exclusions, or tone. Topics is the lighter-weight choice for "just bias toward these themes." Keep prompts concrete (1–3 sentences); pin a tested prompt for production workflows since AI interpretation may evolve while the field is in preview
* **Topics**: Be specific with topic strings to get more relevant clips; broad topics like `"highlights"` cast a wider net while narrow ones like `"pricing breakdown"` are more precise
## Clip Duration Ranges
Use `clipDurations` to control the length of generated clips. Each value is a `[min, max]` pair in seconds.
| Value | Label |
| ------------ | ---------------- |
| `[0, 30]` | Under 30 seconds |
| `[30, 60]` | 30s – 60s |
| `[60, 90]` | 60s – 90s |
| `[90, 180]` | 90s – 3 minutes |
| `[180, 300]` | 3 – 5 minutes |
You can pass multiple ranges to get a mix of clip lengths. When omitted, the AI determines optimal durations based on the content.
## Topics
Use `topics` to steer the AI toward specific subjects in your video. Pass an array of short topic strings (e.g. `["product demo", "pricing"]`) and the AI will prioritize segments that match those themes. When omitted, the AI selects the most engaging topics automatically. For richer control — clip count, duration caps, editorial modes, exclusions, and tone — use the [Prompt](#prompt) field instead.
## Prompt
`prompt` is a preview feature — see the [Preview note](#rate-limiting) at the top of this page. The field schema is stable; how the AI interprets a given prompt may evolve.
Use `prompt` to describe in plain language what kinds of clips you want. The instruction (max 1000 characters) is parsed by an LLM into a structured plan that drives clip count, duration, content focus, exclusions, and editorial style. When the prompt and a candidate moment conflict, the prompt wins over generic virality scoring.
### What you can do
* **Set how many clips to produce** — "give me 5 clips", "just one highlight reel"
* **Cap clip length** — "each under 30 seconds", "5-minute deep dives"
* **Focus on specific topics, speakers, or themes** — "only the section about pricing", "moments where the host disagrees with the guest"
* **Exclude segments** — "skip the intro and sponsor reads", "no tangents about politics"
* **Pick an editorial mode** — highlight reel, trailer, compilation, hooks-only, quotes, Q\&A, listicle, storytelling, educational, stats and facts, tips and advice, reaction moments, controversy, topic-focused
* **Steer tone and style** — "prefer high-energy delivery", "open each clip with the key claim"
### Example prompts
The 14 prompts below cover the supported editorial modes. Use them verbatim, edit them to fit your video, or write your own.
Build a highlight reel of the very best moments in the video — peak energy, the strongest reactions, the most quotable lines, and the biggest emotional or visual climaxes. Prioritize moments that would still feel powerful out of context, and skip filler, intros, or set-up.
Generate a teaser-style trailer — pick suspenseful, attention-grabbing moments that hook the viewer without giving everything away. Look for cliffhangers, intriguing questions, bold setups, and emotional peaks that make viewers want to watch the full video.
Create a compilation of similar moments from across the video — clips that share a common theme, tone, or topic. Group them so they feel cohesive when watched back-to-back as a single themed reel.
Find clips centered on a single topic or theme. Focus on moments where the speaker discusses one specific subject in depth, and skip tangents or unrelated digressions.
Extract only the strongest hooks — the opening lines, bold statements, or attention-grabbing moments designed to stop a viewer mid-scroll. Look for surprising claims, questions, or pattern-interrupts.
Pull out the most quotable lines — punchy one-liners, memorable phrases, or sharp insights that work as standalone soundbites and would read well as text overlays or pull-quotes.
Find educational moments — clear explanations, lessons, frameworks, or insights that teach the viewer something new. Prioritize clips that deliver real value or impart knowledge concisely.
Build a listicle-style breakdown — moments where the speaker enumerates points, steps, reasons, or tips in order. Look for "first…", "second…", "three reasons…", and similar list-driven structures.
Pick out storytelling moments — narrative arcs with setup, conflict, and payoff. Look for personal anecdotes, case studies, or any segment where the speaker takes the viewer on a journey.
Find clear question-and-answer exchanges — interview questions paired with strong responses, or moments where the speaker fields and addresses a specific question. Each clip should make sense as a standalone Q\&A pair.
Surface moments containing notable statistics, data points, or factual claims. Look for numbers, percentages, comparisons, or verified facts that lend credibility and would catch a viewer's attention.
Extract practical tips and advice — short, actionable recommendations the audience can apply immediately. Each clip should deliver one concrete piece of guidance, not vague philosophy.
Find strong reaction moments — surprise, shock, laughter, awe, or visible emotional responses from anyone on screen. Look for facial expressions and unfiltered reactions that capture the moment's energy.
Surface controversial or polarizing moments — strong opinions, callouts, or statements likely to spark debate. Look for clips that take a clear stance or make claims people would react to in the comments.
### Using `prompt` and `topics` together
You can send either field, both, or neither:
* **`prompt` only** — full natural-language control. Drives clip count, duration, focus, exclusions, and mode.
* **`topics` only** — the AI auto-maps to a topic-focused mode and prioritizes the listed themes.
* **Both** — the prompt wins on conflict; topics act as additional guidance the prompt can refine or override.
* **Neither** — the AI falls back to baseline virality-driven selection.
### Limits and validation
* **Length:** up to 1000 characters. Longer prompts are rejected at request validation.
* **Sanitization:** prompts are Unicode-normalized and stripped of zero-width, bidi, and other control characters. Multi-language printable text and emoji are preserved.
* **Rejection:** prompts that attempt jailbreaks, ask for unsupported instructions, or otherwise can't be processed return a `400` with a plain-language reason in the response body.
## Use Cases
Scale video production for multiple clients with automated, prompt-driven clipping workflows
Repurpose long-form content into platform-optimized clips with editorial prompts that match each show's voice
Extract key teaching moments from lectures at scale, steered by prompts that target concepts and learning objectives
Add prompt-controlled video clipping to your product without building the AI selection layer from scratch
# Create Dubbing
Source: https://docs.reap.video/api-reference/create-dubbing
POST /automation/create-dubbing
Create AI-powered voice dubbing for videos in different languages
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Transform your video content with AI-powered voice dubbing. This endpoint creates natural-sounding voiceovers in different languages while preserving the original speaker's tone and emotion. Perfect for localizing content for global audiences.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Use the [Get Dubbing Languages](/api-reference/get-dubbing-languages) endpoint to retrieve all supported language codes.
## Video Requirements
**Minimum:** 3 seconds\
**Maximum:** 10 minutes
**Maximum:** 2 GB
MP4 or MOV with clear audio
Works best with clear speech and dialogue
## Plan Limits
| Plan | Concurrent Projects |
| ------- | ------------------- |
| Creator | 3 |
| Studio | 10 |
Higher-tier plans allow you to process more videos simultaneously.
The Automation API requires an active subscription. [View pricing](https://reap.video/pricing) to compare plans.
## Response
Unique project identifier
Project title (usually the filename)
URL to the project thumbnail image
Duration in seconds that will be billed to your account
Current processing status ("processing", "completed", "failed")
Type of project ("dubbing")
Source of the original video ("Upload")
Source language of the original video
Target language for dubbing
Video metadata including duration, resolution, format, etc.
Object containing project URLs and assets
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-dubbing" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"sourceLanguage": "en-US",
"targetLanguage": "es-MX"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/create-dubbing', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
sourceLanguage: 'en-US',
targetLanguage: 'es-MX'
})
});
const project = await response.json();
console.log('Dubbing project created:', project.id);
console.log('Status:', project.status);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
'sourceLanguage': 'en-US',
'targetLanguage': 'es-MX'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/create-dubbing',
headers=headers,
json=data
)
project = response.json()
print(f"Dubbing project created: {project['id']}")
print(f"Status: {project['status']}")
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d1',
'sourceLanguage' => 'en-US',
'targetLanguage' => 'es-MX'
];
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Dubbing project created: ' . $project['id'] . "\n";
echo 'Status: ' . $project['status'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/create-dubbing"
data := map[string]interface{}{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"sourceLanguage": "en-US",
"targetLanguage": "es-MX",
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CreateDubbingExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/create-dubbing");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{" +
"\"uploadId\": \"65f1a2b3c4d5e6f7a8b9c0d1\"," +
"\"sourceLanguage\": \"en-US\"," +
"\"targetLanguage\": \"es-MX\"}";
try(OutputStream os = conn.getOutputStream()) {
byte[] input = jsonInputString.getBytes("utf-8");
os.write(input, 0, input.length);
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Dubbing project: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"title": "presentation.mp4",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d1.jpg",
"billedDuration": 450.5,
"status": "processing",
"projectType": "dubbing",
"source": "Upload",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": 450.5,
"exportResolution": 720,
"exportOrientation": "landscape",
"captionsPreset": null,
"enableCaptions": false,
"enableEmojis": false,
"enableHighlights": false,
"language": "en-US",
"dubbingLanguage": "es-MX",
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 450.5,
"width": 1920,
"height": 1080,
"fps": 30,
"format": "mp4",
"size": 89234567,
"bitrate": 1500000
},
"urls": {
"videoFile": "https://storage.reap.video/studios/65cf.../videos/65f1.../video.mp4?X-Amz-Signature=...",
"audioFile": "https://storage.reap.video/studios/65cf.../videos/65f1.../audio.mp3?X-Amz-Signature=...",
"transcription": "https://storage.reap.video/studios/65cf.../videos/65f1.../transcription.json?X-Amz-Signature=..."
},
"createdAt": 1710345600,
"updatedAt": 1710345600
}
```
```json theme={"system"}
{
"detail": "Missing upload ID."
}
```
```json theme={"system"}
{
"detail": "Invalid source language. Supported languages: en-US, es-ES, fr-FR, ..."
}
```
```json theme={"system"}
{
"detail": "Invalid target language. Supported languages: en-US, es-ES, fr-FR, ..."
}
```
```json theme={"system"}
{
"detail": "Upload not found."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Maximum concurrent projects reached. Please wait for the current projects to complete."
}
```
```json theme={"system"}
{
"detail": "Failed to create project. Please contact support."
}
```
## Processing Workflow
Extract and analyze the audio track from your video
Transcribe the original speech with precise timing
Translate the transcription to the target language
Generate natural-sounding speech in the target language
Sync the new audio with the original video timing
Combine dubbed audio with original video
## Language Pair Quality
Different language pairs have varying quality levels:
**English ↔ Spanish, French, German, Portuguese**\
Highest quality voice models and cultural adaptation
**English ↔ Italian, Dutch, Japanese, Korean**\
Excellent voice quality with good cultural nuances
**English ↔ Chinese, Arabic, Hindi, Russian**\
Good voice quality, suitable for most content types
**Other language pairs**\
Standard quality, continuously improving
## Monitoring Progress
Monitor the dubbing project using these endpoints:
1. **[Get Project Status](/api-reference/get-project-status)** - Quick status check
2. **[Get Project Details](/api-reference/get-project-details)** - Full project information
3. **[Get Project Clips](/api-reference/get-project-clips)** - Retrieve finished dubbed video
## Best Practices
**Dubbing Optimization Tips:**
* Use high-quality source audio for better results
* Choose appropriate regional language variants for your target audience
* Test with shorter clips first to evaluate voice quality
* Consider the cultural context of your target language
* Ensure clear speech in the original video for best results
## Common Use Cases
Automatically localize content libraries for international audiences
Scale course content to new markets without re-recording
Dub internal videos for multinational teams
Offer AI dubbing as a service to your clients
## Next Steps
After creating a dubbing project:
1. Monitor progress with [Get Project Status](/api-reference/get-project-status)
2. Retrieve the dubbed video with [Get Project Clips](/api-reference/get-project-clips)
3. Use the dubbed content in your applications or download for distribution
# Create Reframe
Source: https://docs.reap.video/api-reference/create-reframe
POST /automation/create-reframe
Automatically reframe videos for different aspect ratios
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Automatically reframe videos from landscape to portrait or square formats using AI. Perfect for adapting content for TikTok, Instagram Stories, and other vertical video platforms.
You must provide either `sourceUrl` (a web video URL, e.g. YouTube) or `uploadId` (a previously uploaded file), but not both. Use `selectedStart` / `selectedEnd` to reframe just a window of a longer video — only the selected window is billed.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Video Requirements
**Minimum:** 3 seconds\
**Maximum:** 10 minutes\
The source video itself can be longer — select a window with `selectedStart` / `selectedEnd`.
**Maximum:** 2 GB (uploads)
MP4 or MOV with valid video streams, or a supported web URL
Landscape source videos only — portrait sources are rejected (URL sources after download, with the charge refunded)
## Plan Limits
Reframe is available on **Creator** and **Studio** plans. Free plans cannot use this endpoint.
| Plan | Concurrent Projects | Max Resolution |
| ------- | ------------------- | -------------- |
| Creator | 3 | 1080p |
| Studio | 10 | 4K (2160p) |
The Automation API requires an active paid subscription. [View pricing](https://reap.video/pricing) to compare plans.
## Response
Unique project identifier
Project title (usually the filename)
Thumbnail URL for the project
Duration in seconds that will be billed to your account
Current processing status
* `processing` - Video is being analyzed and reframed
* `completed` - Reframing completed successfully
* `failed` - Processing failed due to an error
Type of project (always "reframe" for this endpoint)
Source of the video content, e.g. "Upload" or "Youtube"
Video genre used for AI analysis
Array of identified topics in the video
Array of clip duration preferences
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for the reframed video
Output orientation for the reframed video
Caption style preset ID (null if captions disabled)
Whether captions are enabled
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Target dubbing language (null if not applicable)
Whether transcription will be translated
Array of languages for translation
Video file metadata including duration, resolution, format, etc.
Project URLs and assets (populated when processing completes)
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-reframe" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"genre": "talking",
"orientation": "portrait",
"disableAutoSplit": false
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/create-reframe', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
genre: 'talking',
orientation: 'portrait',
disableAutoSplit: false
})
});
const project = await response.json();
console.log('Reframe project created:', project.id);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
'genre': 'talking',
'orientation': 'square',
'disableAutoSplit': False
}
response = requests.post(
'https://public.reap.video/api/v1/automation/create-reframe',
headers=headers,
json=data
)
project = response.json()
print(f'Reframe project created: {project["id"]}')
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d1',
'genre' => 'talking',
'orientation' => 'portrait',
'disableAutoSplit' => false
];
$ch = curl_init('https://public.reap.video/api/v1/automation/create-reframe');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Reframe project created: ' . $project['id'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/create-reframe"
data := map[string]interface{}{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"genre": "talking",
"orientation": "portrait",
"disableAutoSplit": false,
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CreateReframeExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/create-reframe");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{\"uploadId\":\"65f1a2b3c4d5e6f7a8b9c0d1\",\"genre\":\"talking\",\"orientation\":\"portrait\",\"disableAutoSplit\":false}";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonInputString.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Reframe project created: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d6",
"title": "Landscape Video Reframe",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d6.jpg",
"billedDuration": 600.0,
"status": "processing",
"projectType": "reframe",
"source": "Upload",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": null,
"enableCaptions": false,
"enableEmojis": false,
"enableHighlights": false,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 600.0,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 4000000,
"size": 120000000,
"codec": "h264"
},
"urls": {},
"createdAt": 1710003000,
"updatedAt": 1710003000
}
```
```json theme={"system"}
{
"detail": "Missing required parameter: uploadId"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Upload not found"
}
```
```json theme={"system"}
{
"detail": "Invalid video format or duration. Video must be between 3 seconds and 10 minutes."
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
```json theme={"system"}
{
"detail": "Maximum concurrent projects reached. Please wait for the current projects to complete."
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Processing Workflow
1. **Upload Analysis** - Video is analyzed for speakers, objects, and key visual elements
2. **Smart Cropping** - AI automatically crops and reframes to keep important content in view
3. **Motion Tracking** - Follows speakers and maintains optimal framing throughout the video
4. **Segmentation** - Optionally splits longer videos into optimal segments (unless disabled)
5. **Output Generation** - Creates reframed video in the target aspect ratio
## Reframing Features
* **Speaker Tracking**: Automatically follows speakers and keeps them centered
* **Object Recognition**: Identifies and tracks important visual elements
* **Smart Cropping**: Maintains optimal composition throughout the video
* **Smooth Transitions**: Ensures natural camera movements between focus points
* **Auto-Segmentation**: Intelligently splits content into engaging segments
## Use Cases
Automatically adapt content for YouTube, TikTok, Instagram, and more
Generate all aspect ratio variants on upload for any platform
Offer automatic reframing as a feature to your users
Scale ad creative production across different placements
## Best Practices
* **Source Quality**: Use high-resolution landscape videos for best results
* **Speaker Positioning**: Videos with centered speakers reframe more effectively
* **Content Type**: Works best with talking head videos and presentations
* **Duration**: Shorter videos (under 5 minutes) process faster and more accurately
# Create Transcription
Source: https://docs.reap.video/api-reference/create-transcription
POST /automation/create-transcription
Generate accurate transcriptions from video and audio content
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Extract accurate transcriptions from your videos using AI-powered speech recognition. This endpoint generates timestamped transcriptions with support for multiple languages, translation, and script format options. Transcription output is available in multiple formats including SRT, VTT, CSV, and TXT.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
You must provide either `sourceUrl` or `uploadId`, but not both.
## Video Requirements
**Minimum:** 3 seconds\
**Maximum:** 2 hours
**Maximum:** 5 GB
MP4 or MOV with valid audio streams
Clear speech produces best transcription results
## Plan Limits
| Plan | Concurrent Projects |
| ------- | ------------------- |
| Creator | 3 |
| Studio | 10 |
Higher-tier plans allow you to process more videos simultaneously.
The Automation API requires an active subscription. [View pricing](https://reap.video/pricing) to compare plans.
## Response
Unique project identifier
Project title (usually the filename)
Thumbnail URL for the project
Duration in seconds that will be billed to your account
Current processing status
* `processing` - Audio is being transcribed
* `completed` - Transcription has been generated successfully
* `failed` - Processing failed due to an error
Type of project (always "transcription" for this endpoint)
Source of the video content
* `Upload` - Uploaded file
* `Youtube` - YouTube URL
* `Generic` - External URL
Primary language of the video content
Whether transcription will be translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets (populated when processing completes). Includes the word-level `transcription` JSON plus transcription files in multiple formats: SRT, VTT, CSV, and TXT.
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL with Upload theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-transcription" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"language": "en",
"transcriptionScript": "native"
}'
```
```bash cURL with URL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/create-transcription" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"sourceUrl": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
"language": "en"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/create-transcription', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
uploadId: '65f1a2b3c4d5e6f7a8b9c0d1',
language: 'en',
transcriptionScript: 'native'
})
});
const project = await response.json();
console.log('Transcription project created:', project.id);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'uploadId': '65f1a2b3c4d5e6f7a8b9c0d1',
'language': 'en',
'transcriptionScript': 'native'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/create-transcription',
headers=headers,
json=data
)
project = response.json()
print(f'Transcription project created: {project["id"]}')
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d1',
'language' => 'en',
'transcriptionScript' => 'native'
];
$ch = curl_init('https://public.reap.video/api/v1/automation/create-transcription');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Transcription project created: ' . $project['id'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/create-transcription"
data := map[string]interface{}{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"language": "en",
"transcriptionScript": "native",
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class CreateTranscriptionExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/create-transcription");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{" +
"\"uploadId\": \"65f1a2b3c4d5e6f7a8b9c0d1\"," +
"\"language\": \"en\"," +
"\"transcriptionScript\": \"native\"}";
try(OutputStream os = conn.getOutputStream()) {
byte[] input = jsonInputString.getBytes("utf-8");
os.write(input, 0, input.length);
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Transcription project: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "my-video.mp4",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 180.5,
"status": "processing",
"projectType": "transcription",
"source": "Upload",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 720,
"exportOrientation": "landscape",
"captionsPreset": null,
"enableCaptions": false,
"enableEmojis": false,
"enableHighlights": false,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 180.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 45000000,
"codec": "h264"
},
"urls": {},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
```
```json theme={"system"}
{
"detail": "Missing source URL or upload ID."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Upload not found."
}
```
```json theme={"system"}
{
"detail": "Maximum concurrent projects reached. Please wait for the current projects to complete."
}
```
```json theme={"system"}
{
"detail": "Failed to create project. Please contact support."
}
```
## Processing Workflow
1. **Audio Extraction** - Audio is extracted from the video file
2. **Speech Recognition** - AI transcribes the speech with word-level timing
3. **Translation** - If a translation language is specified, the transcription is translated
4. **Format Generation** - Output is generated in multiple formats (SRT, VTT, CSV, TXT)
5. **Completion** - Use [Get Project Status](/api-reference/get-project-status) to monitor progress
## Output Formats
When transcription completes, the `urls` object in [Get Project Details](/api-reference/get-project-details) includes:
| Format | Field | Description |
| ------ | ------------------- | ----------------------------------------------------------------------------------- |
| JSON | `transcription` | Word-level transcript with timestamps (the translated version when translation ran) |
| SRT | `transcription_srt` | SubRip subtitle format |
| VTT | `transcription_vtt` | WebVTT subtitle format |
| CSV | `transcription_csv` | Comma-separated values |
| TXT | `transcription_txt` | Plain text transcript |
| Audio | `audioFile` | Extracted audio file |
The `transcription_srt/vtt/csv/txt` exports are only generated for transcription projects. The word-level `transcription` JSON is available on every project type.
## Best Practices
* **Audio Quality**: Clear audio with minimal background noise produces more accurate results
* **Language Selection**: Specify the language explicitly for better transcription accuracy
* **Script Format**: Use "roman" for romanized output of non-Latin script languages
* **Translation**: Combine with `translationLanguage` to get translated transcriptions
## Use Cases
Generate searchable text from video libraries at scale
Create SRT/VTT files for video players and platforms
Transcribe recorded meetings and webinars
Make video content accessible with accurate transcriptions
## Next Steps
After creating a transcription project:
1. Monitor progress with [Get Project Status](/api-reference/get-project-status)
2. Retrieve the full project with transcription URLs via [Get Project Details](/api-reference/get-project-details)
3. Download transcription files in your preferred format
# Delete Clip
Source: https://docs.reap.video/api-reference/delete-clip
DELETE /automation/delete-clip
Permanently delete a clip
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Permanently delete a clip and its exported video file. This action cannot be undone.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
This permanently deletes the clip and its exported video file. Cannot delete clips that are still processing.
## Response
ID of the deleted clip
Always `true` on success
## Example Request
```bash cURL theme={"system"}
curl -X DELETE "https://public.reap.video/api/v1/automation/delete-clip?projectId=65f1a2b3c4d5e6f7a8b9c0d2&clipId=65f1a2b3c4d5e6f7a8b9c0d4" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d2';
const clipId = '65f1a2b3c4d5e6f7a8b9c0d4';
const response = await fetch(`https://public.reap.video/api/v1/automation/delete-clip?projectId=${projectId}&clipId=${clipId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Deleted: ${data.deleted}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d2'
clip_id = '65f1a2b3c4d5e6f7a8b9c0d4'
response = requests.delete(
f'https://public.reap.video/api/v1/automation/delete-clip?projectId={project_id}&clipId={clip_id}',
headers=headers
)
data = response.json()
print(f"Deleted: {data['deleted']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d2"
clipId := "65f1a2b3c4d5e6f7a8b9c0d4"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/delete-clip?projectId=%s&clipId=%s", projectId, clipId)
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class DeleteClipExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d2";
String clipId = "65f1a2b3c4d5e6f7a8b9c0d4";
URL url = new URL("https://public.reap.video/api/v1/automation/delete-clip?projectId=" + projectId + "&clipId=" + clipId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("DELETE");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"deleted": true
}
```
```json theme={"system"}
{
"detail": "Cannot delete a clip that is still processing"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Clip not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Delete Post
Source: https://docs.reap.video/api-reference/delete-post
DELETE /automation/delete-post
Delete a publisher post
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Delete a publisher post. Scheduled posts will have their schedule automatically cancelled. Posts that are currently processing cannot be deleted.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Cannot delete posts that are currently processing. Scheduled posts will have their schedule cancelled automatically.
## Response
ID of the deleted post
Always `true` on success
## Example Request
```bash cURL theme={"system"}
curl -X DELETE "https://public.reap.video/api/v1/automation/delete-post?postId=67b1c2d3e4f5a6b7c8d9e0f1" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const postId = '67b1c2d3e4f5a6b7c8d9e0f1';
const response = await fetch(`https://public.reap.video/api/v1/automation/delete-post?postId=${postId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Deleted: ${data.deleted}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
post_id = '67b1c2d3e4f5a6b7c8d9e0f1'
response = requests.delete(
f'https://public.reap.video/api/v1/automation/delete-post?postId={post_id}',
headers=headers
)
data = response.json()
print(f"Deleted: {data['deleted']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type DeleteResponse struct {
PostID string `json:"postId"`
Deleted bool `json:"deleted"`
}
func main() {
postId := "67b1c2d3e4f5a6b7c8d9e0f1"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/delete-post?postId=%s", postId)
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var result DeleteResponse
json.Unmarshal(body, &result)
fmt.Printf("Post %s deleted: %t\n", result.PostID, result.Deleted)
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class DeletePostExample {
public static void main(String[] args) throws Exception {
String postId = "67b1c2d3e4f5a6b7c8d9e0f1";
URL url = new URL("https://public.reap.video/api/v1/automation/delete-post?postId=" + postId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("DELETE");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"postId": "67b1c2d3e4f5a6b7c8d9e0f1",
"deleted": true
}
```
```json theme={"system"}
{
"detail": "Cannot delete a post that is currently processing"
}
```
```json theme={"system"}
{
"detail": "Post not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Delete Project
Source: https://docs.reap.video/api-reference/delete-project
DELETE /automation/delete-project
Soft-delete a project
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Soft-delete a project. Deleted projects will no longer appear in the [Get All Projects](/api-reference/get-all-projects) response.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Cannot delete projects that are still processing. Wait for the project to reach `completed` or `failed` status before deleting.
## Response
ID of the deleted project
Always `true` on success
## Example Request
```bash cURL theme={"system"}
curl -X DELETE "https://public.reap.video/api/v1/automation/delete-project?projectId=65f1a2b3c4d5e6f7a8b9c0d2" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d2';
const response = await fetch(`https://public.reap.video/api/v1/automation/delete-project?projectId=${projectId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Deleted: ${data.deleted}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d2'
response = requests.delete(
f'https://public.reap.video/api/v1/automation/delete-project?projectId={project_id}',
headers=headers
)
data = response.json()
print(f"Deleted: {data['deleted']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d2"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/delete-project?projectId=%s", projectId)
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class DeleteProjectExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d2";
URL url = new URL("https://public.reap.video/api/v1/automation/delete-project?projectId=" + projectId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("DELETE");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"deleted": true
}
```
```json theme={"system"}
{
"detail": "Cannot delete a project that is still processing"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Project not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Delete Upload
Source: https://docs.reap.video/api-reference/delete-upload
DELETE /automation/delete-upload
Delete an uploaded file
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Permanently delete an uploaded file from storage. This action cannot be undone.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
This permanently removes the file from storage. Any projects that reference this upload will not be affected, but the original source file will no longer be available.
## Response
ID of the deleted upload
Always `true` on success
## Example Request
```bash cURL theme={"system"}
curl -X DELETE "https://public.reap.video/api/v1/automation/delete-upload?uploadId=65f1a2b3c4d5e6f7a8b9c0d1" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const uploadId = '65f1a2b3c4d5e6f7a8b9c0d1';
const response = await fetch(`https://public.reap.video/api/v1/automation/delete-upload?uploadId=${uploadId}`, {
method: 'DELETE',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Deleted: ${data.deleted}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
upload_id = '65f1a2b3c4d5e6f7a8b9c0d1'
response = requests.delete(
f'https://public.reap.video/api/v1/automation/delete-upload?uploadId={upload_id}',
headers=headers
)
data = response.json()
print(f"Deleted: {data['deleted']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
uploadId := "65f1a2b3c4d5e6f7a8b9c0d1"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/delete-upload?uploadId=%s", uploadId)
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class DeleteUploadExample {
public static void main(String[] args) throws Exception {
String uploadId = "65f1a2b3c4d5e6f7a8b9c0d1";
URL url = new URL("https://public.reap.video/api/v1/automation/delete-upload?uploadId=" + uploadId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("DELETE");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"uploadId": "65f1a2b3c4d5e6f7a8b9c0d1",
"deleted": true
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Upload not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Get All Posts
Source: https://docs.reap.video/api-reference/get-all-posts
GET /automation/get-all-posts
List publisher posts with pagination and filtering
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Retrieve a paginated list of all publisher posts. Filter by status or date range to find specific posts.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Response
Array of post objects
Unique post identifier
ID of the parent project
ID of the published clip
Array of target platform names
Platforms where publishing succeeded
Platforms where publishing failed
Array of integration IDs used for publishing
Post title
Post description
Array of tags applied to the post
Current post status
* `processing` - Post is being published
* `draft` - Post is saved as draft
* `completed` - Published successfully
* `failed` - Publishing failed
* `cancelled` - Post was cancelled
* `unresolved` - Partial success (some platforms failed)
Type of scheduling (`immediate` or `scheduled`)
Scheduled publish date as Unix timestamp (null for immediate)
Actual publish date as Unix timestamp
Published URLs per platform
Per-platform configuration
YouTube-specific settings
Video privacy: `public`, `private`, or `unlisted`
Whether the video can be embedded on other sites
Whether view counts are publicly visible
Whether the video is made for kids (COPPA compliance)
TikTok-specific settings
Video privacy: `public`, `friends`, or `private`
Disable comments on the video
Disable duets for the video
Disable stitches for the video
Mark as paid partnership / brand content
Mark as organic brand content
Instagram-specific settings
Whether to share Reels to the main feed
LinkedIn-specific settings
Post visibility: `public` or `connections`
Unix timestamp when the post was created
Unix timestamp when the post was last updated
Current page number
Total number of pages
Total number of posts matching the filters
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-posts?page=1&pageSize=10&status=completed" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const params = new URLSearchParams({
page: '1',
pageSize: '10',
status: 'completed'
});
const response = await fetch(`https://public.reap.video/api/v1/automation/get-all-posts?${params}`, {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Found ${data.totalPosts} posts (page ${data.currentPage}/${data.totalPages})`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
params = {
'page': 1,
'pageSize': 10,
'status': 'completed'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-all-posts',
headers=headers,
params=params
)
data = response.json()
print(f"Found {data['totalPosts']} posts (page {data['currentPage']}/{data['totalPages']})")
```
```php PHP theme={"system"}
1,
'pageSize' => 10,
'status' => 'completed'
]);
$ch = curl_init('https://public.reap.video/api/v1/automation/get-all-posts?' . $query);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
echo 'Found ' . $data['totalPosts'] . ' posts' . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type PostsResponse struct {
TotalPosts int `json:"totalPosts"`
CurrentPage int `json:"currentPage"`
TotalPages int `json:"totalPages"`
}
func main() {
url := "https://public.reap.video/api/v1/automation/get-all-posts?page=1&pageSize=10&status=completed"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var result PostsResponse
json.Unmarshal(body, &result)
fmt.Printf("Found %d posts (page %d/%d)\n", result.TotalPosts, result.CurrentPage, result.TotalPages)
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetAllPostsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-all-posts?page=1&pageSize=10&status=completed");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"posts": [
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube", "tiktok"],
"successPlatforms": ["youtube", "tiktok"],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1", "66a1b2c3d4e5f6a7b8c9d0e3"],
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology"],
"status": "completed",
"scheduleType": "immediate",
"scheduleDate": null,
"publishDate": 1710000300,
"urls": {
"youtube": "https://youtube.com/shorts/abc123",
"tiktok": "https://tiktok.com/@user/video/123456"
},
"platformSettings": {
"youtube": { "privacy": "public", "madeForKids": false },
"tiktok": { "privacy": "public", "disableComments": false }
},
"createdAt": 1710000000,
"updatedAt": 1710000300
}
],
"currentPage": 1,
"totalPages": 3,
"totalPosts": 24
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Get All Presets
Source: https://docs.reap.video/api-reference/get-all-presets
GET /automation/get-all-presets
Retrieve all available caption presets for your studio
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a paginated list of all caption presets available in your studio. Presets define the styling, animation, and visual presentation of captions that can be applied to your video projects.
Results are ordered with **your own presets first** (most recently edited first), followed by the built-in system presets. The ordering is stable across pages.
## Response
Array of preset objects
Unique identifier for the preset
Display name of the preset
Source type of the preset ("system" or "user")
Preset preferences and configuration
Whether to add an audiogram visualization
Whether captions are enabled by default
Default video genre ("talking", "screenshare", "gaming")
Default transcription language code
Default translation target language
Script format ("native" or "roman")
Default video orientation ("portrait", "landscape", "square")
Default export resolution (720, 1080, 1440, 2160)
Default clip duration ranges
Current page number
Total number of pages available
Total number of presets in your studio
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-presets?page=1&pageSize=20" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-all-presets?page=1&pageSize=20', {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(data.presets);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-all-presets',
headers=headers,
params={'page': 1, 'pageSize': 20}
)
data = response.json()
print(data['presets'])
```
## Example Response
```json theme={"system"}
{
"presets": [
{
"id": "system_beasty",
"name": "Beasty",
"source": "system",
"preferences": {
"addAudiogram": false,
"addCaptions": true,
"genre": "talking",
"language": "en",
"translationLanguage": null,
"transcriptionScript": "native",
"orientation": "portrait",
"resolution": 720,
"clipDurations": [[30, 60]]
}
},
{
"id": "system_minimal",
"name": "Minimal",
"source": "system",
"preferences": {
"addAudiogram": false,
"addCaptions": true,
"genre": "talking",
"language": "en",
"translationLanguage": null,
"transcriptionScript": "native",
"orientation": "portrait",
"resolution": 720,
"clipDurations": [[30, 60]]
}
},
{
"id": "custom_brand_style",
"name": "Brand Style",
"source": "user",
"preferences": {
"addAudiogram": false,
"addCaptions": true,
"genre": "talking",
"language": "en",
"translationLanguage": null,
"transcriptionScript": "native",
"orientation": "portrait",
"resolution": 1080,
"clipDurations": [[30, 60]]
}
}
],
"currentPage": 1,
"totalPages": 1,
"totalPresets": 3
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Preset Types
Caption presets control various aspects of subtitle presentation:
* **Typography**: Font family, size, weight, and color
* **Positioning**: Caption placement and alignment on screen
* **Animation**: Text entrance and exit effects
* **Background**: Caption background styling and transparency
* **Highlighting**: Keyword emphasis and emoji integration
## Common Use Cases
Choose from your own caption styles when creating video projects
Validate preset IDs before creating video projects
Maintain consistent caption styling across all your video content
Display caption style previews to help users choose the right visual presentation
## Error Responses
Unauthorized - Invalid or missing API key
Too Many Requests - Rate limit exceeded
Internal Server Error - Something went wrong on our end
## Next Steps
Once you have your presets, you can use them when creating video projects:
* [Create Clips](/api-reference/create-clips) - Use presets in clipping projects
* [Create Captions](/api-reference/create-captions) - Apply caption styles to your videos
* [Create Transcription](/api-reference/create-transcription) - Generate transcriptions from videos
* [Create Reframe](/api-reference/create-reframe) - Apply captions to reframed videos
* [Create Dubbing](/api-reference/create-dubbing) - Add styled captions to dubbed content
# Get All Projects
Source: https://docs.reap.video/api-reference/get-all-projects
GET /automation/get-all-projects
Retrieve all automation projects in your studio
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a paginated list of all video projects created through the automation API. Monitor project status and access project details.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Filtering & Search
Use query parameters to filter, search, and sort the results.
Filter by project type. Pass multiple values to match any of them.
* `clipping` - AI clip generation
* `captions` - Caption generation
* `reframe` - Video reframing
* `dubbing` - Voice dubbing
* `transcription` - Audio transcription
Filter by processing status. Pass multiple values to match any of them.
* `queued` - Waiting to be processed
* `processing` - Currently being processed
* `completed` - Processing finished successfully
* `failed` - Processing failed
* `invalid` - Video file was invalid
* `expired` - Project has expired
Search projects by title. Case-insensitive partial match.
Unix timestamp. Only return projects created after this time.
Unix timestamp. Only return projects created before this time.
Field to sort by.
* `createdAt` - Sort by creation date
* `updatedAt` - Sort by last update date
* `duration` - Sort by billed duration
Sort direction.
* `asc` - Ascending (oldest/shortest first)
* `desc` - Descending (newest/longest first)
## Response
Array of project objects
Unique project identifier
Project title (usually the filename)
Thumbnail URL for the project
Duration in seconds that was billed for this project
Current processing status
* `processing` - Project is being processed
* `completed` - Processing completed successfully
* `failed` - Processing failed
Type of project
* `clipping` - AI clip generation
* `captions` - Caption generation
* `reframe` - Video reframing
* `dubbing` - Voice dubbing
* `transcription` - Audio transcription
Source of the video content
* `Upload` - Uploaded file
* `Youtube` - YouTube URL
Video genre used for AI analysis
Array of identified topics in the video
Array of clip duration preferences
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for the project
Output orientation
Caption style preset ID (null if captions disabled)
Whether captions are enabled
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Target dubbing language (null if not applicable)
Whether transcription is translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets (populated when processing completes)
Unix timestamp when the project was created
Unix timestamp when the project was last updated
Current page number
Total number of pages
Total number of projects
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const params = new URLSearchParams({
page: '1',
pageSize: '20',
projectType: 'clipping',
status: 'completed',
sortBy: 'createdAt',
sortOrder: 'desc'
});
const response = await fetch(`https://public.reap.video/api/v1/automation/get-all-projects?${params}`, {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Found ${data.totalProjects} projects`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
params = {
'page': 1,
'pageSize': 20,
'projectType': 'clipping',
'status': 'completed',
'sortBy': 'createdAt',
'sortOrder': 'desc'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-all-projects',
headers=headers,
params=params
)
data = response.json()
print(f"Found {data['totalProjects']} projects")
```
```php PHP theme={"system"}
1,
'pageSize' => 20,
'projectType' => 'clipping',
'status' => 'completed',
'sortBy' => 'createdAt',
'sortOrder' => 'desc'
]);
$ch = curl_init('https://public.reap.video/api/v1/automation/get-all-projects?' . $params);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
echo 'Found ' . $data['totalProjects'] . ' projects' . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetAllProjectsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-all-projects?page=1&pageSize=20&projectType=clipping&status=completed&sortBy=createdAt&sortOrder=desc");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Found projects: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"projects": [
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Educational Video",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 1800.5,
"status": "completed",
"projectType": "clipping",
"source": "Upload",
"genre": "talking",
"topics": ["AI", "Technology", "Education"],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 1800.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 450000000,
"codec": "h264"
},
"urls": {
"projectUrl": "https://app.reap.video/project/65f1a2b3c4d5e6f7a8b9c0d2",
"downloadUrl": "https://cdn.reap.video/downloads/65f1a2b3c4d5e6f7a8b9c0d2.zip"
},
"createdAt": 1710000000,
"updatedAt": 1710001800
},
{
"id": "65f1a2b3c4d5e6f7a8b9c0d3",
"title": "Marketing Webinar",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d3.jpg",
"billedDuration": 3600.0,
"status": "processing",
"projectType": "clipping",
"source": "Youtube",
"genre": "talking",
"topics": [],
"clipDurations": [],
"selectedStart": 300,
"selectedEnd": 3300,
"exportResolution": 720,
"exportOrientation": "landscape",
"captionsPreset": "system_minimal",
"enableCaptions": true,
"enableEmojis": false,
"enableHighlights": false,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 3600.0,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 3000000,
"size": 800000000,
"codec": "h264"
},
"urls": {},
"createdAt": 1710002000,
"updatedAt": 1710002000
}
],
"currentPage": 1,
"totalPages": 5,
"totalProjects": 87
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Project Status Values
* **`queued`** - Project is queued and waiting to be processed
* **`processing`** - Project is currently being processed (video analysis, clip generation, etc.)
* **`completed`** - All processing has finished successfully, clips are ready
* **`failed`** - Processing failed due to an error
* **`invalid`** - Video file was invalid or unsupported
* **`expired`** - Project has expired
## Project Types
* **`clipping`** - AI-powered clip generation from long-form videos
* **`captions`** - Caption and subtitle generation
* **`reframe`** - Automatic video reframing for different aspect ratios
* **`dubbing`** - Voice dubbing and translation
* **`transcription`** - Audio transcription
## Use Cases
Build project management dashboards
Monitor multiple projects simultaneously
Track processing patterns and success rates
Organize and categorize video projects
# Get All Uploads
Source: https://docs.reap.video/api-reference/get-all-uploads
GET /automation/get-all-uploads
Retrieve all uploaded files for your studio
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a paginated list of all files uploaded to your studio via the Upload API. This endpoint helps you track upload status, manage files, and retrieve upload IDs for use in video projects.
## Response
Array of upload objects
Unique identifier for the upload
Name of the uploaded file
Type of file ("video", "audio", or "image")
Size of the file in bytes (null if not yet uploaded)
MIME type of the file (null if not yet uploaded)
Current status ("upload", "verified", or "rejected")
Unix timestamp when the upload was created
Unix timestamp when the upload was last updated
Current page number
Total number of pages available
Total number of uploads in your studio
## Upload Status Values
File upload URL has been generated but file hasn't been uploaded yet
File has been successfully uploaded and validated when first used in a project - ready for reuse
File upload failed validation (invalid format, too large, corrupted, etc.)
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-all-uploads?page=1&pageSize=20" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-all-uploads?page=1&pageSize=20', {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(data.uploads);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-all-uploads',
headers=headers,
params={'page': 1, 'pageSize': 20}
)
data = response.json()
print(data['uploads'])
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/get-all-uploads?page=1&pageSize=20"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetAllUploadsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-all-uploads?page=1&pageSize=20");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"uploads": [
{
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"fileName": "presentation.mp4",
"fileType": "video",
"fileSize": 157286400,
"contentType": "video/mp4",
"status": "verified",
"createdAt": 1710345600,
"updatedAt": 1710345660
},
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"fileName": "tutorial.mov",
"fileType": "video",
"fileSize": 234567890,
"contentType": "video/quicktime",
"status": "verified",
"createdAt": 1710345500,
"updatedAt": 1710345550
},
{
"id": "65f1a2b3c4d5e6f7a8b9c0d3",
"fileName": "demo.mp4",
"fileType": "video",
"fileSize": null,
"contentType": null,
"status": "upload",
"createdAt": 1710345400,
"updatedAt": 1710345400
}
],
"currentPage": 1,
"totalPages": 2,
"totalUploads": 25
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Filtering and Management
### Upload Status Filtering
You can filter uploads by status to find specific files:
* **Verified uploads** - Successfully validated when first used, ready for reuse
* **Pending uploads** - Upload URL generated but file not uploaded yet
* **Rejected uploads** - Failed validation and cannot be used
### File Management
Use this endpoint to:
Monitor which files have been successfully uploaded and their validation status
Review file sizes and manage your storage usage
Get upload IDs for use in project creation endpoints
Identify rejected uploads and troubleshoot problems
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Common Use Cases
Track upload status and find verified files for reuse in projects
Build upload management interfaces in your application
Process multiple uploaded files in batch operations
Analyze upload patterns and storage usage
## Next Steps
Once you have upload IDs from verified uploads, you can use them to create projects:
* [Create Clips](/api-reference/create-clips) - Generate AI-powered short clips
* [Create Captions](/api-reference/create-captions) - Add AI-generated captions to videos
* [Create Transcription](/api-reference/create-transcription) - Generate transcriptions from videos
* [Create Reframe](/api-reference/create-reframe) - Reframe videos for different aspect ratios
* [Create Dubbing](/api-reference/create-dubbing) - Add voice dubbing to videos
# Get Clip Details
Source: https://docs.reap.video/api-reference/get-clip-details
GET /automation/get-clip-details
Retrieve details for a specific clip
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get detailed information about a specific clip, including its download URL, AI-generated metadata, virality score, and export settings.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Response
Unique identifier for the clip
ID of the parent project
Direct download URL for the final clip (includes captions if enabled)
Start time of the clip in the original video (seconds)
End time of the clip in the original video (seconds)
Duration of the clip in seconds
Primary topic or theme of the clip
AI-generated title for the clip
AI-generated caption/description for the clip
Language of the clip content
Whether transcription is translated
Array of languages for translation
Target dubbing language (for dubbing projects)
Script format for transcription ("native" or "roman")
AI-predicted virality score (0-10, higher is better)
Resolution of the exported clip
Orientation of the exported clip ("landscape", "portrait", "square")
Caption style preset used for this clip
Whether captions are enabled for this clip
Whether emojis are added to captions
Whether keyword highlighting is enabled
Clip metadata including technical details
Unix timestamp when the clip was created
Unix timestamp when the clip was last updated
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-clip-details?projectId=65f1a2b3c4d5e6f7a8b9c0d2&clipId=65f1a2b3c4d5e6f7a8b9c0d4" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d2';
const clipId = '65f1a2b3c4d5e6f7a8b9c0d4';
const response = await fetch(`https://public.reap.video/api/v1/automation/get-clip-details?projectId=${projectId}&clipId=${clipId}`, {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const clip = await response.json();
console.log(`${clip.title} (Score: ${clip.viralityScore})`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d2'
clip_id = '65f1a2b3c4d5e6f7a8b9c0d4'
response = requests.get(
f'https://public.reap.video/api/v1/automation/get-clip-details?projectId={project_id}&clipId={clip_id}',
headers=headers
)
clip = response.json()
print(f"{clip['title']} (Score: {clip['viralityScore']})")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type Clip struct {
Title string `json:"title"`
ViralityScore float64 `json:"viralityScore"`
}
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d2"
clipId := "65f1a2b3c4d5e6f7a8b9c0d4"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/get-clip-details?projectId=%s&clipId=%s", projectId, clipId)
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var clip Clip
json.Unmarshal(body, &clip)
fmt.Printf("%s (Score: %.1f)\n", clip.Title, clip.ViralityScore)
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetClipDetailsExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d2";
String clipId = "65f1a2b3c4d5e6f7a8b9c0d4";
URL url = new URL("https://public.reap.video/api/v1/automation/get-clip-details?projectId=" + projectId + "&clipId=" + clipId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d4",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipUrl": "https://cdn.reap.video/clips/65f1a2b3c4d5e6f7a8b9c0d4.mp4",
"startTime": 45.2,
"endTime": 75.8,
"duration": 30.6,
"topic": "AI Technology",
"title": "The Future of Artificial Intelligence",
"caption": "Exploring how AI will transform our daily lives and work in the next decade",
"language": "en",
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"viralityScore": 8.7,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"metadata": {
"duration": 30.6,
"width": 1080,
"height": 1920,
"fps": 30,
"bitrate": 4000000,
"size": 25000000,
"codec": "h264"
},
"createdAt": 1710001800,
"updatedAt": 1710001800
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Clip not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Get Dubbing Languages
Source: https://docs.reap.video/api-reference/get-dubbing-languages
GET /automation/get-dubbing-languages
Retrieve all supported languages for video dubbing
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a comprehensive list of all supported source and target languages for video dubbing projects. This endpoint returns language codes and display names for both source language detection and target language dubbing.
## Response
Array of supported source languages for dubbing
Language code (e.g., "en-US", "es-ES", "fr-FR")
Human-readable language name (e.g., "English (United States)", "Spanish (Spain)")
Optional display name for the language
Array of supported target languages for dubbing
Language code (e.g., "en-US", "es-ES", "fr-FR")
Human-readable language name (e.g., "English (United States)", "Spanish (Spain)")
Optional display name for the language
## Language Coverage
We support over **80 languages** for dubbing, including:
English, Spanish, French, German, Italian, Portuguese, Chinese, Japanese, Korean, Arabic
Multiple regional variants for major languages (e.g., en-US, en-GB, en-AU)
Hindi, Bengali, Tamil, Telugu, Urdu, Vietnamese, Thai, Indonesian
Dutch, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-dubbing-languages" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-dubbing-languages', {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const languages = await response.json();
console.log('Source languages:', languages.sourceLanguages.length);
console.log('Target languages:', languages.targetLanguages.length);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-dubbing-languages',
headers=headers
)
languages = response.json()
print(f"Source languages: {len(languages['sourceLanguages'])}")
print(f"Target languages: {len(languages['targetLanguages'])}")
# Find English variants
english_targets = [lang for lang in languages['targetLanguages'] if 'English' in lang['name']]
print(f"English variants: {len(english_targets)}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/get-dubbing-languages"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var languages map[string]interface{}
json.Unmarshal(body, &languages)
fmt.Printf("Source languages: %d\n", len(languages["sourceLanguages"].([]interface{})))
fmt.Printf("Target languages: %d\n", len(languages["targetLanguages"].([]interface{})))
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;
public class GetDubbingLanguagesExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-dubbing-languages");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
Gson gson = new Gson();
JsonObject languages = gson.fromJson(response.toString(), JsonObject.class);
JsonArray sourceLanguages = languages.getAsJsonArray("sourceLanguages");
JsonArray targetLanguages = languages.getAsJsonArray("targetLanguages");
System.out.println("Source languages: " + sourceLanguages.size());
System.out.println("Target languages: " + targetLanguages.size());
}
}
```
## Example Response
The response includes the full supported source and target language lists. This example is shortened for readability; call the endpoint for the current complete list.
```json theme={"system"}
{
"sourceLanguages": [
{
"code": "en-US",
"name": "English (United States)"
},
{
"code": "es-ES",
"name": "Spanish (Spain)"
},
{
"code": "fr-FR",
"name": "French (France)"
}
],
"targetLanguages": [
{
"code": "en-US",
"name": "English (United States)"
},
{
"code": "es-MX",
"name": "Spanish (Mexico)"
},
{
"code": "fr-FR",
"name": "French (France)"
}
]
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Language Selection Guide
### Source Languages
Source languages are used for:
* **Automatic detection**: If not specified, we'll auto-detect the source language
* **Accuracy improvement**: Specifying the source language improves dubbing quality
* **Regional variants**: Choose the specific regional variant for better voice matching
### Target Languages
Target languages determine:
* **Voice characteristics**: Each language has native speaker voice models
* **Cultural adaptation**: Regional variants include local pronunciation and cultural nuances
* **Quality levels**: Popular language pairs have higher quality voice models
## Popular Language Pairs
**en-US** → **es-MX** (North America)\
**en-GB** → **es-ES** (Europe)
**en-US** → **fr-CA** (North America)\
**en-GB** → **fr-FR** (Europe)
**en-US** → **de-DE**\
High quality for business content
**en-US** → **pt-BR** (Brazil)\
**en-GB** → **pt-PT** (Portugal)
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Common Use Cases
Populate dropdowns and selection interfaces
Validate language codes before creating dubbing projects
Plan content localization strategies
Choose optimal language pairs for your content
## Best Practices
**Language Selection Tips:**
* Use specific regional variants when targeting specific markets
* Consider cultural context when choosing between regional variants
* Test with sample content to evaluate voice quality for your use case
* Use auto-detection for source language if uncertain
## Next Steps
Use the language codes from this endpoint when creating dubbing projects:
* [Create Dubbing](/api-reference/create-dubbing) - Create a dubbing project with specific source and target languages
# Get Integrations
Source: https://docs.reap.video/api-reference/get-integrations
GET /automation/get-integrations
List active social media integrations connected to your studio
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Retrieve all active social media integrations connected to your studio. Use this endpoint to get integration IDs needed for publishing and scheduling clips.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Integrations are connected and managed from your Reap dashboard. This endpoint only lists your active integrations.
## Response
Array of active integration objects
Unique integration identifier (use this when publishing or scheduling)
Social media platform
* `youtube` - YouTube
* `instagram` - Instagram
* `tiktok` - TikTok
* `linkedin` - LinkedIn
* `x` - X (formerly Twitter)
Whether the integration is currently active and ready to publish
Platform username or handle
Display name on the platform
URL of the profile picture on the platform
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-integrations" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-integrations', {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
data.integrations.forEach(i => {
console.log(`${i.platform}: ${i.username} (${i.id})`);
});
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-integrations',
headers=headers
)
data = response.json()
for integration in data['integrations']:
print(f"{integration['platform']}: {integration['username']} ({integration['id']})")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type Integration struct {
ID string `json:"id"`
Platform string `json:"platform"`
Username string `json:"username"`
}
type Response struct {
Integrations []Integration `json:"integrations"`
}
func main() {
url := "https://public.reap.video/api/v1/automation/get-integrations"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var result Response
json.Unmarshal(body, &result)
for _, i := range result.Integrations {
fmt.Printf("%s: %s (%s)\n", i.Platform, i.Username, i.ID)
}
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetIntegrationsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-integrations");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"integrations": [
{
"id": "66a1b2c3d4e5f6a7b8c9d0e1",
"platform": "youtube",
"isActive": true,
"username": "@mychannel",
"name": "My YouTube Channel",
"profilePictureUrl": "https://yt3.googleusercontent.com/example.jpg"
},
{
"id": "66a1b2c3d4e5f6a7b8c9d0e2",
"platform": "instagram",
"isActive": true,
"username": "myaccount",
"name": "My Instagram",
"profilePictureUrl": "https://instagram.com/example.jpg"
},
{
"id": "66a1b2c3d4e5f6a7b8c9d0e3",
"platform": "tiktok",
"isActive": true,
"username": "@mytiktok",
"name": "My TikTok",
"profilePictureUrl": "https://p16-sign.tiktokcdn.com/example.jpg"
}
]
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Get Plan Usage
Source: https://docs.reap.video/api-reference/get-plan-usage
GET /automation/get-plan-usage
Check your current plan, credit balances, and limits before submitting projects
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get your studio's current plan and credit usage. Use this to check remaining credits **before** submitting a project instead of parsing rejection errors — especially useful for agents and automated pipelines that batch work.
## Response
User-friendly plan label, e.g. `"Studio (Monthly)"` or your AppSumo tier name
Media credit pool (clipping, captions, reframing, transcription, audiograms, editor processing)
Effective spendable cap. Includes active top-up credits, so this can be higher than your plan's base allowance.
Credits consumed this billing cycle. Can exceed `total` if overage occurred.
`max(0, total - used)` — never negative.
AI credit pool (dubbing, AI voiceovers, emoji highlighter). Same `{total, used, remaining}` shape.
How many automation projects can process at once on your plan (Creator: 3, Studio: 10)
How long completed projects are kept before they expire
Unix timestamp when the usage counters reset (your next billing cycle)
## Credit Costs
Credits are consumed per billed minute of video. The multipliers by project type:
| Project type | Cost |
| ----------------- | ---------------------------- |
| Clipping | 1 media credit / minute |
| Captions | 1 media credit / minute |
| Transcription | 1 media credit / minute |
| Audiogram | 1 media credit / minute |
| Reframe | **2 media credits / minute** |
| Editor processing | **2 media credits / minute** |
| Dubbing | **0.5 AI credits / minute** |
See the [Reap Credit System guide](/help-center/reap-credit-system-complete-guide) for details and examples.
If your plan was purchased through AppSumo, `remaining` may temporarily overstate spendable credits during the first 31 days after purchase (a refund-window safeguard). If a submission is rejected despite showing remaining credits, contact support.
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-plan-usage" \
-H "Authorization: Bearer YOUR_API_KEY"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-plan-usage', {
headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});
const usage = await response.json();
if (usage.mediaCredits.remaining < 30) {
console.log('Low on media credits — top up before submitting');
}
```
```python Python theme={"system"}
import requests
response = requests.get(
'https://public.reap.video/api/v1/automation/get-plan-usage',
headers={'Authorization': 'Bearer YOUR_API_KEY'}
)
usage = response.json()
print(f"{usage['plan']}: {usage['mediaCredits']['remaining']} media credits left")
```
## Example Response
```json theme={"system"}
{
"plan": "Studio (Monthly)",
"mediaCredits": {
"total": 4000,
"used": 1240,
"remaining": 2760
},
"aiCredits": {
"total": 400,
"used": 35,
"remaining": 365
},
"maxConcurrentProjects": 10,
"projectRetentionDays": 90,
"resetsOn": 1785412800
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Next Steps
* **Low on media credits?** Get a checkout link with [Top Up Media Credits](/api-reference/top-up-media-credits)
* **Changing plans?** Get a billing portal link with [Manage Subscription](/api-reference/manage-subscription)
# Get Post Details
Source: https://docs.reap.video/api-reference/get-post-details
GET /automation/get-post-details
Get details of a specific publisher post
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Retrieve the full details of a specific publisher post, including its current status, platform URLs, and configuration.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Response
Unique post identifier
ID of the parent project
ID of the published clip
Array of target platform names
Platforms where publishing succeeded
Platforms where publishing failed
Array of integration IDs used for publishing
Post title
Post description
Array of tags applied to the post
Current post status
* `processing` - Post is being published
* `draft` - Post is saved as draft
* `scheduled` - Post is scheduled for future publishing
* `completed` - Published successfully
* `failed` - Publishing failed
* `cancelled` - Post was cancelled
* `unresolved` - Partial success (some platforms failed)
Type of scheduling (`immediate` or `scheduled`)
Scheduled publish date as Unix timestamp (null for immediate)
Actual publish date as Unix timestamp
Published URLs per platform (populated after successful publishing)
Per-platform configuration
YouTube-specific settings
Video privacy: `public`, `private`, or `unlisted`
Whether the video can be embedded on other sites
Whether view counts are publicly visible
Whether the video is made for kids (COPPA compliance)
TikTok-specific settings
Video privacy: `public`, `friends`, or `private`
Disable comments on the video
Disable duets for the video
Disable stitches for the video
Mark as paid partnership / brand content
Mark as organic brand content
Instagram-specific settings
Whether to share Reels to the main feed
LinkedIn-specific settings
Post visibility: `public` or `connections`
Unix timestamp when the post was created
Unix timestamp when the post was last updated
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-post-details?postId=67b1c2d3e4f5a6b7c8d9e0f1" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const postId = '67b1c2d3e4f5a6b7c8d9e0f1';
const response = await fetch(`https://public.reap.video/api/v1/automation/get-post-details?postId=${postId}`, {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const post = await response.json();
console.log(`Post ${post.id}: ${post.status}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
post_id = '67b1c2d3e4f5a6b7c8d9e0f1'
response = requests.get(
f'https://public.reap.video/api/v1/automation/get-post-details?postId={post_id}',
headers=headers
)
post = response.json()
print(f"Post {post['id']}: {post['status']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type Post struct {
ID string `json:"id"`
Status string `json:"status"`
}
func main() {
postId := "67b1c2d3e4f5a6b7c8d9e0f1"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/get-post-details?postId=%s", postId)
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var post Post
json.Unmarshal(body, &post)
fmt.Printf("Post %s: %s\n", post.ID, post.Status)
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetPostDetailsExample {
public static void main(String[] args) throws Exception {
String postId = "67b1c2d3e4f5a6b7c8d9e0f1";
URL url = new URL("https://public.reap.video/api/v1/automation/get-post-details?postId=" + postId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube", "tiktok"],
"successPlatforms": ["youtube", "tiktok"],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1", "66a1b2c3d4e5f6a7b8c9d0e3"],
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology"],
"status": "completed",
"scheduleType": "immediate",
"scheduleDate": null,
"publishDate": 1710000300,
"urls": {
"youtube": "https://youtube.com/shorts/abc123",
"tiktok": "https://tiktok.com/@user/video/123456"
},
"platformSettings": {
"youtube": {
"privacy": "public",
"embeddable": true,
"publicStats": true,
"madeForKids": false
},
"tiktok": {
"privacy": "public",
"disableComments": false,
"disableDuet": false,
"disableStitch": false,
"brandContent": false,
"brandOrganic": false
}
},
"createdAt": 1710000000,
"updatedAt": 1710000300
}
```
```json theme={"system"}
{
"detail": "Post not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Get Project Clips
Source: https://docs.reap.video/api-reference/get-project-clips
GET /automation/get-project-clips
Retrieve all clips generated from a video project
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get all clips generated from a completed video project. This endpoint returns downloadable URLs for each clip, along with metadata like virality scores, titles, and captions.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
## Response
Array of clip objects
Unique identifier for the clip
ID of the parent project
Direct download URL for the final clip (includes captions if enabled)
Start time of the clip in the original video (seconds)
End time of the clip in the original video (seconds)
Duration of the clip in seconds
Primary topic or theme of the clip
AI-generated title for the clip
AI-generated caption/description for the clip
Language of the clip content
Whether transcription is translated
Array of languages for translation
Target dubbing language (for dubbing projects)
Script format for transcription ("native" or "roman")
AI-predicted virality score (0-10, higher is better)
Resolution of the exported clip
Orientation of the exported clip ("landscape", "portrait", "square")
Caption style preset used for this clip
Whether captions are enabled for this clip
Whether emojis are added to captions
Whether keyword highlighting is enabled
Clip metadata including technical details
Unix timestamp when the clip was created
Unix timestamp when the clip was last updated
Current page number
Total number of pages available
Total number of clips in the project
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-project-clips?projectId=65f1a2b3c4d5e6f7a8b9c0d2&page=1&pageSize=10" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d2';
const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-clips?projectId=${projectId}&page=1&pageSize=10`, {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const data = await response.json();
console.log(`Found ${data.totalClips} clips`);
data.clips.forEach(clip => {
console.log(`${clip.title} (Score: ${clip.viralityScore})`);
});
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d2'
response = requests.get(
f'https://public.reap.video/api/v1/automation/get-project-clips?projectId={project_id}&page=1&pageSize=10',
headers=headers
)
data = response.json()
print(f"Found {data['totalClips']} clips")
for clip in data['clips']:
print(f"{clip['title']} (Score: {clip['viralityScore']})")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type Clip struct {
Title string `json:"title"`
ViralityScore float64 `json:"viralityScore"`
}
type Response struct {
TotalClips int `json:"totalClips"`
Clips []Clip `json:"clips"`
}
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d2"
url := fmt.Sprintf("https://public.reap.video/api/v1/automation/get-project-clips?projectId=%s&page=1&pageSize=10", projectId)
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var result Response
json.Unmarshal(body, &result)
fmt.Printf("Found %d clips\n", result.TotalClips)
for _, clip := range result.Clips {
fmt.Printf("%s (Score: %.1f)\n", clip.Title, clip.ViralityScore)
}
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetProjectClipsExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d2";
URL url = new URL("https://public.reap.video/api/v1/automation/get-project-clips?projectId=" + projectId + "&page=1&pageSize=10");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"clips": [
{
"id": "65f1a2b3c4d5e6f7a8b9c0d4",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipUrl": "https://cdn.reap.video/clips/65f1a2b3c4d5e6f7a8b9c0d4.mp4",
"startTime": 45.2,
"endTime": 75.8,
"duration": 30.6,
"topic": "AI Technology",
"title": "The Future of Artificial Intelligence",
"caption": "Exploring how AI will transform our daily lives and work in the next decade",
"language": "en",
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"viralityScore": 8.7,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"metadata": {
"duration": 30.6,
"width": 1080,
"height": 1920,
"fps": 30,
"bitrate": 4000000,
"size": 25000000,
"codec": "h264"
},
"createdAt": 1710001800,
"updatedAt": 1710001800
},
{
"id": "65f1a2b3c4d5e6f7a8b9c0d5",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipUrl": "https://cdn.reap.video/clips/65f1a2b3c4d5e6f7a8b9c0d5.mp4",
"startTime": 120.5,
"endTime": 180.2,
"duration": 59.7,
"topic": "Machine Learning",
"title": "Understanding Neural Networks",
"caption": "A beginner-friendly explanation of how neural networks process information",
"language": "en",
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"viralityScore": 7.3,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"metadata": {
"duration": 59.7,
"width": 1080,
"height": 1920,
"fps": 30,
"bitrate": 4000000,
"size": 48000000,
"codec": "h264"
},
"createdAt": 1710001800,
"updatedAt": 1710001800
}
],
"currentPage": 1,
"totalPages": 3,
"totalClips": 12
}
```
```json theme={"system"}
{
"detail": "Missing required parameter: projectId"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Project not found or no clips available"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Virality Score
The virality score is an AI-predicted metric (0-10) that indicates how likely a clip is to perform well on social media:
* **9-10**: Exceptional content with viral potential
* **7-8**: High-quality content likely to perform well
* **5-6**: Good content suitable for regular posting
* **3-4**: Average content that may need optimization
* **1-2**: Lower-quality content requiring review
## Clip Status
Clips are only returned when the parent project status is `completed`. If the project is still `processing`, this endpoint will return an empty clips array.
## Use Cases
Download clips for posting across social platforms
Use virality scores to prioritize high-potential content
Retrieve all clips for automated publishing workflows
Review clip titles and captions before publishing
# Get Project Details
Source: https://docs.reap.video/api-reference/get-project-details
GET /automation/get-project-details
Retrieve complete details and configuration for a video project
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get comprehensive information about a video project, including processing configuration, metadata, and current status. This endpoint returns the full project object with all settings and URLs.
## Response
Unique project identifier
Project title (usually the filename or video title)
URL to the project thumbnail image
Duration in seconds that was billed to your account
Current processing status ("processing", "completed", "failed", "cancelled")
Type of project ("clipping", "captions", "reframe", "dubbing", "transcription")
Source of the original video ("Youtube", "Upload", "Generic")
Video genre for AI analysis ("talking", "screenshare", "gaming")
Array of topic strings identified in the video
Array of clip duration objects with min/max values
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for clips (720, 1080, 1440, 2160)
Output orientation ("landscape", "portrait", "square")
Caption style preset ID (null if captions disabled)
Whether captions are enabled for this project
Whether emojis are added to captions
Whether keywords are highlighted in captions
Primary language of the video content
Target language for dubbing projects
Whether transcription is translated to other languages
Array of language codes for translation
Script format for transcription ("native" or "roman")
Video metadata including duration, resolution, format, etc.
Object containing various project URLs and assets
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-project-details?projectId=65f1a2b3c4d5e6f7a8b9c0d1" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d1';
const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-details?projectId=${projectId}`, {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const project = await response.json();
console.log('Project:', project.title);
console.log('Status:', project.status);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d1'
response = requests.get(
'https://public.reap.video/api/v1/automation/get-project-details',
headers=headers,
params={'projectId': project_id}
)
project = response.json()
print(f"Project: {project['title']}")
print(f"Status: {project['status']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d1"
url := "https://public.reap.video/api/v1/automation/get-project-details?projectId=" + projectId
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetProjectDetailsExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d1";
URL url = new URL("https://public.reap.video/api/v1/automation/get-project-details?projectId=" + projectId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"title": "my-presentation.mp4",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d1.jpg",
"billedDuration": 1800.5,
"status": "completed",
"projectType": "clipping",
"source": "Upload",
"genre": "talking",
"topics": ["marketing", "business", "strategy"],
"clipDurations": [
{"min": 15, "max": 30},
{"min": 30, "max": 60}
],
"selectedStart": 0,
"selectedEnd": 1800,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 1800.5,
"width": 1920,
"height": 1080,
"fps": 30,
"format": "mp4",
"size": 157286400,
"bitrate": 2500000
},
"urls": {
"videoFile": "https://storage.reap.video/studios/65cf.../videos/65f1.../video.mp4?X-Amz-Signature=...",
"audioFile": "https://storage.reap.video/studios/65cf.../videos/65f1.../audio.mp3?X-Amz-Signature=...",
"transcription": "https://storage.reap.video/studios/65cf.../videos/65f1.../transcription.json?X-Amz-Signature=..."
},
"createdAt": 1710345600,
"updatedAt": 1710347400
}
```
```json theme={"system"}
{
"detail": "Project not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Project Configuration
### Clipping Projects
For clipping projects, the response includes:
* `topics`: AI-identified topics in the video
* `clipDurations`: Preferred clip length ranges
* `genre`: Video genre for better AI analysis
* `exportOrientation`: Output aspect ratio — `portrait`/`square` clips are auto-cropped from the source
### Caption Projects
For caption projects, the response includes:
* `captionsPreset`: Style preset for captions
* `enableEmojis`: Whether emojis are added
* `enableHighlights`: Whether keywords are highlighted
* `language`: Primary language of the content
### Reframe Projects
For reframe projects, the response includes:
* `exportOrientation`: Target orientation (portrait/square)
* `genre`: Video genre for better reframing
### Transcription Projects
For transcription projects, the response includes:
* `language`: Primary language of the content
* `translateTranscription`: Whether transcription is translated
* `translationLanguages`: Target translation languages
* `transcriptionScript`: Script format ("native" or "roman")
### Dubbing Projects
For dubbing projects, the response includes:
* `language`: Source language of the video
* `dubbingLanguage`: Target language for dubbing
* `translateTranscription`: Whether transcription is translated
## URLs Object
The `urls` object contains presigned URLs for the project's assets:
URL of the processed source video
URL of the extracted audio track
URL of the word-level transcript JSON (the translated version when translation ran). Useful for auditing a video's content without playback.
SRT subtitle file — **transcription projects only**
WebVTT subtitle file — **transcription projects only**
CSV transcript — **transcription projects only**
Plain-text transcript — **transcription projects only**
URLs are presigned and expire. Always use the most recent URLs from API responses. The `transcription_srt/vtt/csv/txt` exports are only generated for transcription projects — other project types include just `videoFile`, `audioFile`, and `transcription`.
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Common Use Cases
Get detailed status and configuration information
Verify project settings and parameters
Access video metadata and processing details
Retrieve URLs for project assets and files
## Next Steps
Based on the project details:
* **Completed Projects**: Use [Get Project Clips](/api-reference/get-project-clips) to retrieve clips
* **Processing Projects**: Monitor with [Get Project Status](/api-reference/get-project-status)
* **Failed Projects**: Review configuration and retry if needed
# Get Project Status
Source: https://docs.reap.video/api-reference/get-project-status
GET /automation/get-project-status
Check the current processing status of a video project
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get the current processing status of a video project. This is a lightweight endpoint that returns essential status information for monitoring project progress without fetching full project details.
## Response
The unique identifier of the project
Type of project ("clipping", "captions", "reframe", "dubbing", or "transcription")
Source of the original video ("Youtube", "Upload", or "Generic")
Current processing status of the project
## Project Status Values
Project is queued and waiting to be processed
Project is currently being processed by our AI systems
Project has finished processing successfully - clips are ready
Project processing failed due to an error
Project was cancelled before completion
## Project Type Values
AI-powered short clip generation from long-form videos
Caption generation and styling for videos
Video reframing for different aspect ratios
Voice dubbing and translation services
Audio transcription for videos
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-project-status?projectId=65f1a2b3c4d5e6f7a8b9c0d1" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const projectId = '65f1a2b3c4d5e6f7a8b9c0d1';
const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-status?projectId=${projectId}`, {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const status = await response.json();
console.log('Project status:', status.status);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
project_id = '65f1a2b3c4d5e6f7a8b9c0d1'
response = requests.get(
'https://public.reap.video/api/v1/automation/get-project-status',
headers=headers,
params={'projectId': project_id}
)
status = response.json()
print(f"Project {status['projectId']} is {status['status']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
projectId := "65f1a2b3c4d5e6f7a8b9c0d1"
url := "https://public.reap.video/api/v1/automation/get-project-status?projectId=" + projectId
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetProjectStatusExample {
public static void main(String[] args) throws Exception {
String projectId = "65f1a2b3c4d5e6f7a8b9c0d1";
URL url = new URL("https://public.reap.video/api/v1/automation/get-project-status?projectId=" + projectId);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d1",
"projectType": "clipping",
"source": "Upload",
"status": "processing"
}
```
```json theme={"system"}
{
"detail": "Project not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Polling Example
**Prefer webhooks over polling.** Set up [webhooks](/api-reference/webhooks) to get notified automatically when projects reach a final state, instead of polling this endpoint in a loop.
For cases where polling is needed, use a separate polling loop that calls this endpoint at regular intervals:
```javascript theme={"system"}
async function waitForCompletion(projectId) {
const pollInterval = 5000; // 5 seconds
while (true) {
const response = await fetch(`https://public.reap.video/api/v1/automation/get-project-status?projectId=${projectId}`, {
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const status = await response.json();
if (status.status === 'completed') {
console.log('Project completed successfully!');
break;
} else if (status.status === 'failed') {
console.log('Project failed');
break;
}
console.log('Still processing...');
await new Promise(resolve => setTimeout(resolve, pollInterval));
}
}
```
## Processing Times
Typical processing times by project type:
**5-15 minutes** depending on video length and complexity
**2-5 minutes** for most video lengths
**3-8 minutes** depending on video length
**10-20 minutes** depending on video length and language pair
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Best Practices
**Polling Guidelines:**
* Poll every 5-10 seconds for active monitoring
* Use exponential backoff for long-running projects
* Handle rate limits gracefully in your polling logic
* Consider using [webhooks](/api-reference/webhooks) for production applications instead of polling
## Common Use Cases
Track project progress in real-time user interfaces
Build automated systems that wait for project completion
Create monitoring dashboards for multiple projects
Detect and handle failed projects in your applications
## Next Steps
Based on the project status:
* **Processing**: Continue monitoring or check [Get Project Details](/api-reference/get-project-details)
* **Completed**: Retrieve results with [Get Project Clips](/api-reference/get-project-clips)
* **Failed**: Review project details and retry if needed
# Get Translation Languages
Source: https://docs.reap.video/api-reference/get-translation-languages
GET /automation/get-translation-languages
Retrieve all supported languages for caption translation
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a comprehensive list of all supported source and target languages for caption translation. This endpoint returns language codes and display names for transcription source languages and translation target languages.
## Response
Array of supported source languages for transcription
Language code (e.g., "en", "es", "fr")
Human-readable language name (e.g., "English", "Español", "Français")
Optional display name for the language
Array of supported target languages for translation
Language code (e.g., "en")
Human-readable language name (e.g., "English")
Optional display name for the language
## Language Coverage
We support over **100 languages** for transcription and translation, including:
English, Spanish, French, German, Italian, Portuguese, Chinese, Japanese, Korean, Arabic, Russian
Hindi, Bengali, Tamil, Telugu, Vietnamese, Thai, Indonesian, Malay, Tagalog
Dutch, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian, Greek, Romanian
Hebrew, Turkish, Ukrainian, Persian, Urdu, Swahili, and many more
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-translation-languages" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-translation-languages', {
method: 'GET',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
});
const languages = await response.json();
console.log('Source languages:', languages.sourceLanguages.length);
console.log('Target languages:', languages.targetLanguages.length);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
response = requests.get(
'https://public.reap.video/api/v1/automation/get-translation-languages',
headers=headers
)
languages = response.json()
print(f"Source languages: {len(languages['sourceLanguages'])}")
print(f"Target languages: {len(languages['targetLanguages'])}")
# Find a specific language
spanish = next((lang for lang in languages['sourceLanguages'] if lang['code'] == 'es'), None)
if spanish:
print(f"Spanish: {spanish['name']}")
```
```php PHP theme={"system"}
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/get-translation-languages"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
var languages map[string]interface{}
json.Unmarshal(body, &languages)
fmt.Printf("Source languages: %d\n", len(languages["sourceLanguages"].([]interface{})))
fmt.Printf("Target languages: %d\n", len(languages["targetLanguages"].([]interface{})))
}
```
```java Java theme={"system"}
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetTranslationLanguagesExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-translation-languages");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
StringBuilder response = new StringBuilder();
String line;
while ((line = br.readLine()) != null) {
response.append(line);
}
br.close();
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"sourceLanguages": [
{
"code": "en",
"name": "English"
},
{
"code": "zh",
"name": "中文"
},
{
"code": "de",
"name": "Deutsch"
},
{
"code": "es",
"name": "Español"
},
{
"code": "ru",
"name": "Русский"
},
{
"code": "ko",
"name": "한국어"
},
{
"code": "fr",
"name": "Français"
},
{
"code": "ja",
"name": "日本語"
},
{
"code": "pt",
"name": "Português"
},
{
"code": "tr",
"name": "Türkçe"
},
{
"code": "pl",
"name": "Polski"
},
{
"code": "nl",
"name": "Nederlands"
},
{
"code": "ar",
"name": "العربية"
},
{
"code": "it",
"name": "Italiano"
},
{
"code": "hi",
"name": "हिन्दी"
},
{
"code": "vi",
"name": "Tiếng Việt"
},
{
"code": "he",
"name": "עברית"
},
{
"code": "uk",
"name": "Українська"
},
{
"code": "el",
"name": "Ελληνικά"
},
{
"code": "th",
"name": "ไทย"
}
],
"targetLanguages": [
{
"code": "en",
"name": "English"
}
]
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Internal Server Error - Something went wrong on our end"
}
```
## Language Selection Guide
### Source Languages
Source languages are used for:
* **Transcription**: Specify the language of speech in your video
* **Auto-detection**: If not specified, the language will be auto-detected
* **Accuracy**: Specifying the correct language improves transcription accuracy
### Target Languages
Target languages determine:
* **Translation output**: The language captions will be translated to
* **Currently supported**: English (more languages coming soon)
## Difference from Dubbing Languages
| Feature | Translation Languages | Dubbing Languages |
| -------- | ----------------------------- | ------------------------------ |
| Purpose | Caption/subtitle translation | Voice dubbing |
| Format | Simple codes (e.g., "en") | Regional codes (e.g., "en-US") |
| Output | Text captions | Audio voiceover |
| Use with | Create Clips, Create Captions | Create Dubbing |
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Common Use Cases
Populate language dropdowns in your application
Validate language codes before creating projects
Plan content strategy for different language audiences
Show users available languages when auto-detection is uncertain
## Best Practices
**Language Selection Tips:**
* Use auto-detection when unsure of the source language
* Specify the language explicitly for better transcription accuracy
* Consider your target audience when choosing translation languages
* Test with sample content to evaluate transcription quality
## Next Steps
Use the language codes from this endpoint when creating projects:
* [Create Clips](/api-reference/create-clips) - Use `language` and `translationLanguage` parameters
* [Create Captions](/api-reference/create-captions) - Use `language` and `translationLanguage` parameters
* [Create Transcription](/api-reference/create-transcription) - Use `language` and `translationLanguage` parameters
# Get Upload URL
Source: https://docs.reap.video/api-reference/get-upload-url
POST /automation/get-upload-url
Get a presigned URL to upload video files to Reap
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Generate a secure, time-limited upload URL for video files. This endpoint creates a presigned URL that allows you to upload files directly to our storage service. After uploading, you can immediately use the upload ID in project creation - validation happens automatically when the file is first used.
## File Requirements
**MP4** and **MOV** files only
**Maximum:** 5 GB per file
**Maximum:** 1000 characters
Files are validated when first used in a project
## Response
Presigned URL for uploading the file (expires after a limited time)
Unique identifier for this upload
Name of the file as it will be stored
Type of file ("video", "audio", or "image")
Size of the file in bytes (null until upload completes)
MIME type of the file (null until upload completes)
Current status of the upload ("upload", "verified", or "rejected")
Unix timestamp when the upload record was created
Unix timestamp when the upload record was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/get-upload-url" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"filename": "my-presentation.mp4"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-upload-url', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
filename: 'my-presentation.mp4'
})
});
const uploadData = await response.json();
console.log('Upload URL:', uploadData.uploadUrl);
console.log('Upload ID:', uploadData.id);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'filename': 'my-presentation.mp4'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/get-upload-url',
headers=headers,
json=data
)
upload_data = response.json()
print(f"Upload URL: {upload_data['uploadUrl']}")
print(f"Upload ID: {upload_data['id']}")
```
```php PHP theme={"system"}
'my-presentation.mp4'
];
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$upload_data = json_decode($response, true);
echo 'Upload URL: ' . $upload_data['uploadUrl'] . "\n";
echo 'Upload ID: ' . $upload_data['id'] . "\n";
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
url := "https://public.reap.video/api/v1/automation/get-upload-url"
data := map[string]string{
"filename": "my-presentation.mp4",
}
payload, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetUploadUrlExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/get-upload-url");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonInputString = "{\"filename\": \"my-presentation.mp4\"}";
try(OutputStream os = conn.getOutputStream()) {
byte[] input = jsonInputString.getBytes("utf-8");
os.write(input, 0, input.length);
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Upload response: " + response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"uploadUrl": "https://reap-user-uploads.s3.amazonaws.com/studios/65f1a2b3c4d5e6f7a8b9c0d1/api-uploads/my-presentation-abc123.mp4?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=...",
"id": "65f1a2b3c4d5e6f7a8b9c0d1",
"fileName": "my-presentation.mp4",
"fileType": "video",
"fileSize": null,
"contentType": null,
"status": "upload",
"createdAt": 1710345600,
"updatedAt": 1710345600
}
```
```json theme={"system"}
{
"detail": "Missing or invalid filename."
}
```
```json theme={"system"}
{
"detail": "Unsupported file type. Supported file types: .mp4, .mov"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit exceeded"
}
```
```json theme={"system"}
{
"detail": "Failed to create upload URL. Please try again."
}
```
## Upload Process
After receiving the upload URL, follow these steps:
### 1. Upload Your File
Use the provided `uploadUrl` to upload your video file:
```bash cURL theme={"system"}
curl -X PUT "UPLOAD_URL_FROM_RESPONSE" \
-H "Content-Type: video/mp4" \
--data-binary @/path/to/your/video.mp4
```
```python Python theme={"system"}
import requests
upload_url = "UPLOAD_URL_FROM_RESPONSE"
file_path = "/path/to/your/video.mp4"
with open(file_path, 'rb') as file:
response = requests.put(
upload_url,
data=file,
headers={'Content-Type': 'video/mp4'}
)
if response.status_code == 200:
print("Upload successful!")
else:
print(f"Upload failed: {response.status_code}")
```
The upload URL expires after a limited time. Upload your file immediately after receiving the URL.
### 2. Use in Projects
After uploading, you can immediately use the upload ID in project creation endpoints like:
* [Create Clips](/api-reference/create-clips)
* [Create Captions](/api-reference/create-captions)
* [Create Transcription](/api-reference/create-transcription)
* [Create Reframe](/api-reference/create-reframe)
* [Create Dubbing](/api-reference/create-dubbing)
## File Validation
Files are validated when first used in a project. The validation process checks:
Must be MP4 or MOV format with valid video streams
Maximum size of 5 GB per file
Varies by project type (see individual project endpoints)
Must contain valid video and audio streams
### Upload Status Flow
* **"upload"** - Initial status after file upload
* **"verified"** - File validated successfully when first used in a project
* **"rejected"** - File failed validation when first used in a project
Files remain in "upload" status until they are used in a project for the first time. Only then are they validated and marked as "verified" or "rejected".
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Best Practices
* You can use upload IDs immediately after uploading - no need to wait for verification
* Use descriptive filenames to help identify uploads later
* Keep track of upload IDs for future reference
* Handle upload failures gracefully by requesting new upload URLs
* To reuse files, use uploads with "verified" status from the [Get All Uploads](/api-reference/get-all-uploads) endpoint
## Next Steps
After uploading your file:
1. Create a project using the upload ID (validation happens automatically):
* [Create Clips](/api-reference/create-clips) - Generate short clips
* [Create Captions](/api-reference/create-captions) - Add AI-generated captions
* [Create Transcription](/api-reference/create-transcription) - Generate transcriptions
* [Create Reframe](/api-reference/create-reframe) - Reframe for different aspect ratios
* [Create Dubbing](/api-reference/create-dubbing) - Add voice dubbing
2. For reusing files, check [Get All Uploads](/api-reference/get-all-uploads) for uploads with "verified" status
# Manage Subscription
Source: https://docs.reap.video/api-reference/manage-subscription
GET /automation/manage-subscription
Get a Stripe billing portal link to change plan, update payment details, or cancel
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a Stripe billing-portal link for the studio's subscription. In the portal the user can change plan, update the payment method, view invoices, or cancel. Like [Top Up Media Credits](/api-reference/top-up-media-credits), this endpoint only returns a URL — all changes happen in the browser.
**Admin keys only.** Only API keys created by the studio admin can call this endpoint; member keys receive a `403`.
Plans purchased through **AppSumo** are managed in your AppSumo account, not Stripe. AppSumo subscriptions receive a `400` with a message pointing to appsumo.com.
## Response
Stripe billing-portal URL. Open it in a browser to manage the subscription.
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/manage-subscription" \
-H "Authorization: Bearer YOUR_API_KEY"
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/manage-subscription', {
headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});
const { url } = await response.json();
console.log('Manage your subscription at:', url);
```
```python Python theme={"system"}
import requests
response = requests.get(
'https://public.reap.video/api/v1/automation/manage-subscription',
headers={'Authorization': 'Bearer YOUR_API_KEY'}
)
print('Manage your subscription at:', response.json()['url'])
```
## Example Response
```json theme={"system"}
{
"url": "https://billing.stripe.com/p/session/live_XYZ..."
}
```
```json theme={"system"}
{
"detail": "Your plan was purchased through AppSumo, so billing is managed in your AppSumo account, not Stripe. Visit appsumo.com to manage your plan."
}
```
```json theme={"system"}
{
"detail": "Only the studio admin can manage the subscription."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Next Steps
* **Just need more media credits?** Use [Top Up Media Credits](/api-reference/top-up-media-credits) — it works for any API key and doesn't change your plan
* **Check current plan and usage** with [Get Plan Usage](/api-reference/get-plan-usage)
# MCP
Source: https://docs.reap.video/api-reference/mcp
Connect your AI agent to your Reap workspace: create clips, add captions, reframe, dub, and publish via Model Context Protocol
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The Reap MCP server connects your AI agent directly to your Reap workspace. Once connected, your agent can run the full pipeline for you -- upload a video, generate clips, add captions, reframe, dub, transcribe, and publish to social platforms -- all from inside your chat.
Works with **Cursor**, **Claude Code**, **VS Code**, **GitHub Copilot**, **Codex**, **Gemini CLI**, and any other MCP-compatible agent.
The MCP server requires a paid plan with API access enabled.
## How it works
1. **Add** the endpoint `https://mcp.reap.video/mcp` to your agent.
2. **Authorize** once via OAuth: sign in and pick the workspace the agent may use.
3. **Use** the tools in chat. No API key to copy, no local server to run.
The agent only ever has access to the single workspace you select, and you can revoke it anytime from your [dashboard](https://app.reap.video).
## Add the server
The endpoint is the same everywhere:
```text theme={"system"}
https://mcp.reap.video/mcp
```
The fastest way: just ask your agent to connect it for you. Paste this into any MCP-capable agent:
```text theme={"system"}
Add reap to my user-scoped MCP servers and connect:
"reap": {
"url": "https://mcp.reap.video/mcp"
}
```
The agent writes the config and kicks off the sign-in below. The rest of this page is the manual path if you'd rather wire it up yourself.
Add to `.cursor/mcp.json` in your project root, or `~/.cursor/mcp.json` to make it available everywhere:
```json theme={"system"}
{
"mcpServers": {
"reap": {
"url": "https://mcp.reap.video/mcp"
}
}
}
```
Add to `.vscode/mcp.json` in your project root, or run **MCP: Open User Configuration** for the global file. Note the key is `servers`, and remote servers need `"type": "http"`:
```json theme={"system"}
{
"servers": {
"reap": {
"type": "http",
"url": "https://mcp.reap.video/mcp"
}
}
}
```
Add it as a user-scoped HTTP server, then run `/mcp` to sign in:
```bash theme={"system"}
claude mcp add --transport http --scope user reap "https://mcp.reap.video/mcp"
```
Drop `--scope user` to add it to the current project only.
Add Reap as a plugin, with no local config. Open the [create connector dialog](https://chatgpt.com/plugins#settings/Connectors?create-connector=true\&redirectAfter=%2Fplugins), enter the URL below with **OAuth** auth, then enable the plugin:
```text theme={"system"}
https://mcp.reap.video/mcp
```
Any MCP-compatible agent works. Point its MCP config at the streamable HTTP endpoint:
```text theme={"system"}
https://mcp.reap.video/mcp
```
The OAuth sign-in below is triggered automatically by the agent, so there's nothing extra to configure.
Step-by-step setup guides: [ChatGPT & Codex](/help-center/connect-reap-mcp-to-chatgpt), [Claude & Claude Code](/help-center/connect-reap-mcp-to-claude), [Cursor](/help-center/connect-reap-mcp-to-cursor), [VS Code](/help-center/connect-reap-mcp-to-vs-code), [OpenClaw](/help-center/connect-reap-mcp-to-openclaw).
## Sign in to your workspace
The first time the agent connects (Claude Code prompts this on `/mcp`; Cursor and others trigger it on first tool use), a one-time OAuth sign-in runs:
The agent opens the Reap authorization page automatically. If it doesn't open, your agent shows the URL to copy into a browser manually.
Sign in to your Reap account if you aren't already.
The consent screen shows that the app will be able to **manage your videos & clips** in the workspace you pick. Choose the workspace from the dropdown and click **Authorize**. The agent only ever gets access to the workspace you select.
The browser shows **Authentication successful**. Close the tab and go back to your agent. It reconnects automatically and the Reap tools are now live.
**Done.** Your agent can now create projects, track them, and publish clips in the selected workspace.
## What Can Your Agent Do With MCP?
"Clip the most quotable moments from this YouTube video and keep them under 60 seconds."
"Add captions to this video and translate them into Spanish."
"Reframe this landscape interview to vertical with the speaker centered."
"Publish this clip to my YouTube and TikTok." (The agent confirms with you before posting.)
## Tools
The MCP exposes the full Reap workspace as 29 tools.
**Create projects**
* `request_upload_url` -- get a presigned URL to upload a source video
* `create_clips` -- generate AI clips from a video or URL
* `add_captions` -- add styled, animated captions
* `transcribe` -- transcribe a video to timestamped text
* `reframe` -- change aspect ratio with auto face tracking
* `dub_video` -- voice-dub into another language
**Track & retrieve**
* `list_videos` -- list projects in the workspace
* `get_video` -- full metadata for one project
* `get_status` -- processing status plus a live time estimate
* `get_results` -- generated clips with download URLs
* `get_clip` -- details for a single clip
* `list_uploads` -- videos uploaded to the workspace
* `cancel_video` -- cancel a stuck processing project (credits refunded)
**Edit metadata**
* `update_video` -- rename a project
* `update_clip` -- edit a clip's title or caption
**Publish**
* `list_integrations` -- connected social accounts
* `publish_clip` -- post a clip immediately
* `schedule_clips` -- schedule clips for later
* `list_publisher_posts` -- list scheduled and published posts
* `get_publisher_post` -- details for one post
* `update_publisher_post` -- edit a scheduled post
**Reference catalogs**
* `get_caption_styles` -- built-in caption styles
* `list_templates` -- saved caption-style presets
* `get_languages` -- supported spoken/source languages
* `get_translation_languages` -- supported transcription/translation languages
* `get_dubbing_languages` -- supported dubbing languages
**Billing & usage**
* `get_plan_usage` -- plan, credit balances, and limits
* `top_up_media_credits` -- Stripe checkout link for extra media credits
* `manage_subscription` -- Stripe billing portal link (admin keys only)
`publish_clip`, `schedule_clips`, and `update_publisher_post` post or modify content publicly. These tools require an explicit confirmation, so your agent will ask you before posting on your behalf.
## MCP vs Agent Skill
Both connect Reap to your agent, but they do different jobs:
* **MCP server** -- connects your agent to your workspace live over OAuth so it creates clips, tracks projects, and publishes for you.
* **[Agent Skill](/api-reference/agent-skills)** -- *teaches* your agent the Reap Public API so it can write integration code. Offline, versioned with your repo.
Use both together: the skill to write code against the API, the MCP to let your agent run your workspace directly.
## Learn More
* [Agent Skills](/api-reference/agent-skills) -- Give your agent knowledge of the Reap Public API
* [Quickstart](/api-reference/3_quickstart) -- Get started with the Reap API
* [Authentication](/api-reference/2_authentication) -- Manage API keys for direct REST access
* [Dashboard](https://app.reap.video) -- Manage workspaces, integrations, and API access
# Publish Clip
Source: https://docs.reap.video/api-reference/publish-clip
POST /automation/publish-clip
Immediately publish a completed clip to social media platforms
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Publish a completed clip directly to one or more social media platforms. The clip must have a `completed` status before it can be published. Use [Get Integrations](/api-reference/get-integrations) to retrieve your available integration IDs.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Only completed clips can be published. Get integration IDs from the [Get Integrations](/api-reference/get-integrations) endpoint. The `platformSettings` object lets you configure per-platform settings. Only include platforms you're publishing to.
Clips belonging to a cancelled project can't be published. The API returns `400` — *"This project was cancelled and can no longer be modified or published."*
## Response
Unique post identifier
ID of the parent project
ID of the published clip
Array of target platform names
Platforms where publishing succeeded
Platforms where publishing failed
Array of integration IDs used for publishing
Post title
Post description
Array of tags applied to the post
Current post status
* `processing` - Post is being published
* `completed` - Published successfully to all platforms
* `failed` - Publishing failed on all platforms
* `unresolved` - Partial success (some platforms failed)
Type of scheduling (`immediate` or `scheduled`)
Scheduled publish date as Unix timestamp (null for immediate)
Actual publish date as Unix timestamp
Published URLs per platform (populated after successful publishing)
Per-platform configuration
YouTube-specific settings
Video privacy: `public`, `private`, or `unlisted`
Whether the video can be embedded on other sites
Whether view counts are publicly visible
Whether the video is made for kids (COPPA compliance)
TikTok-specific settings
Video privacy: `public`, `friends`, or `private`
Disable comments on the video
Disable duets for the video
Disable stitches for the video
Mark as paid partnership / brand content
Mark as organic brand content
Instagram-specific settings
Whether to share Reels to the main feed
LinkedIn-specific settings
Post visibility: `public` or `connections`
Unix timestamp when the post was created
Unix timestamp when the post was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/publish-clip" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology", "future"],
"platformSettings": {
"youtube": {
"privacy": "private",
"embeddable": true,
"publicStats": true,
"madeForKids": false
}
}
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/publish-clip', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
projectId: '65f1a2b3c4d5e6f7a8b9c0d2',
clipId: '65f1a2b3c4d5e6f7a8b9c0d4',
integrations: ['66a1b2c3d4e5f6a7b8c9d0e1'],
title: 'The Future of AI',
description: 'Exploring how AI will transform our daily lives',
tags: ['ai', 'technology', 'future'],
platformSettings: {
youtube: {
privacy: 'private',
embeddable: true,
publicStats: true,
madeForKids: false
}
}
})
});
const post = await response.json();
console.log('Post created:', post.id, 'Status:', post.status);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId': '65f1a2b3c4d5e6f7a8b9c0d4',
'integrations': ['66a1b2c3d4e5f6a7b8c9d0e1'],
'title': 'The Future of AI',
'description': 'Exploring how AI will transform our daily lives',
'tags': ['ai', 'technology', 'future'],
'platformSettings': {
'youtube': {
'privacy': 'private',
'embeddable': True,
'publicStats': True,
'madeForKids': False
}
}
}
response = requests.post(
'https://public.reap.video/api/v1/automation/publish-clip',
headers=headers,
json=data
)
post = response.json()
print(f"Post created: {post['id']} Status: {post['status']}")
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d2',
'clipId' => '65f1a2b3c4d5e6f7a8b9c0d4',
'integrations' => ['66a1b2c3d4e5f6a7b8c9d0e1'],
'title' => 'The Future of AI',
'description' => 'Exploring how AI will transform our daily lives',
'tags' => ['ai', 'technology', 'future'],
'platformSettings' => [
'youtube' => [
'privacy' => 'private',
'embeddable' => true,
'publicStats' => true,
'madeForKids' => false
]
]
];
$ch = curl_init('https://public.reap.video/api/v1/automation/publish-clip');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$post = json_decode($response, true);
echo 'Post created: ' . $post['id'] . ' Status: ' . $post['status'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]interface{}{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"integrations": []string{"66a1b2c3d4e5f6a7b8c9d0e1"},
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": []string{"ai", "technology", "future"},
"platformSettings": map[string]interface{}{
"youtube": map[string]interface{}{
"privacy": "private",
"embeddable": true,
"publicStats": true,
"madeForKids": false,
},
},
}
jsonData, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/publish-clip", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class PublishClipExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/publish-clip");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = """
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology", "future"],
"platformSettings": {
"youtube": {
"privacy": "private",
"embeddable": true,
"publicStats": true,
"madeForKids": false
}
}
}""";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube"],
"successPlatforms": [],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology", "future"],
"status": "processing",
"scheduleType": "immediate",
"scheduleDate": null,
"publishDate": null,
"urls": {},
"platformSettings": {
"youtube": {
"privacy": "private",
"embeddable": true,
"publicStats": true,
"madeForKids": false
}
},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
```
```json theme={"system"}
{
"detail": "Clip is not completed. Only completed clips can be published."
}
```
```json theme={"system"}
{
"detail": "Invalid integration ID: 66a1b2c3d4e5f6a7b8c9d0e1"
}
```
```json theme={"system"}
{
"detail": "Title exceeds maximum length of 100 characters"
}
```
```json theme={"system"}
{
"detail": "Clip not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Schedule Clips
Source: https://docs.reap.video/api-reference/schedule-clips
POST /automation/schedule-clips
Schedule completed clips for future publishing to social media
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Schedule one or more completed clips for publishing at a future date. Clips are published sequentially with a configurable interval between each. Use this for batch publishing workflows where you want to space out content over time.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
* Schedule date must be at least 50 minutes in the future and within 12 months
* Interval between clips must be at least 5 minutes (300 seconds)
* Maximum 50 clips per request
* Each clip is scheduled at `scheduleDate + (index * intervalSeconds)`
* Partial success is possible: some clips may fail validation while others are scheduled successfully
* Only completed clips can be scheduled
* Clips from a cancelled project are returned in the `failed` array (not scheduled) with the error `The project for this clip was cancelled.`
## Response
Array of successfully scheduled post objects
Unique post identifier
ID of the parent project
ID of the scheduled clip
Array of target platform names
Platforms where publishing succeeded (empty until published)
Platforms where publishing failed (empty until published)
Array of integration IDs used for publishing
Post title
Post description
Array of tags applied to the post
Post status (will be `scheduled` for newly created scheduled posts)
Always `scheduled` for this endpoint
Scheduled publish date as Unix timestamp
Actual publish date (null until published)
Published URLs per platform (populated after publishing)
Per-platform configuration
YouTube-specific settings
Video privacy: `public`, `private`, or `unlisted`
Whether the video can be embedded on other sites
Whether view counts are publicly visible
Whether the video is made for kids (COPPA compliance)
TikTok-specific settings
Video privacy: `public`, `friends`, or `private`
Disable comments on the video
Disable duets for the video
Disable stitches for the video
Mark as paid partnership / brand content
Mark as organic brand content
Instagram-specific settings
Whether to share Reels to the main feed
LinkedIn-specific settings
Post visibility: `public` or `connections`
Unix timestamp when the post was created
Unix timestamp when the post was last updated
Array of clips that failed validation
ID of the clip that failed
Index of the clip in the input array
Reason the clip failed validation
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/schedule-clips" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"clips": [
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"title": "The Future of AI - Part 1",
"description": "First in our AI series",
"tags": ["ai", "technology"]
},
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d5",
"title": "The Future of AI - Part 2",
"description": "Second in our AI series",
"tags": ["ai", "technology"]
}
],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"scheduleDate": 1710100000,
"intervalSeconds": 600,
"platformSettings": {
"youtube": {
"privacy": "public",
"madeForKids": false
}
}
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/schedule-clips', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
clips: [
{
projectId: '65f1a2b3c4d5e6f7a8b9c0d2',
clipId: '65f1a2b3c4d5e6f7a8b9c0d4',
title: 'The Future of AI - Part 1',
description: 'First in our AI series',
tags: ['ai', 'technology']
},
{
projectId: '65f1a2b3c4d5e6f7a8b9c0d2',
clipId: '65f1a2b3c4d5e6f7a8b9c0d5',
title: 'The Future of AI - Part 2',
description: 'Second in our AI series',
tags: ['ai', 'technology']
}
],
integrations: ['66a1b2c3d4e5f6a7b8c9d0e1'],
scheduleDate: 1710100000,
intervalSeconds: 600,
platformSettings: {
youtube: { privacy: 'public', madeForKids: false }
}
})
});
const data = await response.json();
console.log(`Scheduled: ${data.posts.length}, Failed: ${data.failed.length}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'clips': [
{
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId': '65f1a2b3c4d5e6f7a8b9c0d4',
'title': 'The Future of AI - Part 1',
'description': 'First in our AI series',
'tags': ['ai', 'technology']
},
{
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId': '65f1a2b3c4d5e6f7a8b9c0d5',
'title': 'The Future of AI - Part 2',
'description': 'Second in our AI series',
'tags': ['ai', 'technology']
}
],
'integrations': ['66a1b2c3d4e5f6a7b8c9d0e1'],
'scheduleDate': 1710100000,
'intervalSeconds': 600,
'platformSettings': {
'youtube': {'privacy': 'public', 'madeForKids': False}
}
}
response = requests.post(
'https://public.reap.video/api/v1/automation/schedule-clips',
headers=headers,
json=data
)
result = response.json()
print(f"Scheduled: {len(result['posts'])}, Failed: {len(result['failed'])}")
```
```php PHP theme={"system"}
[
[
'projectId' => '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId' => '65f1a2b3c4d5e6f7a8b9c0d4',
'title' => 'The Future of AI - Part 1',
'description' => 'First in our AI series',
'tags' => ['ai', 'technology']
],
[
'projectId' => '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId' => '65f1a2b3c4d5e6f7a8b9c0d5',
'title' => 'The Future of AI - Part 2',
'description' => 'Second in our AI series',
'tags' => ['ai', 'technology']
]
],
'integrations' => ['66a1b2c3d4e5f6a7b8c9d0e1'],
'scheduleDate' => 1710100000,
'intervalSeconds' => 600,
'platformSettings' => [
'youtube' => ['privacy' => 'public', 'madeForKids' => false]
]
];
$ch = curl_init('https://public.reap.video/api/v1/automation/schedule-clips');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$result = json_decode($response, true);
echo 'Scheduled: ' . count($result['posts']) . ', Failed: ' . count($result['failed']) . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]interface{}{
"clips": []map[string]interface{}{
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"title": "The Future of AI - Part 1",
"description": "First in our AI series",
"tags": []string{"ai", "technology"},
},
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d5",
"title": "The Future of AI - Part 2",
"description": "Second in our AI series",
"tags": []string{"ai", "technology"},
},
},
"integrations": []string{"66a1b2c3d4e5f6a7b8c9d0e1"},
"scheduleDate": 1710100000,
"intervalSeconds": 600,
"platformSettings": map[string]interface{}{
"youtube": map[string]interface{}{
"privacy": "public", "madeForKids": false,
},
},
}
jsonData, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/schedule-clips", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class ScheduleClipsExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/schedule-clips");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = """
{
"clips": [
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"title": "The Future of AI - Part 1",
"description": "First in our AI series",
"tags": ["ai", "technology"]
},
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d5",
"title": "The Future of AI - Part 2",
"description": "Second in our AI series",
"tags": ["ai", "technology"]
}
],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"scheduleDate": 1710100000,
"intervalSeconds": 600,
"platformSettings": {
"youtube": { "privacy": "public", "madeForKids": false }
}
}""";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"posts": [
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube"],
"successPlatforms": [],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI - Part 1",
"description": "First in our AI series",
"tags": ["ai", "technology"],
"status": "scheduled",
"scheduleType": "scheduled",
"scheduleDate": 1710100000,
"publishDate": null,
"urls": {},
"platformSettings": {
"youtube": { "privacy": "public", "madeForKids": false }
},
"createdAt": 1710000000,
"updatedAt": 1710000000
},
{
"id": "67b1c2d3e4f5a6b7c8d9e0f2",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d5",
"platforms": ["youtube"],
"successPlatforms": [],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI - Part 2",
"description": "Second in our AI series",
"tags": ["ai", "technology"],
"status": "scheduled",
"scheduleType": "scheduled",
"scheduleDate": 1710100600,
"publishDate": null,
"urls": {},
"platformSettings": {
"youtube": { "privacy": "public", "madeForKids": false }
},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
],
"failed": []
}
```
```json theme={"system"}
{
"posts": [
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube"],
"successPlatforms": [],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "The Future of AI - Part 1",
"description": "First in our AI series",
"tags": ["ai", "technology"],
"status": "scheduled",
"scheduleType": "scheduled",
"scheduleDate": 1710100000,
"publishDate": null,
"urls": {},
"platformSettings": {},
"createdAt": 1710000000,
"updatedAt": 1710000000
}
],
"failed": [
{
"clipId": "65f1a2b3c4d5e6f7a8b9c0d5",
"index": 1,
"error": "Clip is not completed"
},
{
"clipId": "65f1a2b3c4d5e6f7a8b9c0d6",
"index": 2,
"error": "The project for this clip was cancelled."
}
]
}
```
```json theme={"system"}
{
"detail": "Schedule date must be at least 50 minutes in the future"
}
```
```json theme={"system"}
{
"detail": "Maximum 50 clips per request"
}
```
```json theme={"system"}
{
"detail": "Interval must be at least 300 seconds (5 minutes)"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Top Up Media Credits
Source: https://docs.reap.video/api-reference/top-up-media-credits
GET /automation/top-up-media-credits
Get a Stripe checkout link to buy extra media credits as a one-time purchase
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Get a Stripe Checkout link for a one-time media-credit top-up. This endpoint only returns a URL — nothing is charged until the user opens the link and completes payment in the browser.
Top-ups work like this:
* Credits are sold in **packs of 100 media credits**
* The purchase is one-time — it doesn't change your subscription or renewal date
* Top-up credits **never expire**; monthly plan credits are always spent first
* Media credits only (clipping, captions, reframing, transcription, audiograms, editor processing) — AI credits can't be topped up
Any valid API key on an active paid plan can call this endpoint — including member keys. (In the web app the top-up button is admin-only; the API is deliberately lower-friction.)
## Query Parameters
Number of 100-credit packs to preload in the checkout. Must be ≥ 1. The user can still adjust the quantity on the checkout page (up to 1,000 packs).
Optional promo code to apply at checkout. Invalid or expired codes return a `400`. When omitted, any default top-up discount is applied automatically.
## Response
Stripe Checkout URL. Open it in a browser to review the purchase and pay. Credits are added to the account within a few seconds of payment.
## Example Request
```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/top-up-media-credits?quantity=3" \
-H "Authorization: Bearer YOUR_API_KEY"
```
```javascript JavaScript theme={"system"}
const response = await fetch(
'https://public.reap.video/api/v1/automation/top-up-media-credits?quantity=3',
{ headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
);
const { url } = await response.json();
console.log('Complete the purchase at:', url);
```
```python Python theme={"system"}
import requests
response = requests.get(
'https://public.reap.video/api/v1/automation/top-up-media-credits',
headers={'Authorization': 'Bearer YOUR_API_KEY'},
params={'quantity': 3}
)
print('Complete the purchase at:', response.json()['url'])
```
## Example Response
```json theme={"system"}
{
"url": "https://checkout.stripe.com/c/pay/cs_live_a1B2c3..."
}
```
```json theme={"system"}
{
"detail": "Invalid or expired promo code."
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
## Rate Limiting
This endpoint is subject to the standard rate limit of **10 requests per minute**.
## Next Steps
* **Check your balance first** with [Get Plan Usage](/api-reference/get-plan-usage)
* **How top-ups behave** (expiry, freezing, spend order): see the [help-center guide](/help-center/top-up-media-credits)
# Update Clip
Source: https://docs.reap.video/api-reference/update-clip
POST /automation/update-clip
Update a clip's title and caption
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Update the title and/or caption of an existing clip. Clips that are still processing cannot be updated.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Cannot update clips that are still processing. Title is limited to 80 characters and caption to 400 characters.
Clips belonging to a cancelled project can't be edited. The API returns `400` — *"This project was cancelled and can no longer be modified or published."*
## Response
Unique identifier for the clip
ID of the parent project
Direct download URL for the final clip (includes captions if enabled)
Start time of the clip in the original video (seconds)
End time of the clip in the original video (seconds)
Duration of the clip in seconds
Primary topic or theme of the clip
Updated title for the clip
Updated caption/description for the clip
Language of the clip content
Whether transcription is translated
Array of languages for translation
Target dubbing language (for dubbing projects)
Script format for transcription ("native" or "roman")
AI-predicted virality score (0-10, higher is better)
Resolution of the exported clip
Orientation of the exported clip ("landscape", "portrait", "square")
Caption style preset used for this clip
Whether captions are enabled for this clip
Whether emojis are added to captions
Whether keyword highlighting is enabled
Clip metadata including technical details
Unix timestamp when the clip was created
Unix timestamp when the clip was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/update-clip" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"title": "Updated Clip Title",
"caption": "A new caption for this clip"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/update-clip', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
projectId: '65f1a2b3c4d5e6f7a8b9c0d2',
clipId: '65f1a2b3c4d5e6f7a8b9c0d4',
title: 'Updated Clip Title',
caption: 'A new caption for this clip'
})
});
const clip = await response.json();
console.log(`Updated: ${clip.title}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2',
'clipId': '65f1a2b3c4d5e6f7a8b9c0d4',
'title': 'Updated Clip Title',
'caption': 'A new caption for this clip'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/update-clip',
headers=headers,
json=data
)
clip = response.json()
print(f"Updated: {clip['title']}")
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d2',
'clipId' => '65f1a2b3c4d5e6f7a8b9c0d4',
'title' => 'Updated Clip Title',
'caption' => 'A new caption for this clip'
];
$ch = curl_init('https://public.reap.video/api/v1/automation/update-clip');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$clip = json_decode($response, true);
echo 'Updated: ' . $clip['title'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"title": "Updated Clip Title",
"caption": "A new caption for this clip",
}
body, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/update-clip", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class UpdateClipExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/update-clip");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = "{\"projectId\":\"65f1a2b3c4d5e6f7a8b9c0d2\",\"clipId\":\"65f1a2b3c4d5e6f7a8b9c0d4\",\"title\":\"Updated Clip Title\",\"caption\":\"A new caption for this clip\"}";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d4",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipUrl": "https://cdn.reap.video/clips/65f1a2b3c4d5e6f7a8b9c0d4.mp4",
"startTime": 45.2,
"endTime": 75.8,
"duration": 30.6,
"topic": "AI Technology",
"title": "Updated Clip Title",
"caption": "A new caption for this clip",
"language": "en",
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"viralityScore": 8.7,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"metadata": {
"duration": 30.6,
"width": 1080,
"height": 1920,
"fps": 30,
"bitrate": 4000000,
"size": 25000000,
"codec": "h264"
},
"createdAt": 1710001800,
"updatedAt": 1710005000
}
```
```json theme={"system"}
{
"detail": "Cannot update a clip that is still processing"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Clip not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Update Post
Source: https://docs.reap.video/api-reference/update-post
POST /automation/update-post
Update a scheduled or draft post
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Update the details of a scheduled or draft post. You can modify the title, description, tags, schedule date, and platform settings. Only the fields you provide will be updated; other fields remain unchanged.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Cannot update posts that are already completed or currently processing. Schedule date must be at least 50 minutes in the future. Only fields you provide will be updated; other fields remain unchanged.
Posts tied to a cancelled project can't be updated. The API returns `400` — *"This project was cancelled, so its posts can no longer be updated."*
## Response
Unique post identifier
ID of the parent project
ID of the published clip
Array of target platform names
Platforms where publishing succeeded
Platforms where publishing failed
Array of integration IDs used for publishing
Post title
Post description
Array of tags applied to the post
Current post status
Type of scheduling (`immediate` or `scheduled`)
Scheduled publish date as Unix timestamp
Actual publish date as Unix timestamp (null if not yet published)
Published URLs per platform
Per-platform configuration
YouTube-specific settings
Video privacy: `public`, `private`, or `unlisted`
Whether the video can be embedded on other sites
Whether view counts are publicly visible
Whether the video is made for kids (COPPA compliance)
TikTok-specific settings
Video privacy: `public`, `friends`, or `private`
Disable comments on the video
Disable duets for the video
Disable stitches for the video
Mark as paid partnership / brand content
Mark as organic brand content
Instagram-specific settings
Whether to share Reels to the main feed
LinkedIn-specific settings
Post visibility: `public` or `connections`
Unix timestamp when the post was created
Unix timestamp when the post was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/update-post" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"postId": "67b1c2d3e4f5a6b7c8d9e0f1",
"title": "Updated: The Future of AI",
"scheduleDate": 1710200000,
"platformSettings": {
"youtube": {
"privacy": "unlisted"
}
}
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/update-post', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
postId: '67b1c2d3e4f5a6b7c8d9e0f1',
title: 'Updated: The Future of AI',
scheduleDate: 1710200000,
platformSettings: {
youtube: { privacy: 'unlisted' }
}
})
});
const post = await response.json();
console.log('Updated post:', post.id, 'New schedule:', post.scheduleDate);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'postId': '67b1c2d3e4f5a6b7c8d9e0f1',
'title': 'Updated: The Future of AI',
'scheduleDate': 1710200000,
'platformSettings': {
'youtube': {'privacy': 'unlisted'}
}
}
response = requests.post(
'https://public.reap.video/api/v1/automation/update-post',
headers=headers,
json=data
)
post = response.json()
print(f"Updated post: {post['id']} New schedule: {post['scheduleDate']}")
```
```php PHP theme={"system"}
'67b1c2d3e4f5a6b7c8d9e0f1',
'title' => 'Updated: The Future of AI',
'scheduleDate' => 1710200000,
'platformSettings' => [
'youtube' => ['privacy' => 'unlisted']
]
];
$ch = curl_init('https://public.reap.video/api/v1/automation/update-post');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$post = json_decode($response, true);
echo 'Updated post: ' . $post['id'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]interface{}{
"postId": "67b1c2d3e4f5a6b7c8d9e0f1",
"title": "Updated: The Future of AI",
"scheduleDate": 1710200000,
"platformSettings": map[string]interface{}{
"youtube": map[string]interface{}{"privacy": "unlisted"},
},
}
jsonData, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/update-post", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class UpdatePostExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/update-post");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = """
{
"postId": "67b1c2d3e4f5a6b7c8d9e0f1",
"title": "Updated: The Future of AI",
"scheduleDate": 1710200000,
"platformSettings": {
"youtube": { "privacy": "unlisted" }
}
}""";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "67b1c2d3e4f5a6b7c8d9e0f1",
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"clipId": "65f1a2b3c4d5e6f7a8b9c0d4",
"platforms": ["youtube"],
"successPlatforms": [],
"failedPlatforms": [],
"integrations": ["66a1b2c3d4e5f6a7b8c9d0e1"],
"title": "Updated: The Future of AI",
"description": "Exploring how AI will transform our daily lives",
"tags": ["ai", "technology"],
"status": "scheduled",
"scheduleType": "scheduled",
"scheduleDate": 1710200000,
"publishDate": null,
"urls": {},
"platformSettings": {
"youtube": {
"privacy": "unlisted",
"embeddable": true,
"publicStats": true,
"madeForKids": false
}
},
"createdAt": 1710000000,
"updatedAt": 1710050000
}
```
```json theme={"system"}
{
"detail": "Cannot update a completed post"
}
```
```json theme={"system"}
{
"detail": "Cannot update a post that is currently processing"
}
```
```json theme={"system"}
{
"detail": "Schedule date must be at least 50 minutes in the future"
}
```
```json theme={"system"}
{
"detail": "Post not found"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Update Project
Source: https://docs.reap.video/api-reference/update-project
POST /automation/update-project
Update a project's title
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Update the title of an existing project. Projects that are still processing cannot be updated.
## Rate Limiting
This endpoint is rate limited to 10 requests per minute per API key.
Cannot update projects that are still processing. Wait for the project to reach `completed` or `failed` status before updating.
A cancelled project can't be renamed. The API returns `400` — *"This project was cancelled and can no longer be modified or published."*
## Response
Unique project identifier
Updated project title
Thumbnail URL for the project
Duration in seconds that was billed for this project
Current processing status
Type of project
Source of the video content
Video genre used for AI analysis
Array of identified topics in the video
Array of clip duration preferences
Start time in seconds for processing (null if entire video)
End time in seconds for processing (null if entire video)
Output resolution for the project
Output orientation
Caption style preset ID (null if captions disabled)
Whether captions are enabled
Whether emojis are added to captions
Whether keyword highlighting is enabled
Primary language of the video content
Target dubbing language (null if not applicable)
Whether transcription is translated
Array of languages for translation
Script format for transcription ("native" or "roman")
Video file metadata including duration, resolution, format, etc.
Project URLs and assets
Unix timestamp when the project was created
Unix timestamp when the project was last updated
## Example Request
```bash cURL theme={"system"}
curl -X POST "https://public.reap.video/api/v1/automation/update-project" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Updated Title"
}'
```
```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/update-project', {
method: 'POST',
headers: {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
projectId: '65f1a2b3c4d5e6f7a8b9c0d2',
title: 'My Updated Title'
})
});
const project = await response.json();
console.log(`Updated: ${project.title}`);
```
```python Python theme={"system"}
import requests
headers = {
'Authorization': 'Bearer YOUR_API_KEY',
'Content-Type': 'application/json'
}
data = {
'projectId': '65f1a2b3c4d5e6f7a8b9c0d2',
'title': 'My Updated Title'
}
response = requests.post(
'https://public.reap.video/api/v1/automation/update-project',
headers=headers,
json=data
)
project = response.json()
print(f"Updated: {project['title']}")
```
```php PHP theme={"system"}
'65f1a2b3c4d5e6f7a8b9c0d2',
'title' => 'My Updated Title'
];
$ch = curl_init('https://public.reap.video/api/v1/automation/update-project');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer YOUR_API_KEY',
'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$project = json_decode($response, true);
echo 'Updated: ' . $project['title'] . "\n";
?>
```
```go Go theme={"system"}
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
func main() {
data := map[string]string{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Updated Title",
}
body, _ := json.Marshal(data)
req, _ := http.NewRequest("POST", "https://public.reap.video/api/v1/automation/update-project", bytes.NewBuffer(body))
req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
respBody, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(respBody))
}
```
```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class UpdateProjectExample {
public static void main(String[] args) throws Exception {
URL url = new URL("https://public.reap.video/api/v1/automation/update-project");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
conn.setRequestProperty("Content-Type", "application/json");
conn.setDoOutput(true);
String jsonBody = "{\"projectId\":\"65f1a2b3c4d5e6f7a8b9c0d2\",\"title\":\"My Updated Title\"}";
try (OutputStream os = conn.getOutputStream()) {
os.write(jsonBody.getBytes("utf-8"));
}
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println(response.toString());
}
}
```
## Example Response
```json theme={"system"}
{
"id": "65f1a2b3c4d5e6f7a8b9c0d2",
"title": "My Updated Title",
"thumbnail": "https://cdn.reap.video/thumbnails/65f1a2b3c4d5e6f7a8b9c0d2.jpg",
"billedDuration": 1800.5,
"status": "completed",
"projectType": "clipping",
"source": "Upload",
"genre": "talking",
"topics": ["AI", "Technology"],
"clipDurations": [],
"selectedStart": 0,
"selectedEnd": null,
"exportResolution": 1080,
"exportOrientation": "portrait",
"captionsPreset": "system_beasty",
"enableCaptions": true,
"enableEmojis": true,
"enableHighlights": true,
"language": "en",
"dubbingLanguage": null,
"translateTranscription": false,
"translationLanguages": [],
"transcriptionScript": "native",
"metadata": {
"duration": 1800.5,
"width": 1920,
"height": 1080,
"fps": 30,
"bitrate": 5000000,
"size": 450000000,
"codec": "h264"
},
"urls": {
"projectUrl": "https://app.reap.video/project/65f1a2b3c4d5e6f7a8b9c0d2",
"downloadUrl": "https://cdn.reap.video/downloads/65f1a2b3c4d5e6f7a8b9c0d2.zip"
},
"createdAt": 1710000000,
"updatedAt": 1710005000
}
```
```json theme={"system"}
{
"detail": "Cannot update a project that is still processing"
}
```
```json theme={"system"}
{
"detail": "Unauthorized - Invalid or missing API key"
}
```
```json theme={"system"}
{
"detail": "Project not found"
}
```
```json theme={"system"}
{
"detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
}
```
# Webhooks
Source: https://docs.reap.video/api-reference/webhooks
Receive real-time notifications when your video projects finish processing
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Webhooks let Reap push status updates to your server the moment a video project reaches a final state -- no more polling. When a project completes, fails, or expires, Reap sends a POST request to your configured endpoint with the project's status.
## How It Works
Use the API to create a clipping, captions, transcription, reframe, or dubbing project as usual.
Reap processes your video in the background.
The project finishes with a status of `completed` or `invalid`.
A POST request with the project status is sent to every active webhook URL configured in your studio.
Your endpoint receives the payload, returns HTTP 200 with an empty body, and handles the event.
## Webhook Payload
Every webhook delivery sends a JSON POST request with this structure:
```json theme={"system"}
{
"projectId": "65f1a2b3c4d5e6f7a8b9c0d1",
"projectType": "clipping",
"source": "Upload",
"status": "completed"
}
```
Unique identifier of the project.
Type of project: `clipping`, `captions`, `reframe`, `dubbing`, or `transcription`.
Source of the original video: `Youtube`, `Upload`, or `Generic`.
The final status that triggered the webhook.
### Statuses That Trigger Webhooks
| Status | Description |
| ----------- | ------------------------------------------------------------------ |
| `completed` | Project finished processing successfully. Clips/results are ready. |
| `invalid` | The source video was invalid or processing failed. |
| `expired` | Project results expired and are no longer available. |
Webhooks are only sent when a project reaches a **final state**. You will not receive webhooks for intermediate states like `processing`.
## Setting Up a Webhook
Webhooks are configured from the Reap dashboard, not via the API.
The documentation is public. Dashboard links require a Reap account and are only needed for account setup, API key management, integrations, or webhook configuration.
Log in to your [Reap dashboard](https://app.reap.video) and navigate to **Profile** > **Settings** > **Webhooks**.
Click **Create Webhook**. Provide a descriptive name and your HTTPS endpoint URL.
Reap sends a test POST request to your URL with the following dummy payload. Your endpoint must return HTTP **200** with an **empty response body** within **5 seconds**.
```json theme={"system"}
{
"projectId": "000000000000000000000000",
"projectType": "clipping",
"source": "Upload",
"status": "completed"
}
```
Once the test passes, the webhook is saved and active. All future project status changes in your studio will be delivered to this endpoint.
Your endpoint must be live and responding correctly **before** you create the webhook. Reap will reject the webhook if the test request fails.
## Endpoint Requirements
Your webhook endpoint must meet these requirements:
The URL must use HTTPS. HTTP, localhost, and private IP addresses are not allowed.
Your endpoint must accept POST requests with a `Content-Type: application/json` body.
Respond with HTTP status **200** and an **empty response body**. Any other status code is treated as a failure.
Respond within **5 seconds** during webhook creation/validation, and within **10 seconds** for live deliveries. Exceeding the timeout counts as a failure.
### URL Restrictions
Your webhook URL must pass these validation checks:
* Must use the `https://` scheme
* Cannot point to `localhost`, `127.0.0.1`, or `0.0.0.0`
* Cannot point to private or reserved IP address ranges
## Example Webhook Receiver
```javascript Node.js (Express) theme={"system"}
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhook/reap', (req, res) => {
const { projectId, projectType, source, status } = req.body;
// Return 200 immediately with empty body
res.status(200).send('');
// Process the event asynchronously
handleProjectUpdate(projectId, projectType, source, status);
});
async function handleProjectUpdate(projectId, projectType, source, status) {
if (status === 'completed') {
// Fetch clips or project details from the API
console.log(`Project ${projectId} completed. Fetching results...`);
} else if (status === 'invalid') {
console.log(`Project ${projectId} failed with status: ${status}`);
} else if (status === 'expired') {
console.log(`Project ${projectId} expired.`);
}
}
app.listen(3000, () => console.log('Webhook receiver running on port 3000'));
```
```python Python (Flask) theme={"system"}
from flask import Flask, request
app = Flask(__name__)
@app.route('/webhook/reap', methods=['POST'])
def handle_webhook():
data = request.json
project_id = data['projectId']
status = data['status']
# Process asynchronously in production (e.g. Celery task)
if status == 'completed':
print(f'Project {project_id} completed. Fetching results...')
elif status == 'invalid':
print(f'Project {project_id} failed with status: {status}')
elif status == 'expired':
print(f'Project {project_id} expired.')
# Return 200 with empty body
return '', 200
if __name__ == '__main__':
app.run(port=3000)
```
```go Go theme={"system"}
package main
import (
"encoding/json"
"fmt"
"net/http"
)
type WebhookPayload struct {
ProjectID string `json:"projectId"`
ProjectType string `json:"projectType"`
Source string `json:"source"`
Status string `json:"status"`
}
func webhookHandler(w http.ResponseWriter, r *http.Request) {
var payload WebhookPayload
json.NewDecoder(r.Body).Decode(&payload)
// Return 200 with empty body immediately
w.WriteHeader(http.StatusOK)
// Process the event
go func() {
if payload.Status == "completed" {
fmt.Printf("Project %s completed. Fetching results...\n", payload.ProjectID)
}
}()
}
func main() {
http.HandleFunc("/webhook/reap", webhookHandler)
fmt.Println("Webhook receiver running on port 3000")
http.ListenAndServe(":3000", nil)
}
```
## Managing Webhooks
All webhook management is done from the [Reap dashboard](https://app.reap.video) under **Profile** > **Settings** > **Webhooks**.
You can:
* **Update** the name or URL of an existing webhook. Changing the URL triggers a new test request.
* **Disable/Enable** a webhook. Re-enabling a disabled webhook triggers a test request to verify your endpoint is working.
* **Delete** a webhook to stop receiving notifications permanently.
* **View delivery history** for each webhook, including response codes and delivery times.
All active webhooks in a studio receive notifications for **every** project in that studio. You cannot scope a webhook to specific project types.
## Auto-Disable on Failures
Reap tracks consecutive delivery failures for each webhook:
* Each failed delivery (non-200 response, timeout, or unreachable endpoint) increments the failure counter.
* After **5 consecutive failures**, the webhook is **automatically disabled** and you are notified via email.
* Any **successful delivery** resets the failure counter back to 0.
To re-enable a disabled webhook:
1. Fix the issue with your endpoint
2. Go to **Profile** > **Settings** > **Webhooks** in the dashboard
3. Toggle the webhook back on (this triggers a test request)
There are no automatic retries. If a delivery fails, Reap logs the failure and moves on. Design your system to handle missed events by periodically checking [Get Project Status](/api-reference/get-project-status) for critical projects.
## Plan Limits
| Plan | Max Active Webhooks |
| ------- | --------------------- |
| Free | 0 (no webhook access) |
| Creator | 1 |
| Studio | 5 |
Need more webhooks? [Contact us](mailto:hello@reap.video) to discuss enterprise options.
## Best Practices
Return 200 immediately and process the event asynchronously. Don't do heavy work before responding.
Design your handler to be idempotent. In rare cases, you may receive the same event more than once.
Check webhook delivery history in your dashboard regularly to catch issues before the auto-disable threshold.
Use [Get Project Status](/api-reference/get-project-status) as a fallback for critical workflows in case a webhook delivery is missed.
## Next Steps
* [Get Project Status](/api-reference/get-project-status) -- fallback polling endpoint
* [Get Project Details](/api-reference/get-project-details) -- fetch full project data after a `completed` webhook
* [Get Project Clips](/api-reference/get-project-clips) -- retrieve generated clips after completion
# Add Captions & Translate With MCP
Source: https://docs.reap.video/help-center/add-captions-with-reap-mcp
Add animated captions in 100+ languages and translate them into another language by asking your AI agent — styles, emojis, and highlights included.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can add animated captions to a video and translate them into another language. Captions support 100+ languages, including romanized scripts.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Reap MCP requires a paid plan with API access enabled.
## Add Captions
You can caption a public URL or a video you upload:
```text theme={"system"}
Add captions to this video:
https://www.youtube.com/watch?v=XXXXXXXXXXX
```
```text theme={"system"}
Upload ~/Videos/talk.mp4 and add captions to it.
```
## Translate Captions
Name the target language — your agent looks up the exact code Reap needs:
```text theme={"system"}
Add captions to this video and translate them into Spanish.
```
## Choose A Caption Style
Pick from Reap's built-in styles (Karaoke, Bold, Minimal, and 50+ more):
```text theme={"system"}
Show me the available caption styles, then add captions in the "system_zen" style.
```
To apply your own branded caption style instead, see [Use Brand Templates With Reap MCP](/help-center/use-brand-templates-with-reap-mcp).
## Options You Can Ask For
* **Caption style** — a built-in style or your brand template.
* **Translation** — into any supported language.
* **Emojis** — sprinkle relevant emojis into the captions.
* **Highlights** — highlight keywords.
* **Script** — native script or romanized (Latin) transliteration.
* **Resolution** — 720p, 1080p (default), 1440p, or 2160p (applies when captioning from a URL).
* **Language** — name the spoken language, or leave it out to auto-detect.
## How Your Agent Handles It
Your agent shows the planned caption style, language, and translation, then asks you to confirm.
Approve or tweak the settings before it submits.
Captioning runs asynchronously — ask for status anytime, and you'll get an email when it completes.
## Related
* [Use Brand Templates With Reap MCP](/help-center/use-brand-templates-with-reap-mcp)
* [Transcribe Videos With Reap MCP](/help-center/transcribe-videos-with-reap-mcp)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Asset Library
Source: https://docs.reap.video/help-center/asset-library
Upload, organize, and reuse images, videos, audio, and fonts across projects.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The Asset Library is where you store reusable media for your projects. Use it to keep brand assets, b-rolls, and audio organized so they are ready whenever you edit clips.
## What You Can Store
* `Images`
* `Videos`
* `Audio`
* `Fonts`
## Supported Formats
* `Images`: `.png`, `.jpg`, `.jpeg`, `.webp`
* `Videos`: `.mp4`, `.mov`, `.webm`
* `Audio`: `.mp3`, `.wav`, `.aac`
## Size Limits
Each media type supports up to `250 MB` per file.
## Custom Font Limits
* `Creator` plan supports up to `3` custom fonts.
* `Studio` plan supports up to `6` custom fonts.
## Step-By-Step Workflow
Go to **Asset Library** from your dashboard or editor.
Use the tabs at the top to switch between **Images**, **Videos**, **Audio**, and **Fonts**.
Click **New media** and upload the files you want to use in your projects.
Select your saved assets when adding b-rolls, overlays, backgrounds, audio, or fonts in the editor.
## Tips
* Keep core brand files (logos, intros, outros, and music) in the library so every project stays consistent.
* Use the library to speed up editing and avoid re-uploading the same assets.
# Auto-Reframing in Editor
Source: https://docs.reap.video/help-center/auto-reframing-in-editor
Understand how auto-reframing behaves in the editor, especially when you add new segments or make manual framing changes.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Auto-reframing does not happen live in the editor for newly added segments. Reap updates the framing after you save your changes or export the clip.
## What To Know
* New segments added in the editor are reframed after save or export, not instantly in the browser.
* Manual framing changes always take priority. If you move, crop, or resize the framing yourself, Reap will keep your edits.
* Real-time auto-reframing in the editor is not available yet.
# Using Brand Templates
Source: https://docs.reap.video/help-center/brand-templates
Save reusable presets, video preferences, and branded styling so your content stays consistent across projects.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Brand Templates help you save reusable styling choices so you do not have to rebuild the same look for every new project. You can use them to keep captions, branded visuals, and other preset-based settings consistent across your workflow.
## What You Can Do
* Save reusable branded presets.
* Reuse the same look across clipping, captions, and other supported workflows.
* Manage preset styling from one place instead of rebuilding it each time.
* Keep your fonts, colors, animation, and caption positioning consistent.
## What Can Be Saved In A Brand Template
* `Brand` for brand templates
* `Caption` for caption presets
* `Audiogram` for waveform and audio post visuals
* `Text` for text overlays
* `Intro` for opening assets or sequences
* `Outro` for ending assets or sequences
* `Logo` for logo placement and branding marks
* `Background` for background visuals and colors
* `Settings` for language, translation, script, orientation, and resolution preferences
* `Fonts` for custom fonts
## Guides
Save, manage, and reuse your caption presets as brand templates.
## When To Use Brand Templates
* Use them when you want the same visual identity across multiple videos.
* Create templates before generating large batches of clips or captions.
* Update saved templates when your branding changes, instead of restyling each project manually.
* Manage templates later from **Brand Templates** or from supported editors when you need to adjust them.
* Delete old templates to keep your preset list clean and easy to use.
Brand Templates work best when you want speed and consistency. Set them up once, then reuse them across future projects.
## Common Questions
* If a template does not show up after you save, refresh the list or reopen the editor.
* If a background or branding does not apply on an existing clip, reprocess the clip so the template updates are applied.
* Brand Templates created in the UI can also be used when generating clips via the API.
* Templates apply per project. Use one template per project and tweak sections in the editor if needed.
* If a font is missing special characters for your language, switch to a font that supports those characters.
# Can I change the caption fonts and color?
Source: https://docs.reap.video/help-center/can-i-change-the-caption-fonts-and-color
Change caption font and color settings in the editor to match the style of your clip.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can update caption font and color settings from the captions editor when you want the subtitles to better match your brand or content style.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
Select the **Captions** option in the editor and click **Edit**.
Go to the font and color settings and choose the style you want.
Review the updated captions to make sure they match your intended look.
Once satisfied, click **Export**. Your updated clip will be ready after export is completed.
# Can I remove the silences in the clip?
Source: https://docs.reap.video/help-center/can-i-remove-the-silences-in-the-clip
Use silence removal from the transcript area in the editor to cut dead air automatically.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can remove silent sections from a clip in the editor to make the pacing feel tighter and cleaner.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
In the transcript area, click the **remove gap** button.
Let Reap automatically detect and remove silent sections from your clip.
Review the clip to make sure the silent sections have been removed the way you want.
Once satisfied, click **Export**. Your updated clip will be ready after export is completed.
# Cancel subscription
Source: https://docs.reap.video/help-center/cancel-subscription
Cancel your Reap subscription from the billing page.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can cancel your subscription from **Manage billing** or **Settings**.
## Step-By-Step Workflow
From your home page, click **Manage billing**, or open **Settings**.
Click **Cancel Plan** to confirm the cancellation.
# How to create a Brand template
Source: https://docs.reap.video/help-center/caption-presets-are-now-brand-templates
Save reusable brand templates with caption styling, assets, layout settings, and branded visuals for future projects.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Brand Templates let you save a reusable visual system for your videos, so you do not have to rebuild the same branding every time. Instead of saving only caption styling, you can now save a fuller set of branded elements and settings, then apply them to future projects in one click.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
With Brand Templates, you can save settings for:
* `Brand`: brand templates
* `Caption`: caption presets
* `Audiogram`: waveform and audio post visuals
* `Text`: text overlays
* `Intro`: opening asset or sequence
* `Outro`: ending asset or sequence
* `Logo`: logo placement and branding mark
* `Background`: background visuals/colors
* `Settings`: preferences like language, translation, script, orientation, and resolution
* `Fonts`: custom fonts
## Step-By-Step Workflow
Go to **Brand Templates** from the left side of your dashboard.
Start a new brand template and open the sections you want to customize.
Add and configure your branding across sections like **Caption**, **Audiogram**, **Text**, **Intro**, **Outro**, **Logo**, **Background**, **Settings**, and **Fonts**.
Save your changes once the template is ready to reuse.
Select the saved brand template during supported workflows so your content keeps a consistent look.
## Managing Your Templates
* Edit saved templates from **Brand Templates** whenever your branding changes.
* Update individual sections without rebuilding the whole template from scratch.
* Open and manage saved templates from supported editors like **Clipping** and **Captions** when you need to make quick updates.
* Delete old templates when you no longer want them available in the picker.
* Give templates clear names so they are easier to recognize and reuse later.
## Preset Limits
* `Creator plan` supports up to `3` presets.
* `Studio plan` supports up to `6` presets.
## Common Questions
* If a template does not appear after you save, refresh the list or reopen the editor and try again.
* If the background shows as black after applying a template, reprocess the clip so the updated background is applied.
* Brand Templates created in the UI can also be applied when you generate clips through the API.
* Templates apply per project. Use one template per project and make any section-level tweaks inside the editor.
* If your language needs special characters, test a font in the template preview text and switch fonts if characters are missing.
## What To Know
* Brand Templates are useful when you want the same branded look across multiple videos and workflows.
* Updating a template is faster than manually rebuilding captions, logos, backgrounds, or intro/outro assets every time.
* Clear template names make it easier to choose the right option during clip creation and editing.
* Templates are especially useful when you want to reuse the same presets, video preferences, and custom fonts across multiple projects.
# Change payment method
Source: https://docs.reap.video/help-center/change-payment-method
Add or update the payment method on your account.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can update your payment method from **Manage billing** or **Settings**.
## Step-By-Step Workflow
From your home page, click **Manage billing**, or open **Settings**.
Click **Add Payment Method** to add a new one, and remove the old method if needed.
# Clips and Credits
Source: https://docs.reap.video/help-center/clips-and-credits
Understand clip output, credit usage, AI clipping limits, and ways to save credits in Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
This section covers how clip generation works, how Reap credits are consumed, and what to check when AI clipping is unavailable. It also includes guidance on getting more value from your credits by processing only the parts of a video you actually need.
## What This Section Covers
* How many clips you can expect from a video.
* Why AI clipping may be unavailable for a project.
* How Reap's credit system works across different features.
* How to save credits with the time-frame slider.
## Guides
See the typical clip ranges you can expect based on video length.
Learn the common reasons AI clipping may fail.
Understand media credits, AI credits, and how feature usage is calculated.
Process only the useful part of a video to reduce credit usage.
Describe the clips you want in plain language — count, duration, focus, tone. Private beta — [request access](mailto:hello@reap.video?subject=Clip%20Prompt%20Private%20Beta).
# Connect Reap MCP Server
Source: https://docs.reap.video/help-center/connect-reap-mcp-server
Connect Reap to MCP-compatible AI tools so your agent can create clips, captions, reframes, dubbing projects, and published posts from your workspace.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## What Is Reap MCP?
Reap MCP lets AI tools connect to your Reap workspace through the Model Context Protocol (MCP). After you connect it, you can ask an AI agent to create clips, add captions, reframe videos, dub videos, check project status, retrieve clip links, and publish or schedule content from Reap.
You do not need to copy an API key into your AI tool. Reap MCP uses OAuth, so you sign in to Reap and choose the workspace the agent is allowed to use.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* Your AI tool must support remote MCP servers.
* You need access to the Reap workspace you want to connect.
## Reap MCP Server URL
The endpoint is the same in every tool:
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Pick Your Tool
Each guide has the exact setup steps for that tool:
Custom MCP app in ChatGPT, or a plugin in Codex.
Custom connector in Claude chat, or one command in Claude Code.
Add Reap to `.cursor/mcp.json` or your global config.
Add Reap to `.vscode/mcp.json` and use it in agent mode.
Add Reap with `openclaw mcp add` and authorize.
Point any MCP-compatible tool at the endpoint above.
In any agent that can edit its own config, paste this into the chat:
```text theme={"system"}
Add reap to my user-scoped MCP servers and connect:
"reap": {
"url": "https://mcp.reap.video/mcp"
}
```
The agent writes the config and starts the sign-in flow below.
## Authorize Your Reap Workspace
No matter which agent you connect, the authorization flow works the same way:
Log in to the Reap account that has access to the workspace you want to connect.
Select the Reap workspace your agent is allowed to use.
Click **Authorize**. The agent only gets access to the workspace you selected.
Close the browser tab after authentication succeeds, then return to your agent and continue your workflow.
## Confirm The Connection Works
After connecting, try asking your agent:
```text theme={"system"}
What Reap tools do you have access to?
```
You can also try:
```text theme={"system"}
Show me my recent Reap projects.
```
If the agent can list Reap tools or access your selected workspace, the connection is working.
## What You Can Ask Your Agent To Do
Once connected, your agent can help with workflows like:
* Generate AI clips from a video upload or supported source URL.
* Add captions to a video.
* Reframe a video into portrait or square format.
* Dub a video into another language.
* Transcribe a video.
* Check project status and retrieve generated clip links.
* Publish or schedule clips to connected social platforms.
Publishing or scheduling content can affect public social accounts. Your agent should ask for confirmation before posting, scheduling, or changing published content.
## Things To Note
* Reap MCP uses OAuth, so you do not need to paste a Reap API key into your AI tool.
* Your agent only has access to the Reap workspace you authorize.
* You can revoke access later from your Reap dashboard.
* If your AI tool does not show Reap tools after connecting, restart the tool or reconnect the MCP server.
* If publishing tools fail, make sure your social accounts are connected in Reap.
## Troubleshooting
* Make sure your Reap plan includes API access.
* Confirm you authorized the correct workspace during OAuth.
* If the browser does not open automatically, copy the authorization URL from your agent and open it manually.
* If tools do not appear, reconnect the MCP server or restart your AI tool.
* If publishing fails, check that your social accounts are connected in Reap.
For tool-specific fixes, see the troubleshooting section on your tool's page above.
## Learn More
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Agent Skills](/api-reference/agent-skills)
* [Connect Social Media Accounts](/help-center/how-to-connect-social-media-accounts)
* [Reap Dashboard](https://app.reap.video)
# Connect Reap MCP To ChatGPT And Codex
Source: https://docs.reap.video/help-center/connect-reap-mcp-to-chatgpt
Add Reap to ChatGPT as a custom MCP app, or to Codex as a plugin, so you can create clips, captions, reframes, and dubs from OpenAI tools.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Both OpenAI tools connect to the same Reap MCP endpoint over OAuth. You sign in to Reap and pick the workspace the tool is allowed to use. The setup differs:
* **ChatGPT**: add Reap as a custom MCP app in connector settings.
* **Codex**: add Reap as a plugin from the Codex plugins page.
You never paste a Reap API key into either tool.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* You need access to the Reap workspace you want to connect.
* Custom connector and plugin availability depends on your OpenAI plan and workspace settings. Some options are only available to workspace admins or on supported paid plans.
## Reap MCP Server URL
The endpoint is the same in both tools:
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Connect ChatGPT
Use this when you want Reap available in ChatGPT conversations.
Use this link to land straight on the setting: [Enable Developer Mode in ChatGPT](https://chatgpt.com/#settings/Security?section=developer-mode). Turn on **Developer Mode** so you can add a custom MCP app.
ChatGPT marks this as elevated risk, because it lets you add unverified connectors. Only turn it on if you are adding a connector you trust.
Go to [ChatGPT connector settings](https://chatgpt.com/#settings/Connectors), then click **Create app** or **Add custom app**, depending on the option shown in your workspace.
Fill in the **New App** form:
- Name:
Reap
- Connection: keep Server URL selected, then enter
[https://mcp.reap.video/mcp](https://mcp.reap.video/mcp)
- Authentication:
OAuth
The icon is optional. To show the Reap logo, upload this file in the **Icon** field: [Download Reap MCP icon](/images/help-center/reap-mcp-icon.png). ChatGPT accepts PNG only, up to 10 KB.
![New ChatGPT app form with Reap MCP server URL and OAuth authentication]()
ChatGPT warns that custom MCP servers introduce risk, because OpenAI has not reviewed the server. Tick **I understand and want to continue**, then click **Create**. The **Create** button stays disabled until the box is ticked.
Publish the app for your workspace or enable it for yourself, depending on your ChatGPT plan and admin permissions.
Click **Connect**, sign in to Reap, choose the workspace you want ChatGPT to use, and click **Authorize**.
![ChatGPT prompt to sign in with Reap]()
![Reap authorization screen for granting ChatGPT workspace access]()
If you do not see Developer Mode or custom app options in ChatGPT, check your OpenAI plan and workspace permissions. Some settings are only available to workspace admins or supported paid plans.
Enable the Reap app for a conversation before asking ChatGPT to use it.
## Connect Codex
Use this when you want Reap available in Codex. Reap is added as a plugin, so there is nothing to install locally.
Use this link to land straight on the dialog: [Add a connector in Codex](https://chatgpt.com/plugins#settings/Connectors?create-connector=true\&redirectAfter=%2Fplugins).
Open the [Codex plugins page](https://chatgpt.com/plugins), then add a connector from **Settings** > **Connectors**.
Use these values:
- Name:
Reap
- MCP Server URL:
[https://mcp.reap.video/mcp](https://mcp.reap.video/mcp)
- Authentication:
OAuth
The icon is optional. To show the Reap logo, upload this file in the **Icon** field: [Download Reap MCP icon](/images/help-center/reap-mcp-icon.png).
Sign in to Reap, choose the workspace you want Codex to use, and click **Authorize**. You are returned to the Codex plugins page when it succeeds.
On the plugins page, turn on the Reap plugin so Codex can use its tools.
## Confirm The Connection Works
In either tool, ask:
```text theme={"system"}
What Reap tools do you have access to?
```
If it lists the Reap tools, the connection is working.
## What You Can Ask For
```text theme={"system"}
Clip the best moments from this video and keep them under 60 seconds:
```
```text theme={"system"}
Add captions to this video and translate them into Spanish.
```
```text theme={"system"}
Reframe my last Reap upload to vertical 9:16 with the speaker centered.
```
## Troubleshooting
**ChatGPT**
* **No Developer Mode option?** Check your OpenAI plan and workspace permissions. Custom apps are limited to supported plans and admin roles.
* **App created but no tools?** Make sure the app is published or enabled for your account, and that it is turned on for the conversation.
**Codex**
* **Tools do not appear?** Make sure the Reap plugin is turned on for the session, then reload the plugins page.
* **Authorization never completes?** Open the connector dialog again and restart the sign-in. If the popup is blocked, allow popups for `chatgpt.com` and retry.
* **No option to add a connector?** Check your OpenAI plan and workspace permissions. Adding connectors can be limited to supported plans and admin roles.
**Both**
* **Wrong workspace?** Reconnect and pick the correct workspace on the Reap authorization screen.
* **Publishing fails?** Confirm your social accounts are connected in Reap.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Connect Reap MCP To Claude And Claude Code](/help-center/connect-reap-mcp-to-claude)
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Dashboard](https://app.reap.video)
# Connect Reap MCP To Claude And Claude Code
Source: https://docs.reap.video/help-center/connect-reap-mcp-to-claude
Add Reap as a custom connector in Claude chat, or as an HTTP MCP server in Claude Code, so you can create clips, captions, reframes, and dubs from either one.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Both Claude tools connect to the same Reap MCP endpoint over OAuth. You sign in to Reap and pick the workspace the tool is allowed to use. The setup differs:
* **Claude chat** (web and desktop): add Reap as a custom connector in settings.
* **Claude Code** (terminal): add Reap with one command, then run `/mcp` to sign in.
You never paste a Reap API key into either tool.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* You need access to the Reap workspace you want to connect.
* For Claude chat, custom connectors are available on paid plans. On Team and Enterprise workspaces, an admin may need to allow custom connectors.
* For Claude Code, install it and sign in first.
## Reap MCP Server URL
The endpoint is the same in both tools:
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Connect Claude Chat
Use this when you want Reap available in Claude on the web or desktop.
Use this link to land straight on the dialog: [Add a custom connector in Claude](https://claude.ai/new?modal=add-custom-connector#settings/customize-connectors).
Open [Claude connector settings](https://claude.ai/settings/connectors).
![Claude settings showing the Connectors section and Customize link]()
Then click **Add custom connector**. In some Claude workspaces, this appears under **Customize** > **Connectors**.
![Claude Customize connectors menu showing Add custom connector]()
Use these values:
- Name:
Reap
- MCP Server URL:
[https://mcp.reap.video/mcp](https://mcp.reap.video/mcp)
- Authentication:
OAuth
![Claude Add custom connector form with Reap MCP server URL]()
Click **Connect**, sign in to Reap, choose the workspace you want Claude to use, and click **Authorize**.
In Claude, enable the Reap connector for the conversation before asking Claude to use it.
## Connect Claude Code
Use this when you want Reap available in the Claude Code CLI.
Run this in your terminal:
```bash theme={"system"}
claude mcp add --transport http reap "https://mcp.reap.video/mcp"
```
To make Reap available in every project instead of just the current one, add it at user scope:
```bash theme={"system"}
claude mcp add --transport http --scope user reap "https://mcp.reap.video/mcp"
```
In Claude Code, run:
```text theme={"system"}
/mcp
```
Select **reap** and choose to authenticate. Claude Code opens the Reap authorization page in your browser.
Sign in to Reap, select the workspace Claude Code is allowed to use, and click **Authorize**. Close the tab when you see **Authentication successful**, then return to your terminal.
You can skip the manual setup entirely. Just ask Claude Code to do it: *"Add reap to my user-scoped MCP servers using `https://mcp.reap.video/mcp` and connect."*
## Confirm The Connection Works
In Claude Code, check the server list:
```bash theme={"system"}
claude mcp list
```
Or run `/mcp`, where **reap** should show as connected. In either tool, ask:
```text theme={"system"}
What Reap tools do you have access to?
```
## What You Can Ask For
```text theme={"system"}
Clip the best moments from this video and keep them under 60 seconds:
```
```text theme={"system"}
Add captions to this video and translate them into Spanish.
```
```text theme={"system"}
Dub my last Reap upload from English into Spanish.
```
In Claude Code you can also point at a local file: *"Upload `~/Videos/launch.mp4` and dub it into Spanish."* Claude chat has no access to your filesystem, so upload the video in Reap first.
## Troubleshooting
**Claude chat**
* **No Reap tools in the chat?** Make sure the Reap connector is toggled on for that conversation. Connectors are enabled per chat.
* **No "Add custom connector" button?** Custom connectors need a paid plan, and Team or Enterprise admins may have to allow them first.
**Claude Code**
* **Server shows as failed?** Run `claude mcp list` to see the error, then re-add the server with the exact URL above.
* **Stuck unauthenticated?** Run `/mcp`, select **reap**, and choose to re-authenticate. If the browser does not open, copy the URL from the terminal.
* **Reap missing in another project?** The default scope is local to one project. Re-add it with `--scope user`.
**Both**
* **Wrong workspace?** Reconnect and pick the correct workspace on the Reap authorization screen.
* **Publishing fails?** Confirm your social accounts are connected in Reap.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Connect Reap MCP To ChatGPT And Codex](/help-center/connect-reap-mcp-to-chatgpt)
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Dashboard](https://app.reap.video)
# Connect Reap MCP To Cursor
Source: https://docs.reap.video/help-center/connect-reap-mcp-to-cursor
Add Reap to Cursor with a small mcp.json entry, sign in with OAuth, and let Cursor clip, caption, reframe, dub, and publish from your Reap workspace.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Cursor reads MCP servers from an `mcp.json` file. You add Reap with a short entry, sign in through OAuth, and pick the workspace Cursor is allowed to use.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* Install Cursor and sign in to it.
* You need access to the Reap workspace you want to connect.
## Reap MCP Server URL
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Add Reap To Cursor
For a single project, create `.cursor/mcp.json` in the project root. To make Reap available everywhere, create `~/.cursor/mcp.json` instead.
```json theme={"system"}
{
"mcpServers": {
"reap": {
"url": "https://mcp.reap.video/mcp"
}
}
}
```
Remote servers use `url`. There is no `command` to run and nothing to install locally.
Save the file. If Reap does not appear right away, reload the window or restart Cursor.
Open **Cursor Settings** > **Customize**, where your MCP servers are listed. Find **reap** and click to connect or log in. Cursor also starts the sign-in flow automatically the first time it uses a Reap tool.
Sign in to Reap, select the workspace Cursor is allowed to use, and click **Authorize**. Close the tab when you see **Authentication successful**, then return to Cursor.
For a faster route, paste this into Cursor's chat: *"Add reap to my global MCP servers using `https://mcp.reap.video/mcp` and connect."* Cursor writes the config and starts the sign-in for you.
## Confirm The Connection Works
In **Cursor Settings** > **Customize**, **reap** should show as connected with its tools listed. You can also ask in chat:
```text theme={"system"}
What Reap tools do you have access to?
```
## Use Reap From Cursor
```text theme={"system"}
Clip the best moments from this video and keep them under 60 seconds:
```
```text theme={"system"}
Add captions to this video and translate them into Spanish.
```
## Troubleshooting
* **Reap not listed?** Check that the JSON is valid and uses the `mcpServers` key, then reload the Cursor window.
* **Listed but no tools?** Click **reap** under **Customize** and complete the OAuth sign-in.
* **Works in one project only?** A `.cursor/mcp.json` in a project root applies to that project. Move the entry to `~/.cursor/mcp.json` to use Reap everywhere.
* **Wrong workspace?** Disconnect Reap in settings, reconnect, and pick the correct workspace on the Reap authorization screen.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Connect Reap MCP To VS Code](/help-center/connect-reap-mcp-to-vs-code)
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Dashboard](https://app.reap.video)
# Connect Reap MCP To OpenClaw
Source: https://docs.reap.video/help-center/connect-reap-mcp-to-openclaw
Add Reap to OpenClaw as a streamable HTTP MCP server with OAuth, so your OpenClaw agent can clip, caption, reframe, dub, and publish video.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
OpenClaw manages MCP servers through its `openclaw mcp` commands and stores them in `~/.openclaw/openclaw.json`. You add Reap as a streamable HTTP server with OAuth, sign in, and pick the workspace OpenClaw is allowed to use.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* Install OpenClaw and have your gateway running.
* You need access to the Reap workspace you want to connect.
## Reap MCP Server URL
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Add Reap To OpenClaw
```bash theme={"system"}
openclaw mcp add reap \
--url https://mcp.reap.video/mcp \
--transport streamable-http \
--auth oauth
```
```bash theme={"system"}
openclaw mcp login reap
```
OpenClaw opens the Reap authorization page. If your setup returns an authorization code instead of completing in the browser, pass it back:
```bash theme={"system"}
openclaw mcp login reap --code
```
Sign in to Reap, select the workspace OpenClaw is allowed to use, and click **Authorize**.
```bash theme={"system"}
openclaw mcp reload
```
This clears the cached MCP runtime for the current CLI process. Gateway processes need their own restart or reload before they pick up the new server.
## Edit The Config Directly
If you prefer to edit the file, the entry lives under `mcp.servers` in `~/.openclaw/openclaw.json`:
```json theme={"system"}
{
"mcp": {
"servers": {
"reap": {
"url": "https://mcp.reap.video/mcp",
"transport": "streamable-http",
"auth": "oauth"
}
}
}
}
```
The canonical field is `transport: "streamable-http"`. OpenClaw also accepts the CLI-native `type: "http"` alias when saved through `openclaw mcp set`, and `openclaw doctor --fix` normalizes it.
## Confirm The Connection Works
```bash theme={"system"}
openclaw mcp status
```
```bash theme={"system"}
openclaw mcp tools reap
```
The second command lists the Reap tools available to your agent. You can also ask in chat:
```text theme={"system"}
What Reap tools do you have access to?
```
## Troubleshooting
* **Server unhealthy?** Run `openclaw mcp doctor` or `openclaw mcp probe reap` to see the connection error.
* **Tools missing after login?** Run `openclaw mcp reload`, then restart the gateway process.
* **Login loop?** Run `openclaw mcp logout reap` followed by `openclaw mcp login reap` to start a clean OAuth flow.
* **Wrong workspace?** Log out, log in again, and pick the correct workspace on the Reap authorization screen.
Do not paste secrets inline in `openclaw.json`, because the file ends up in backups and migrations. Reap MCP uses OAuth, so there is no API key to store here.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Dashboard](https://app.reap.video)
# Connect Reap MCP To VS Code
Source: https://docs.reap.video/help-center/connect-reap-mcp-to-vs-code
Add Reap to VS Code as an HTTP MCP server, sign in with OAuth, and use Reap tools from Copilot agent mode to clip, caption, reframe, dub, and publish.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
VS Code reads MCP servers from an `mcp.json` file and exposes their tools in **agent mode**. You add Reap as an HTTP server, sign in through OAuth, and pick the workspace VS Code is allowed to use.
VS Code uses a different JSON shape than Cursor: the top-level key is `servers` (not `mcpServers`), and remote servers need `"type": "http"`.
## Before You Start
* Your Reap workspace must be on a paid plan with API access enabled.
* Use a recent version of VS Code with GitHub Copilot enabled, and switch the Chat view to **Agent** mode.
* You need access to the Reap workspace you want to connect.
## Reap MCP Server URL
```text theme={"system"}
https://mcp.reap.video/mcp
```
## Add Reap To VS Code
For a single project, create `.vscode/mcp.json` in the project root. To make Reap available everywhere, open the Command Palette and run **MCP: Open User Configuration**, which opens the `mcp.json` in your user profile.
```json theme={"system"}
{
"servers": {
"reap": {
"type": "http",
"url": "https://mcp.reap.video/mcp"
}
}
}
```
Save the file. VS Code shows a **Start** action above the server entry. Click it, or run **MCP: List Servers** from the Command Palette and start **reap**.
VS Code prompts you to allow the server to sign in. Accept, then sign in to Reap, select the workspace VS Code is allowed to use, and click **Authorize**. Close the tab when you see **Authentication successful**.
Open the Chat view, switch to **Agent** mode, and click the tools icon to confirm the Reap tools are selected.
You can also add the server from the terminal with `code --add-mcp`, or just ask Copilot in agent mode to add `https://mcp.reap.video/mcp` for you.
## Confirm The Connection Works
Run **MCP: List Servers** from the Command Palette. **reap** should be running. Then ask in agent mode:
```text theme={"system"}
What Reap tools do you have access to?
```
## Use Reap From VS Code
```text theme={"system"}
Clip the best moments from this video and keep them under 60 seconds:
```
```text theme={"system"}
Reframe my last upload to vertical 9:16 with the speaker centered.
```
## Troubleshooting
* **Server does not start?** Check the JSON shape. VS Code needs `servers` with `"type": "http"`. The `mcpServers` key is Cursor's format and will not work here.
* **No tools in chat?** Reap tools only appear in **Agent** mode. Switch modes, then check the tools picker.
* **Stuck unauthenticated?** Run **MCP: List Servers**, stop and restart **reap**, and accept the sign-in prompt.
* **Wrong workspace?** Restart the server, re-authorize, and pick the correct workspace on the Reap authorization screen.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Connect Reap MCP To Cursor](/help-center/connect-reap-mcp-to-cursor)
* [Reap MCP Guide](/help-center/reap-mcp-guide)
* [MCP API Reference](/api-reference/mcp)
* [Reap Dashboard](https://app.reap.video)
# Create Clips With MCP
Source: https://docs.reap.video/help-center/create-clips-with-reap-mcp
Turn a long video or a YouTube URL into short, social-ready clips by asking your AI agent — orientation, duration, captions, and confirmation, all in chat.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can generate AI clips from a video for you. You describe what you want, the agent submits one clipping job, and Reap returns many short clips ready for social.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Reap MCP requires a paid plan with API access enabled.
## Clip From A URL
The quickest path. Point your agent at a public URL (like YouTube):
```text theme={"system"}
Clip the most engaging moments from this video and keep them under 60 seconds:
https://www.youtube.com/watch?v=XXXXXXXXXXX
```
## Clip From An Uploaded File
When the video is on your machine, ask your agent to upload it first:
```text theme={"system"}
Upload ~/Videos/founder-interview.mp4 to Reap, then create portrait clips with captions.
```
Your agent requests an upload URL, uploads the `.mp4` or `.mov`, and uses the result as the clip source. See [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp) to fetch the finished clips.
## Give Creative Direction
For broad requests, keep it simple — Reap's auto-selection finds strong moments better when you don't over-direct. Add detail only when you have a clear editorial goal:
```text theme={"system"}
From this interview, give me three punchy sub-30s hooks about pricing,
two 60-90s clips on the product demo, and skip the intro.
```
A single clipping job returns **many** clips. There's no need to ask for several separate projects from the same video.
## Options You Can Ask For
You can describe any of these in plain language and your agent applies them:
* **Orientation** — portrait (9:16) for social, square (1:1), or keep the original landscape.
* **Duration** — target lengths like "under 60 seconds" or "60–90s."
* **Captions** — on by default; ask for a specific style, emojis, or keyword highlighting, or turn them off.
* **Brand template** — apply your saved logo/intro/outro/music/caption style. See [Use Brand Templates With Reap MCP](/help-center/use-brand-templates-with-reap-mcp).
* **Resolution** — 720p, 1080p (default), 1440p, or 2160p.
* **Language** — just name it (e.g. "Spanish"); your agent looks up the code. Leave it out to auto-detect.
* **Translate captions** — into another language.
* **Face tracking** — keep the speaker centered when reframing to vertical.
## How Your Agent Handles It
Before submitting, your agent shows the planned settings — orientation, resolution, caption style, captions on/off — and asks you to confirm.
Approve as-is, or change anything in that step rather than re-running the job later.
Clipping runs asynchronously. Ask for status anytime, and you'll get an email when it finishes.
When ready, your agent lists each clip with links to open in Reap or download.
## Related
* [Use Brand Templates With Reap MCP](/help-center/use-brand-templates-with-reap-mcp)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Publish & Schedule Clips With Reap MCP](/help-center/publish-and-schedule-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Dub Videos With MCP
Source: https://docs.reap.video/help-center/dub-videos-with-reap-mcp
Voice-dub a video into 80+ languages with AI voice matching by asking your AI agent through Reap MCP.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can dub a video's audio into another language with AI voice matching. Dubbing supports 80+ languages.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Dubbing runs on a video **uploaded** to Reap. Ask your agent to upload the file first.
## Dub An Upload
Name the source and target languages — your agent looks up the exact codes Reap needs:
```text theme={"system"}
Upload ~/Videos/launch.mp4 and dub it from English into Spanish.
```
To see what's available first:
```text theme={"system"}
What languages can Reap dub into?
```
## How Your Agent Handles It
Dubbing needs an upload, so your agent uploads your `.mp4` or `.mov` first if it isn't already in Reap.
You say "English to Spanish"; your agent maps those to the exact source and target language codes Reap expects.
Dubbing runs asynchronously — ask for status anytime, and you'll get an email when it completes.
## Related
* [Add Captions & Translate With Reap MCP](/help-center/add-captions-with-reap-mcp)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Edit Clips
Source: https://docs.reap.video/help-center/edit-clips
Open generated clips in the editor, refine them with transcript-based tools, and use detailed editor guides for specific tasks.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's editor helps you fine-tune clips after they are generated. You can open a clip in the editor, adjust the transcript, remove unwanted parts, change layout and orientation, add assets, and export a polished final result.
## What You Can Do In The Editor
Use the editor to:
* Remove or trim unwanted parts from clips
* Correct transcript words
* Highlight important words
* Add emojis
* Add highlights
* Add voiceover
* Change orientation
* Add assets, b-rolls, text, and branding
* Adjust caption timing
* Reorder timeline rows and add more layers
## How To Open A Clip In The Editor
1. Generate your clips in Reap.
2. Click the **Edit** button below the clip you want to refine.
3. Make changes in the editor, preview the result, then export when you're ready.
## Transcript-Based Editing
Inside the editor, you can select transcript text and apply editing actions directly from the context menu.
Common transcript actions include:
* `Set as start`
* `Set as end`
* `Correct word`
* `Highlight`
* `Add emoji`
* `Remove caption`
* `Remove video`
* `Cut`
## Sidebar Tools
The editor also includes tools such as:
* `Brand` to apply your brand template
* `Caption` to change caption presets
* `AI Tools` for emoji, highlighter, and voice over features
* `Text` to add text overlays
* `B-rolls` to add supporting footage
* `Assets` to add audio, video, or image assets
## Core Editing Guides
Start with these common editing workflows to shape the look, pacing, and structure of your clip.
Add text overlays and control their position, style, and timing.
Change row order to control which elements appear above others.
Add opening and ending assets for a more polished final video.
Layer in supporting visuals to make clips feel more dynamic.
Bring in images, video, or audio files directly into the editor.
Place a watermark or branded asset on top of your clip.
Create extra rows when you need more layers for complex edits.
Add enter and exit transitions between segments.
Apply filter presets to quickly change the visual style.
Fine-tune brightness from the video panel.
Access clip-level settings and controls from the editor panel.
Speed up common editing actions with keyboard shortcuts.
## Orientation, Layout and Reframing
Use these guides when you need to change the shape of the frame, improve composition, or troubleshoot reframing issues.
Switch the clip orientation and review each segment after the change.
Choose the layout that best fits the speaker or screen share in the frame.
Use the right mode when your video includes screen sharing or slides.
Follow an on-stage speaker and keep them in frame as they move.
Fine-tune framing on the canvas when automatic results need more control.
Troubleshoot framing and cropping issues in the editor.
Understand why layout options are not available for landscape videos.
Learn how auto-reframing behaves after adding new segments or saving changes.
## Captions, Emojis and Highlights
Use these guides when you want to restyle captions, change their position, or refine them with emojis, highlights, and timing adjustments.
Browse caption presets and customize the style for your clip.
Turn captions off when you want a clean export without subtitles.
Move captions anywhere on the canvas to better fit your layout.
Customize font and color settings to match the look of your clip.
Add emojis to specific transcript moments for extra expression.
Emphasize key words directly from the transcript.
Fine-tune when captions appear and disappear with more precision.
## Remove Silences, Find and Correct Words
Use these guides to clean transcript issues, remove dead air, and polish the final pacing of your clip.
Detect and remove silent sections automatically from the editor.
Fix incorrect caption words directly from transcript options.
## Segment Editing
Use these guides when you want to extend an AI clip or remove sections that are not working.
Add more content when an AI-generated clip ends too early.
Cut unwanted transcript sections and clean up the final clip quickly.
## Tips For Editing Clips
* Start with transcript edits first when you want the fastest changes.
* Preview your clip after each major adjustment.
* Use assets and timeline rows together when you want layered visual edits.
* Export only after the transcript, layout, and timing feel right.
# Editor keyboard shortcuts
Source: https://docs.reap.video/help-center/editor-keyboard-shortcuts
Use keyboard shortcuts in the Reap editor to move faster while editing, reviewing, and previewing clips.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use these keyboard shortcuts to edit faster in the Reap editor.
On Mac, use `Cmd`. On Windows and Linux, use `Ctrl`.
## Editing Actions
* `Redo`: `Cmd/Ctrl + Shift + Z` or `Cmd/Ctrl + Y`
* `Delete selected overlay`: `Delete` or `Backspace`
* `Duplicate selected overlay`: `Cmd/Ctrl + D`
* `Split selected overlay`: `Alt + S`
* `Save draft`: `Cmd/Ctrl + S`
## Timeline Controls
* `Timeline zoom in`: `Alt + +` or `Alt + =`
* `Timeline zoom out`: `Alt + -`
## Playback Controls
* `Play / Pause`: `Space` or `Alt + Space`
* `Toggle loop`: `Alt + L`
* `Toggle mute`: `Alt + M`
## Notes
* Some shortcuts only work when an overlay is selected.
* If a shortcut does not respond, click inside the editor once and try again.
# Face Tracking
Source: https://docs.reap.video/help-center/face-tracking
Use Face Tracking to follow a speaker on stage and keep them in frame throughout the clip.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Face Tracking helps keep an on-stage speaker in frame as they move around. It follows the speaker's face and adjusts the crop so the final clip stays focused on the person speaking.
Face Tracking is available in both **Clipping** and **Auto Reframe**. It is turned on by default before clipping, so Reap will automatically apply it unless you turn it off.
Use Face Tracking for talks, keynotes, podcasts, panels, interviews, lectures, and event videos where the main speaker may walk, turn, or shift position during the recording.
## When To Use Face Tracking
* Your source video has a speaker on stage or in front of an audience.
* The speaker moves around and may drift out of the center of the frame.
* You are converting a wider video into a portrait or square clip.
* You want Reap to prioritize the person speaking instead of keeping a fixed crop.
## Use Face Tracking Before Clipping
This video shows where to turn Face Tracking on or off before generating clips.
Upload your video or paste a supported video link into Reap.
Select the video genre, captions, language, script, orientation, and resolution for the clips you want to generate.
Face Tracking is on by default. Leave it on if you want Reap to follow the speaker and keep them in frame.
Toggle Face Tracking off before clicking **Get Clips** if you do not want it applied to the generated clips.
Click **Get Clips** to generate your clips with the selected Face Tracking setting.
## Use Face Tracking With Auto Reframe
Face Tracking is also available when using Auto Reframe. Keep it enabled when you want Reap to follow the speaker while reframing the video into another orientation, such as portrait or square.
Turn Face Tracking off in Auto Reframe if you want the reframed output to use a more fixed crop instead of following the speaker.
## Change Face Tracking After Clips Are Generated
You can also change Face Tracking after clips are generated.
This video shows where to turn Face Tracking on or off and adjust Face Tracking settings inside the clip editor.
Open the generated clip you want to adjust.
In the editor, open **AI Tools**.
Toggle Face Tracking off if you no longer want it applied, or keep it on and make adjustments to improve the tracked framing.
Review the clip to make sure the speaker stays in frame, then export when the result looks right.
You may see motion blur in the `480p` preview for an unexported clip and inside the editor. Export the clip to see the final result with clean movement and no motion blur.
## What To Check Before Exporting
* The speaker's face stays visible throughout the important moments.
* The crop does not cut off key gestures, slides, or visual context you want to keep.
* The framing still feels natural when the speaker turns, walks, or changes position.
* Captions, overlays, and other assets do not cover the speaker's face.
## If The Framing Needs Adjustment
If Face Tracking is close but not perfect, open the clip in the editor and adjust the framing manually. Manual framing changes take priority, so Reap will keep the edits you make on the canvas.
For videos with screen sharing, slides, or demos, use Presentation mode when generating clips so Reap can include the shared content along with the speaker.
# Getting Started
Source: https://docs.reap.video/help-center/getting-started
Set up your Reap account, upload your first video, and generate social-ready clips.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Welcome to Reap
Reap helps you turn long-form videos into short, social-ready clips with AI. You can upload a file or paste a supported video link, generate clips automatically, refine them in the editor, and export ready-to-share content in just a few steps.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## What You'll Do
Sign up at [reap.video](https://reap.video/) with your email, or continue with Google.
Upload a local video file or paste a supported video URL from platforms like YouTube, Vimeo, Twitch, or X.
Let Reap analyze your content and find the most engaging moments automatically.
Open your clips in the editor to trim segments, update captions, add highlights, and adjust orientation.
Export your finished clips, save drafts, or schedule content for publishing.
## Step 1: Sign Up And Log In
* Create your account on [reap.video](https://reap.video/).
* Sign in with email and password, or use Google for passwordless login.
* After login, you'll land on your dashboard.
## Step 2: Upload A Video Or Paste A Link
* Click **Generate Clips** from the dashboard.
* Upload your video file, or paste a supported source link.
* Reap supports common long-form sources including YouTube, Vimeo, Twitch, X, and local MP4 uploads.
Use dialogue-rich videos for the best AI clipping results, especially podcasts, interviews, commentary, tutorials, and talking-head content.
## Step 3: Generate Clips
Once your source video is added, Reap analyzes the content and identifies strong moments for short-form clips.
* Use AI clipping to generate clips automatically.
* Steer the AI with a clip prompt — describe in plain language what kinds of clips you want (count, duration, focus, tone). See [How to Create Viral Clips](/help-center/how-to-create-viral-clips#11-add-a-clip-prompt-optional).
* Review the generated results before exporting.
* Fine-tune individual clips in the editor after generation if needed.
For a deeper walkthrough, see [How to Create Viral Clips](/help-center/how-to-create-viral-clips).
## Step 4: Edit And Customize
Use the editor to fine-tune each clip before export.
### Common edits
* Adjust clip start and end points.
* Remove unwanted moments.
* Add captions and change caption styling.
* Add emojis and word highlights.
* Add voice overs.
* Add b-rolls and assets.
* Change clip orientation to fit your target platform.
Extend AI-generated clips with additional segments.
Clean up clips by removing unnecessary sections.
Customize the look of your captions.
Adapt clips for portrait, square, or other layouts.
Add emojis and highlights to make your captions and clips more expressive.
Add voice overs to enhance or localize your content.
Add b-roll footage to support the main story of your clip.
Add images, videos, audio, and branded assets to your clips.
## Step 5: Review Virality Score
Each generated clip includes a virality score to help you evaluate its social media potential.
* Use the score to compare clips quickly.
* Prioritize the strongest options for export and publishing.
* Combine the score with your own editorial judgment before sharing.
## Step 6: Export, Save Drafts, And Share
When your clip is ready:
* Export it in HD.
* Save a draft if you want to come back later.
* Use Reap-generated social media descriptions to speed up publishing.
## More Ways To Get Started
Generate captions separately for any video.
Link your platforms for scheduling and publishing.
Schedule posts or publish content directly from Reap.
Dub your videos into other languages with AI voice generation.
Automatically reframe videos for portrait, square, and other layouts.
Edit clips, captions, assets, and layouts directly inside the editor.
Generate transcriptions to repurpose and review your video content.
Turn audio content into engaging visual posts for social media.
Automate clipping, captions, dubbing, and more with the Reap API.
You're ready to create your first clips in Reap.
# How can I add emojis in the captions?
Source: https://docs.reap.video/help-center/how-can-i-add-emojis-in-the-captions
Add emojis to specific words in the transcript from inside the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add emojis directly from the transcript in the editor to make important moments feel more expressive and engaging.
![Add emoji in captions]()
## Step-By-Step Workflow
Open the clip in the editor.
Click on the part of the transcript where you want to add an emoji.
Use the transcript options and choose **Add emoji**.
Review the clip to make sure the emoji appears where you want it.
# How can I change the captions position?
Source: https://docs.reap.video/help-center/how-can-i-change-the-captions-position
Move captions anywhere on the canvas to better fit your clip layout.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can reposition captions directly on the canvas in the editor when you want them to sit higher, lower, or away from other visual elements.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
Click directly on the captions in the preview.
Drag the captions anywhere on the canvas to change their position.
Review the updated placement to make sure the captions sit where you want them.
Once satisfied, click **Export**. Your updated clip will be ready after export is completed.
# How can I change the clip layout?
Source: https://docs.reap.video/help-center/how-can-i-change-the-clip-layout
Change the layout of a clip segment from the editor and choose the option that fits your content best.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use layout controls in the editor when you want to improve how the speaker, screen share, or frame composition appears in your clip.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
On the timeline, click the video segment you want to update. This opens the video preview and controls in the right side panel.
In the right side panel, locate the layout settings for the selected segment.
Available layout options include **Fill**, **Fit**, and **Split**. Use the one that best matches the content in your frame.
Review the updated layout to make sure the framing looks right before final export.
Once you are satisfied, click **Export**. Your updated clip will be ready to download after export is completed.
## Layout Options
* `Fill` centers the speaker, enlarges the video, and crops it to better fit a vertical frame.
* `Fit` trims to a tighter aspect ratio and adds padding to adapt the clip to a vertical layout.
* `Split` shows both speakers at the same time when both are visible in the original frame.
# How can I highlight the words?
Source: https://docs.reap.video/help-center/how-can-i-highlight-the-words
Highlight important words in the transcript from inside the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use highlights to emphasize important words in your captions and make key moments stand out more clearly.
![Highlight words in captions]()
## Step-By-Step Workflow
Open the clip in the editor.
Click on the word in the transcript that you want to emphasize.
Use the transcript options and choose **Highlight**.
Review the result to make sure the highlighted word appears the way you want.
# How Many Clips Can I Get?
Source: https://docs.reap.video/help-center/how-many-clips-can-i-get
See the estimated clip ranges Reap can generate from videos of different lengths.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The number of clips Reap generates depends on both the length of your video and the clipping settings you use. In general, longer videos can produce more clips, but the final count can still vary depending on your content and selected setup.
## Estimated Clip Ranges
| Video length | Typical clip range |
| ------------------ | ------------------ |
| `0-3 minutes` | `1-4 clips` |
| `3-10 minutes` | `4-14 clips` |
| `10-30 minutes` | `5-21 clips` |
| `30-60 minutes` | `23-32 clips` |
| `60-120 minutes` | `32-42 clips` |
| `Over 120 minutes` | `42-55 clips` |
## What Affects The Final Count
* The total length of the video.
* The type of content in the video.
* The clipping settings you choose.
* How many distinct usable moments the AI finds.
* An explicit count in your [clip prompt](/api-reference/create-clips#prompt) (e.g. "give me 5 clips") nudges the count, but it's still capped by the video's length and how many distinct moments fit your duration setting.
These ranges are estimates, not guarantees. Some videos naturally contain more clip-worthy moments than others.
# How to add assets
Source: https://docs.reap.video/help-center/how-to-add-assets-to-your-clips
Add images, videos, and audio assets to your clips from inside the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the Assets panel in the editor to add images, videos, or audio assets to your clip and preview how they fit before export.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Locate the Assets option in the editor sidebar.
Add images, videos, or audio assets to enhance the clip.
Review the placement and fit of the assets, then export when ready.
# How to Add b-rolls
Source: https://docs.reap.video/help-center/how-to-add-b-rolls-to-your-clip
Add images, videos, or audio as b-roll in the editor to make your clips more dynamic.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add b-rolls to your clip from inside the editor. This helps enhance the main video with supporting visuals or media.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
On the right panel of the editor, locate the **B-rolls** option.
Add images, videos, or audio as b-roll to enhance your clip.
Adjust the b-rolls so they fit the timing and flow of your content, then preview the result to make sure everything looks right.
Once you are satisfied, click **Export**. Your updated clip with b-rolls will be ready to download after export is completed.
# How to add captions
Source: https://docs.reap.video/help-center/how-to-add-captions-to-your-videos
Generate captions for your videos, customize the style, and export a captioned version ready to share.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap makes it easy to add captions to your videos for better accessibility, stronger engagement, and more polished social content. Upload your video, choose your caption settings, generate captions with AI, and make final edits before export.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Start by pasting a video link or uploading a file from your device.
Select a caption style or brand template, then set language, translation, script, resolution, and optional caption effects.
Click **Generate Captions**, review the result, and make any edits you need before export.
## 1. Add Your Source Video
* Paste a supported video link into the input field, or upload a file from your device.
* The upload screen supports direct file browsing and drag-and-drop.
* Supported formats: `.mp4`, `.mov`, `.webm`.
* Supported uploads start at `3 seconds` and go up to `15 minutes`.
* Maximum file size: `2 GB`.
## 2. Choose A Caption Style Or Brand Template
* Pick a style from the **Caption styles** tab.
* If you already have saved branded presets, switch to **Brand templates** instead.
* You can use **More Styles** to browse additional caption looks.
## 3. Choose The Spoken Language
* Select the primary language spoken in the video.
* This helps Reap generate more accurate transcription and caption timing.
## 4. Set Translation
* Optionally choose a **Translate to** language if you want translated captions.
If you do not need translated captions, leave **Translate to** set to `None`.
## 5. Choose Script Mode
Choose the **Script** mode:
* `Native` for captions in the original writing system of the selected language.
* `Roman` for romanized captions written in Latin characters.
## 6. Choose Resolution
Choose the **Resolution** for the captioned export.
* `720`
* `1080`
* `2K`
* `4K`
## 7. Configure Optional Caption Effects
You can enable extra visual styling before generating captions:
* Turn on **AI Emoji** to automatically add emojis where they fit naturally.
* Turn on **Keyword Highlighter** to highlight important words in the captions.
Emoji and highlighter settings are optional. You can keep them off for a cleaner caption style, or turn them on for a more expressive social format.
## 8. Generate Captions
* Click **Generate Captions** to start the AI transcription process.
* Reap will process the video and prepare your captioned output for review.
## 9. Review And Edit
After generation, you can refine the result before export.
Common editing actions include:
* Correct individual words.
* Manually highlight specific words.
* Add custom emojis.
* Change the caption style.
## 10. Export Your Captioned Video
Once you are satisfied with the result:
* Click **Export**.
* Wait for export to complete.
* Download the captioned video when it is ready.
## What To Adjust First
If you want better caption results quickly, focus on these settings first:
1. Spoken language
2. Caption style or brand template
3. Emoji and keyword highlighter toggles
Those settings usually have the biggest effect on how accurate and polished the final captioned video feels.
# How to Add Filters
Source: https://docs.reap.video/help-center/how-to-add-filters-to-your-clip
Apply filter presets to clip segments from the video panel in the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can apply filters to your clip from inside the editor. Select a segment, open the video panel, and choose the filter preset you want to use.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open your clip in the editor by clicking the **Edit** button.
Click on the segment on the timeline where you want to apply a filter.
When the segment is selected, the video panel opens on the right side of the editor.
Below the video preview, click the **Style** button on the right side of the settings button.
In **Style**, choose the filter preset you want to apply to the selected segment.
If you want the same filter across the entire clip, repeat the process for each segment.
Preview the clip to make sure the filters look the way you want. When you are satisfied, click **Export**.
# How to Add Intro and Outro
Source: https://docs.reap.video/help-center/how-to-add-intro-and-outro-to-your-clips
Add intro and outro assets in the editor to give your clips a polished beginning and ending.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add an intro and outro to your clip directly inside the editor. Upload both assets, place them on the timeline, and preview the final result before exporting.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open the clip in the editor by clicking the **Edit** button.
On the right side panel, locate the **Assets** section.
Upload your intro file into **Assets**, then upload your outro file into **Assets**.
Click your intro asset and add it to the timeline at the beginning of your clip. Move the captions timeline forward to make space for the intro.
Click your outro asset and add it to the timeline, then drag it to the end of your clip.
Preview the clip to make sure the intro appears at the start and the outro appears at the end. Check that captions and other elements are still positioned the way you want.
When you are satisfied with the result, click **Export**.
# How to add more caption styles?
Source: https://docs.reap.video/help-center/how-to-add-more-caption-styles
Browse more caption style presets in the editor and customize them before export.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the captions panel in the editor to browse more caption styles and apply the preset that best matches your clip.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
Select the **Captions** option in the editor.
Browse the available caption style presets and select the one you want to use.
Adjust the caption styling further if you want to better match your preferences or brand.
Review the captions in the preview, then click **Export** when you are satisfied.
# How to add more rows on the timeline in the editor
Source: https://docs.reap.video/help-center/how-to-add-more-rows-on-the-timeline-in-the-editor
Add more timeline rows in the editor when you need additional layers for assets, captions, and overlays.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Add more rows on the timeline when you need more layers for assets, captions, b-rolls, and other overlay elements.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Click the settings button inside the editor.
Click the plus (`+`) button to create more layers on the timeline.
Save your changes by exporting once the timeline is set up the way you want.
# How to add text
Source: https://docs.reap.video/help-center/how-to-add-text-to-your-clips
Add text overlays to your clips in the editor and customize their style and position.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the Text option in the editor to add text overlays anywhere on your clip and style them to match your content.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Locate the Text option in the right panel of the editor.
Add your text to the clip, position it on the canvas, and adjust the font and color in styles.
Review the text overlay, then export when ready.
# How to Add Transitions
Source: https://docs.reap.video/help-center/how-to-add-transitions-to-your-clips
Add enter and exit animations to clip segments from the video panel in the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add transitions between segments of your clip from inside the editor. Reap lets you apply enter and exit animations on selected segments to improve the flow of the final video.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open your clip in the editor by clicking the **Edit** button.
On the timeline, click the segment where you want to add a transition.
When you select a segment, the video panel opens on the right side of the editor.
Use the video panel to add an **enter animation** for when the segment starts and an **exit animation** for when the segment ends.
Repeat the same process for each segment where you want transitions.
Preview the clip to see how the transitions appear between segments.
When you are satisfied, click **Export**.
# How to Add Your Watermark or Branding
Source: https://docs.reap.video/help-center/how-to-add-your-watermark-or-branding-to-clips
Upload your watermark or branding asset in the editor and place it on the timeline.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add your watermark or branding to a clip from inside the editor. Upload the asset, place it on the timeline, and adjust its size and position before exporting.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open your clip in the editor by clicking the **Edit** button.
In the right side panel, go to the **Assets** section.
Upload your watermark or branding file into **Assets**.
Click your watermark asset and add it to the timeline. Drag the asset along the timeline to control how long it appears on the clip.
Click the watermark on the clip preview, then move or resize it as needed.
Preview the clip to confirm the watermark is displayed correctly.
When you are satisfied, click **Export**.
# Bulk Schedule Clips
Source: https://docs.reap.video/help-center/how-to-bulk-schedule-clips
Schedule multiple clips from the same video in one flow using the Schedule clips button on the clipping page.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you want to schedule multiple clips from one video at the same time, use the **Schedule clips** button on the clipping page. This lets you send several clips to your connected social platforms in one workflow instead of scheduling each clip one by one.
## Step-By-Step Workflow
Go to the video project that contains the clips you want to schedule.
Use the **Schedule clips** button on the clipping page to open the scheduling flow for multiple clips.
Select the clips you want to include, then click **Next**.
On the next screen, choose the date, time, interval between clips, and connected social platforms.
Click **Next**, then complete the scheduling action so the selected clips are added to your calendar.
## 1. Open The Clipping Page
* Start from the project where your clips were generated.
* Make sure the clips you want to schedule are already available there.
## 2. Click Schedule clips
* Use the **Schedule clips** button on the clipping page.
* This opens the scheduling workflow for multiple clips from the same video.
## 3. Choose The Clips
* Select the clips you want to schedule.
* Click **Next** when your clip selection is ready.
## 4. Set Date, Time, Interval, And Platforms
* Choose the date for the scheduled posts.
* Set the time for the publishing flow.
* Choose the time interval between the clips.
* Select the connected social platforms where the clips should be scheduled.
## 5. Click Next And Schedule
* Click **Next** after the scheduling details are set.
* Complete the scheduling action.
* The selected clips will be added to your publishing calendar.
Scheduling multiple clips works best after your accounts are already connected. If needed, connect your accounts first from **Connect Socials**.
## What To Know
* Bulk scheduling helps you schedule multiple clips from one video faster.
* It uses your connected social platforms, so the correct accounts must already be linked.
* You can control both the scheduled time and the interval between clips before confirming.
# How to change the orientation of AI-generated clips
Source: https://docs.reap.video/help-center/how-to-change-the-orientation-of-ai-generated-clips
Open a generated clip in the editor, change its orientation, and review the layout before export.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Change the orientation of AI-generated clips in the editor when you want the layout to better match the platform where the clip will be published.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the generated clip.
Go to the settings button in the editor and choose the desired orientation.
Check the layout of each segment and adjust it if needed.
Export once the new orientation looks right.
# How to change timeline row positions in the editor
Source: https://docs.reap.video/help-center/how-to-change-timeline-row-positions-in-the-editor
Reorder timeline rows in the editor to control how assets, b-rolls, and captions layer in your clip.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Change timeline row positions when you want to control how assets, b-rolls, captions, and other elements are layered in the final video.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Locate the rows for assets, b-rolls, captions, and other elements.
Move a row up or down to change its position on the timeline.
Check the layering in preview, then export once it looks right.
## Why Row Order Matters
* Rows placed higher on the timeline appear above lower rows in the final video.
* This helps you control which elements stay on top when multiple items overlap.
# Connect Social Media Accounts
Source: https://docs.reap.video/help-center/how-to-connect-social-media-accounts
Connect your social accounts so you can schedule and publish content directly from Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can connect your social media accounts to Reap so you can schedule and publish clips directly to your platforms.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Go to **Connect Socials** from your dashboard, or open it from **Settings > Connect Socials**.
Select the social media platforms you want to connect to your Reap workspace.
Follow the login and authorization prompts for each platform.
Once your accounts are connected, you can schedule or publish content directly from Reap.
## 1. Open Connect Socials
* Open **Connect Socials** from the dashboard.
* You can also find it in **Settings > Connect Socials**.
## 2. Select The Platforms You Want To Link
* Choose the social platforms you want to connect.
* Repeat the connection flow for each platform you want to use.
## 3. Authorize Each Account
* Sign in to the selected platform if prompted.
* Approve the permissions needed for scheduling and publishing.
## 4. Use Connected Accounts For Publishing
* Connected accounts will be available when you schedule posts.
* You can also use them when publishing content directly from a project.
* You can link multiple accounts if you want to publish across more than one platform.
Connect all of the accounts you plan to use before you start scheduling posts. That makes the publishing workflow much faster later.
# How to Create an Audiogram
Source: https://docs.reap.video/help-center/how-to-create-an-audiogram
Turn audio into an animated audiogram with templates, branding, translation settings, and export controls.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap lets you turn audio into a shareable animated audiogram in just a few steps. Upload your audio, choose a visual template, add optional branding elements, and generate a social-ready video version of your audio content.
Use this workflow to turn audio into a shareable animated video with templates, branding, and export controls.
## Step-By-Step Workflow
Start by uploading the audio file you want to turn into an audiogram.
Pick the visual style for the audiogram before adding optional branding and text.
Configure the output settings for the generated audiogram.
Click **Generate audiogram** to create the final animated output.
## 1. Upload Your Audio
* Upload an audio file from your device.
* Supported formats: `.mp3`, `.m4a`, `.wav`.
* Supported uploads start at `3 seconds` and go up to `15 minutes`.
* Maximum file size: `1 GB`.
## 2. Choose A Template Or Brand Template
* Use the **Templates** tab to pick a built-in audiogram style.
* Switch to **Brand templates** if you want to use a saved branded layout instead.
* Available templates include options like `Vinyl Vibes`, `Daily Cafe`, and `After Dark`.
## 3. Add Optional Branding And Visual Elements
You can personalize the audiogram before generation:
* Upload a **Logo**.
* Add **Text** for overlay content.
* Upload a **Background image**.
## 4. Choose Language And Translation
* Select the primary **Language** for the audio.
* Optionally choose **Translate to** if you want translated output.
If you do not need translation, leave **Translate to** set to `None`.
## 5. Choose Script Mode
Select how the script should be handled:
* `Native` for captions in the original script of the selected language.
* `Roman` for romanized captions, where the spoken language is written using Latin characters.
## 6. Choose Orientation
Pick the aspect ratio based on where you plan to publish the audiogram.
| Orientation | Best for |
| ------------------ | ------------------------------------ |
| `Portrait (9:16)` | YouTube, Instagram, TikTok, Facebook |
| `Landscape (16:9)` | YouTube, Facebook |
| `Square (1:1)` | Instagram, Facebook, LinkedIn |
Choose orientation based on the target platform first. This usually has the biggest impact on how native the final audiogram feels.
## 7. Choose Resolution
Select the export resolution for the generated audiogram:
* `720`
* `1080`
* `2K`
* `4K`
## 8. Generate The Audiogram
* After your template and settings are ready, click **Generate audiogram**.
* Reap will process the audio and create the animated audiogram output.
## 9. Edit The Audiogram After Generation
After the audiogram is generated, you can continue refining it inside the editor.
You can update visual and content elements such as:
* Audiogram position
* Text
* Logo
* Background
* Captions
* Assets
* B-rolls
You can also use transcript editing options to fine-tune the final result:
* Correct words in the transcript
* Highlight important words
* Add emojis
* Remove captions
* Remove video or audio sections
* Cut unwanted parts
## Tips For Better Audiogram Results
* Start with clear audio for a cleaner final result.
* Pick a template that fits the platform where the audiogram will be shared.
* Add a logo and text overlay when you want the output to feel more branded.
* Use a background image when you want a more visual, custom look.
# How to Create Viral Clips
Source: https://docs.reap.video/help-center/how-to-create-viral-clips
Create AI-generated social-ready clips from a video upload or pasted link using Reap's clipping workflow.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's clipping workflow helps you turn long-form videos into short, engaging clips for social media. Start with a video upload or pasted link, configure your clip settings, and let Reap generate ready-to-edit clips in a few minutes. For finer editorial control, you can also describe what kinds of clips you want in plain language using a clip prompt — see [Add a Clip Prompt](#11-add-a-clip-prompt-optional) below.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open the clipping workflow and add your source video from a local upload or a supported video link.
Use the first **Get Clips** action to open the clipping setup screen.
Configure genre, caption style, language, orientation, resolution, timeframe, and clip length before starting generation.
Click **Get Clips** again to begin generating your clips.
## 1. Add Your Source Video
* Upload a local video file, or paste a supported video URL.
* Supported formats: `.mp4`, `.mov`, `.webm`, `.mkv`.
* Supported uploads start at `1 minute` and go up to `180 minutes (3 hours)`.
* Maximum file size: `10 GB`.
* After your video loads, click **Get Clips** to move into the clipping setup flow.
## 2. Select Video Genre
Choose the genre that best matches your video so Reap can optimize the clipping behavior.
* `Talking`
* `Presentation`
* `Gaming`
## 3. Choose Caption Style Or Brand Template
* Pick a built-in caption style from the **Caption styles** tab.
* If you have reusable brand presets, switch to **Brand templates** and select one there instead.
## 4. Set Language And Translation
* Set the main spoken **Language** of the source video.
* Optionally choose a **Translate to** language if you want translated clips.
Translation is optional. If you do not want translated clips, leave **Translate to** set to `None`.
## 5. Choose Script Mode
Select how the script should be handled:
* `Native` for captions in the original script of the selected language.
* `Roman` for romanized captions, where the spoken language is written using Latin characters.
## 6. Choose Orientation
Pick the aspect ratio based on where you plan to publish the clips.
| Orientation | Best for |
| ------------------ | ------------------------------------ |
| `Portrait (9:16)` | YouTube, Instagram, TikTok, Facebook |
| `Landscape (16:9)` | YouTube, Facebook |
| `Square (1:1)` | Instagram, Facebook, LinkedIn |
Choose orientation based on the target platform first. This usually has the biggest impact on how native the final clip feels.
## 7. Choose Resolution
Select the export resolution for the generated clips:
* `720`
* `1080`
* `2K`
* `4K`
## 8. Set Processing Time Frame
Use the **Processing Time Frame** slider to control which part of the video Reap should analyze.
* Select the full video if you want clips from the entire upload.
* Narrow the range if you only want clips from a specific section.
## 9. Choose Auto Clip Length
Pick the clip-length range Reap should target:
* `<30s`
* `30s-60s`
* `60s-90s`
* `90s-3min`
## 10. Add Clip Topics (Optional)
Use **Clip Topics** to guide Reap toward specific subjects you want included in the output.
* Add keywords or topics separated by commas.
* Leave it empty if you want Reap to choose freely from the full video.
Clip topics are optional. They are most useful when you want the clips to focus on a specific theme, person, or talking point.
## 11. Add a Clip Prompt (Optional)
Use a **Clip Prompt** to describe in plain language what kinds of clips Reap should pull. A prompt is the richest control you have — it can steer clip count, duration, focus, exclusions, editorial mode, and tone, and it overrides generic virality scoring when the two conflict.
Clip prompts are live today in the [Automation API](/api-reference/create-clips#prompt) as a preview feature. Prompts in the app are in **private beta** — [request access](mailto:hello@reap.video?subject=Clip%20Prompt%20Private%20Beta) for your workspace. In the meantime, [Clip Topics](#10-add-clip-topics-optional) is the closest thing in the UI.
Examples of what a prompt can do:
* "Highlight reel of the funniest moments — keep clips under 60 seconds."
* "Only product-demo segments where the host walks through a feature."
* "Give me 5 clips, each focused on a single tactical takeaway."
* "Trailer-style cuts that build to a punchline; skip anything about pricing."
For 14 ready-to-use prompts covering every editorial mode — highlight reel, trailer, hooks only, quotes, Q\&A, storytelling, and more — see [Example prompts](/api-reference/create-clips#example-prompts) in the API reference.
The prompt is a preview feature: the field, its name, and its 1000-character limit are stable, but how the AI interprets a given instruction may evolve. Pin a tested prompt for production workflows.
Combine a clip prompt with the **Processing Time Frame** slider when you want a focused set of clips from a specific section of the video — the slider narrows the source, the prompt narrows the editorial.
## 12. Generate Your Clips
Once your setup is ready:
* Review your selections.
* Click **Get Clips** again to start processing.
Reap will begin generating clips based on your selected settings, and your viral-ready clips should be available within a few minutes.
## What To Adjust First
If you want the best results quickly, prioritize these settings first:
1. `Clip Prompt` (when you have specific editorial intent — see [Add a Clip Prompt](#11-add-a-clip-prompt-optional))
2. `Video Genre`
3. `Orientation`
4. `Auto Clip Length`
5. `Processing Time Frame`
Those choices usually have the biggest effect on how the final clips look and feel.
# Disconnect Your Social Media Accounts
Source: https://docs.reap.video/help-center/how-to-disconnect-your-social-media-accounts
Remove Reap from your connected social accounts by revoking access from each platform's third-party app settings.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you want to disconnect a social account from Reap, you need to remove Reap from the third-party app settings of that platform. This is done on the platform side, not just inside Reap.
Once you revoke access, Reap will no longer be able to schedule or publish content through that connected account.
## Step-By-Step Workflow
Go to the app permissions, connected apps, or business integrations area for the platform you want to disconnect.
Look for **Reap** in the list of apps or services that currently have access to your account.
Remove Reap from the list so it can no longer access your social account.
If you connected more than one account, repeat the same process for each platform you want to disconnect.
## Open The Platform Settings
Use the platform-specific settings links below to open the correct area and remove Reap.
* **Google / YouTube:** [Google Account third-party connections](https://myaccount.google.com/connections)
* **Instagram:** [Instagram manage access](https://www.instagram.com/accounts/manage_access/)
* **LinkedIn:** [LinkedIn permitted services settings](https://www.linkedin.com/mypreferences/d/data-sharing-for-permitted-services)
* **TikTok:** [TikTok connected third-party apps guide](https://support.tiktok.com/en/safety-hc/account-and-user-safety/connect-to-third-party-apps)
## Where To Remove Reap On Each Platform
* **Google / YouTube**
Open your Google Account third-party connections page, select **Reap**, then remove access.
* **Instagram**
Open the **Manage Access** page, find **Reap**, then remove its access from your account.
* **LinkedIn**
Open the **Permitted Services** page, find **Reap**, then remove it from the connected services list.
* **TikTok**
Open **Settings and privacy > Security & permissions > Apps and services permissions**, then remove Reap from the connected apps list.
## After You Disconnect
* Reap will stop being able to publish through that account.
* Scheduled posts that rely on the disconnected account may fail if they have not already been sent.
* If you want to use the account again later, reconnect it from Reap through **Connect Socials**.
# How to Edit Videos
Source: https://docs.reap.video/help-center/how-to-edit-videos
Use Reap's AI Editor to upload a video, open it in the editor, and make transcript-based edits before export.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's AI Editor lets you upload a video or paste a YouTube link, open it in the editor, and refine the result using transcript-based editing tools. Once the video is loaded, you can make quick edits, adjust captions, and enhance the final output with editor tools.
## Step-By-Step Workflow
Start by adding your source video from a supported link or a local upload.
Set the spoken language and the export resolution before opening the video in the editor.
Use **Submit** to process the video and open it inside the AI Editor.
Make your changes inside the editor, preview the result, and export when you are ready.
## 1. Add Your Source Video
* Paste a YouTube link into the input field, or upload a file from your device.
* Supported formats: `.mp4`, `.mov`, `.webm`, `.mkv`.
* Supported uploads start at `3 seconds` and go up to `10 minutes`.
* Maximum file size: `2 GB`.
## 2. Choose The Spoken Language
* Select the primary spoken language of the video before submitting it to the editor.
* This helps Reap process the transcript and editing tools more accurately.
## 3. Choose Resolution
Choose the resolution for the video.
* `720`
* `1080`
* `2K`
* `4K`
## 4. Submit The Video
* Click **Submit** to process the video and open it in the editor.
* After processing, the video becomes available for transcript-based and visual editing.
## 5. Edit With Transcript Tools
Inside the editor, you can select transcript text and apply editing actions directly from the context menu.
Common transcript actions include:
* `Set as start`
* `Set as end`
* `Correct word`
* `Highlight`
* `Add emoji`
* `Remove caption`
* `Remove video`
* `Cut`
## 6. Use The Editor Sidebar Tools
The editor also includes tools such as:
* `Brand` to apply your brand template to the video inside the editor.
* `Caption` to change caption presets.
* `AI Tools` for adding emoji, highlights, and voiceover.
* `Text` to add text to your video.
* `B-rolls` to add b-rolls in the video.
* `Assets` to add any asset such as audio, video, or image.
## 7. Export Your Edited Video
Once your edits are complete:
* Preview the final result.
* Export the edited video.
* Download or publish it when the export is ready.
# How to extend and add more content to AI-generated clips
Source: https://docs.reap.video/help-center/how-to-extend-and-add-more-content-to-ai-generated-clips
Extend AI-generated clips and add more content from inside the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use **Add Segment** in the editor when a clip ends too early or when you want to continue the speaker flow with more content.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Locate the **Add Segment** button where the clip cuts off or ends abruptly.
Use the popup to extend the sentence or segment and add more content as needed.
Make sure the speaker flow feels smooth, then export.
If you find yourself extending clips often, regenerate with a [clip prompt](/api-reference/create-clips#prompt) that targets longer-form moments — e.g. "give me clips that include the full setup and payoff of each story." It's the root-cause fix when the AI is consistently cutting too early.
# How to find and correct the words in captions?
Source: https://docs.reap.video/help-center/how-to-find-and-correct-the-words-in-captions
Correct words directly from the transcript options inside the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If a captioned word is incorrect, you can fix it directly from the transcript options inside the editor.
![Correct a word from transcript options]()
## Step-By-Step Workflow
Open the clip in the editor.
Click the word or transcript section you want to fix.
Use the transcript options and choose **Correct**.
Enter the corrected word and review the result in the preview.
# How to Generate a Transcript
Source: https://docs.reap.video/help-center/how-to-generate-a-transcript
Generate a transcript for your video, review it with timestamps, and export it in multiple formats.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap lets you generate a transcript of your video in one click. Add a YouTube link or upload a file, choose the language settings, generate the transcript, then review and export it in the format you need.
## Step-By-Step Workflow
Start by pasting a YouTube link or uploading a video from your device.
Select the spoken language, optional translation, and script mode before generating the transcript.
Click **Generate Transcript** to process the video and create the transcript.
Review the generated transcript, toggle timestamps if needed, and export it in the format you want.
## 1. Add Your Video
You can start the transcription workflow in two ways:
* Paste a **YouTube link**.
* Upload a video file from your device.
* Supported formats: `.mp4`, `.mov`.
* Supported uploads start at `3 seconds` and go up to `2 hours`.
* Maximum file size: `5 GB`.
## 2. Choose Language And Translation
* Select the primary **Language** spoken in the video.
* Optionally choose **Translate to** if you want the transcript translated.
If you do not need translation, leave **Translate to** set to `None`.
## 3. Choose Script Mode
Select how the script should be handled:
* `Native` for captions in the original script of the selected language.
* `Roman` for romanized captions, where the spoken language is written using Latin characters.
## 4. Generate The Transcript
* Click **Generate Transcript** after your video and language settings are ready.
* Reap will process the video and create the transcript automatically.
## 5. Review The Generated Transcript
After generation, you can review the transcript inside the transcript view.
* Read the transcript line by line.
* Review the transcript alongside the video preview.
* Turn **Timestamps** on or off depending on how you want to read the transcript.
## 6. Export The Transcript
You can export the generated transcript in multiple formats:
* `TXT`
* `SRT`
* `VTT`
* `CSV`
You can also download the extracted audio.
## Tips For Better Transcript Results
* Choose the correct source language for the most accurate transcript.
* Use timestamps when you need easier review and reference points.
* Export `SRT` or `VTT` when you need subtitle-ready files.
* Export `TXT` or `CSV` when you need the transcript for repurposing or analysis.
# How to Increase the Brightness
Source: https://docs.reap.video/help-center/how-to-increase-the-brightness-of-your-clip
Use the brightness slider in the video panel to adjust clip brightness segment by segment.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can increase the brightness of your clip from inside the editor. Select a segment, open the video panel, and use the brightness slider to adjust the look of the video.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open your clip in the editor by clicking the **Edit** button.
Click the segment on the timeline that you want to adjust.
When the segment is selected, the video panel opens on the right side of the editor.
Below the filter presets in the style settings, locate the brightness slider.
Use the slider to increase or decrease the brightness for that segment.
If you want to update the full clip, repeat the same process for each segment.
Preview the clip to make sure the brightness looks right. When you are satisfied, click **Export**.
# How to open the video panel in the editor
Source: https://docs.reap.video/help-center/how-to-open-the-video-panel-in-the-editor
Open the video panel in the editor to access clip-specific settings and adjustments.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The video panel gives you access to clip-specific settings in the editor. Open it from the timeline when you need to make video-level adjustments.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip.
Click on the timeline where the video images appear.
The video panel will open from the right side of the editor.
Use the panel to adjust the settings you need.
# How to Remove Captions from Your Clip
Source: https://docs.reap.video/help-center/how-to-remove-captions-from-your-clip
Turn captions off in the editor when you want to export a clip without on-screen subtitles.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you no longer want captions on a clip, you can remove them from the captions panel in the editor and preview the result before exporting.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Open your clip in the editor by clicking the **Edit** button.
On the right side panel, click the **Captions** option.
Toggle captions off to remove them from your clip.
Confirm in the preview that captions are no longer visible.
When satisfied, click **Export**.
# How to remove or trim unwanted parts from clips
Source: https://docs.reap.video/help-center/how-to-remove-or-trim-unwanted-parts-from-clips
Remove unwanted transcript sections and trim clips directly inside the Reap editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the editor to remove or trim unwanted parts from your clip by selecting text in the transcript and applying changes before export.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the edit button below the clip you want to refine.
Use the transcript to find the sentences or moments you do not want to keep.
Click and hold to select the unwanted words or transcript sections.
Review the clip, then export when the result looks right.
# Save Credits Using Time-frame Slider
Source: https://docs.reap.video/help-center/how-to-save-credits-using-time-frame-slider
Use the time-frame slider to process only the useful part of a video and avoid spending credits on sections you do not need.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The time-frame slider helps you save credits by limiting clipping to only the part of the video you want to process. Instead of using credits on the full upload, you can target only the section that contains the moments you want to turn into clips.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Start the clipping workflow with your source video.
Use the time-frame slider in the clip setup screen.
Narrow the range to the part of the video that contains the moments you want clipped.
Continue clipping with only that time window selected.
## Example
If you upload a `1-hour` video but only the first `10 minutes` are useful for clipping:
* select only those first `10 minutes`
* generate clips from that range
* spend credits on `10 minutes` instead of the full `1 hour`
## Why It Helps
* avoids spending credits on dull or irrelevant sections
* improves efficiency when only part of a video is clip-worthy
* gives you more control over how credits are used
Combine the time-frame slider with a [clip prompt](/api-reference/create-clips#prompt) when you want fewer, more focused clips from the chosen window — the slider narrows the source, the prompt narrows the editorial.
# Schedule or Publish Your Content
Source: https://docs.reap.video/help-center/how-to-schedule-or-publish-your-content
Schedule posts in advance or publish content immediately from the calendar or a project in Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can schedule or publish content directly from the calendar or from any project in Reap. This gives you flexibility to plan posts ahead of time or send content live right away.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Start from the **Calendar** if you want to manage your content timeline, or open a project if you want to publish directly from there.
Add the content you want to post.
Add a social caption, choose the platform, then select the date and time.
Click **Schedule** to post later, or click **Publish Now** to post immediately.
## 1. Open The Calendar Or Project
* Use the **Calendar** to view and manage your content schedule.
* You can also publish content you have already created directly from a project.
## 2. Add The Content You Want To Share
* Upload the content you want to schedule or publish.
* Make sure you are working with the correct clip or final asset before moving on.
## 3. Write The Social Caption
* Add the caption you want to publish alongside the content.
* Tailor the caption to the platform and audience you are posting for.
## 4. Choose The Platform
* Select the connected social platform where the content should be posted.
* If you have more than one connected account, choose the correct destination before scheduling.
## 5. Set The Date And Time
* Click the day you want to publish on.
* Enter the time you want the content to go live.
## 6. Schedule Or Publish
* Click **Schedule** to publish automatically at the selected time.
* Click **Publish Now** if you want to share the content immediately.
You can use this flow from the calendar or directly from a project, so choose whichever entry point fits your workflow best.
# How to set caption timing with the timing sidebar
Source: https://docs.reap.video/help-center/how-to-set-caption-timing-with-the-timing-sidebar
Adjust caption timing with frame-level precision using the Timing Sidebar in the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
By default, Reap aligns captions automatically. When you need more control, the **Timing Sidebar** lets you manually adjust when captions appear and disappear.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Select a clip with captions and click the edit button below the clip. In the right panel with the transcription box, click **Timing Sidebar**.
Each caption line includes a start handle and an end handle. The highlighted bars show exactly when a caption is visible.
Drag the handles left or right to change start and end times. Use frame-level precision when you need more exact timing.
Press **Play** in the preview window and watch for captions that appear too early, too late, or cut off mid-sentence.
Use `Ctrl+Z` / `Cmd+Z` or the editor undo/redo buttons to reverse a timing change. Refresh the editor if you want to reset a caption back to Reap's default timing.
## Troubleshooting
* If changes do not save, make sure you click **Apply** before leaving the editor.
* If captions look out of sync after export, reopen the project and test the timing again.
* If the sidebar is not visible, refresh the editor and confirm captions are already generated.
# How to use AI Dubbing
Source: https://docs.reap.video/help-center/how-to-use-the-dubbing-feature
Translate and dub your video's audio into other languages with AI-generated voice output.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's dubbing feature helps you translate and dub your video's audio into other languages while keeping the result polished and ready for sharing. It works well alongside Reap's clipping, captioning, and formatting tools, so you can create multilingual content without a manual voiceover workflow.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Why Use AI Dubbing
* Reach more viewers in their native language.
* Save time compared with manual translation and recording.
* Create high-quality AI voiceovers for multilingual content.
* Combine dubbing with captions, clipping, and aspect-ratio formatting.
## Step-By-Step Workflow
Start by uploading the long-form video you want to dub.
Select the original language of the video, then choose the language you want to dub it into.
Start the dubbing process and wait for Reap to prepare the translated voice output.
Review the result, then export and share the dubbed video on your target platforms.
## 1. Upload Your Video
* Upload the video you want to dub into Reap.
* Supported format: `.mp4`.
* Supported uploads start at `3 seconds` and go up to `10 minutes`.
* Maximum file size: `2 GB`.
* Start with the original long-form source so the dubbing workflow has the full audio context.
## 2. Choose Your Languages
* Select the original language spoken in the source video.
* Select the target language for the dubbed output.
Choose the target language based on the audience you want to reach most directly.
## 3. Generate The Dubbed Video
* Start the dubbing workflow after your languages are selected.
* Reap will translate the audio and generate the dubbed voice output automatically.
## 4. Review, Download, And Share
* Review the dubbed result before publishing.
* Download the final video when you are satisfied.
* Share the dubbed content across platforms like Instagram, TikTok, YouTube Shorts, or LinkedIn.
## Tips For Better Dubbing Results
* Match the dubbed language to your target audience.
* Pair dubbing with captions to improve accessibility and comprehension.
* Test regional language variants when they better match your viewers.
* Adjust the aspect ratio for the platforms where the dubbed content will be posted.
* Preview the final result to make sure the tone and pacing feel right.
# How to Use Auto Reframing
Source: https://docs.reap.video/help-center/how-to-use-the-reframing-feature
Automatically reframe landscape videos into portrait or square layouts optimized for social media.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's reframing feature uses AI to automatically adjust your video's composition for social-first aspect ratios without cutting off important faces, text, or visuals. It helps you turn landscape videos into platform-ready content faster, while keeping the most important elements in frame.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Why Use Auto Reframing
* Convert landscape videos into social-ready formats automatically.
* Keep faces, text, and key visuals in frame.
* Save time compared with manual reframing.
* Combine reframing with clipping, captions, and dubbing workflows.
## Supported Aspect Ratios
Reap's reframing workflow supports these formats:
* `Portrait (9:16)` for Instagram Reels, TikTok, and YouTube Shorts
* `Square (1:1)` for Instagram posts, Facebook, and LinkedIn
## Step-By-Step Workflow
Start by uploading the landscape video you want to reframe.
Select the aspect ratio that best fits the platform you are targeting.
Preview the reframed output to make sure important elements stay in focus.
Export the reframed video when you are satisfied and use it in your content workflow.
## 1. Upload Your Video
* Upload the landscape video you want to reframe.
* Supported formats: `.mp4`, `.mov`, `.webm`.
* Supported uploads start at `3 seconds` and go up to `10 minutes`.
* Maximum file size: `2 GB`.
## 2. Choose Orientation
Select the output format that best matches your destination platform.
* `Portrait (9:16)` for mobile-first short-form content
* `Square (1:1)` for balanced feed content across social platforms
Choose orientation based on where the content will be published first. That usually makes the reframed result feel more native on the target platform.
## 3. Review AI Adjustments
* Let Reap automatically reframe the video.
* Preview the result to confirm that speakers, text, logos, and other important content stay visible.
* Make sure the framing still feels natural before exporting.
## 4. Manually Adjust The Framing When Needed
* Open the clip in the editor if you want more precise control.
* Choose the layout for your video segment, then click the video on the timeline.
* Move the clip on the canvas to fine-tune the framing before export.
If you manually move, crop, or resize the framing, Reap keeps your manual changes and does not override them.
## 5. Combine With Other Tools
Reframing works well with other Reap workflows:
* Add captions for better accessibility and engagement.
* Pair it with clipping for social-ready short videos.
* Use dubbing to create multilingual, platform-optimized content.
## 6. Download And Share
* Export the reframed video when you are satisfied.
* Download it or continue using it in your wider publishing workflow.
## Tips For Better Reframing Results
* Use `Portrait (9:16)` for TikTok, Instagram Reels, and YouTube Shorts.
* Use `Square (1:1)` for LinkedIn and feed-style posts.
* Always preview the AI output before publishing.
* Test multiple layouts when you want to compare which one performs better.
# Invite Members To Your Studio
Source: https://docs.reap.video/help-center/invite-members-to-your-workspace
Invite teammates into your current studio from the studio button or from Manage studio in Settings.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can invite someone into your studio directly from the studio button on the top left corner. You can also invite members from **Settings** by opening **Manage studio**.
## Step-By-Step Workflow
Click the studio button on the top left corner of the app, then choose **Invite members**.
Add the email address of the person you want to invite.
Click **Invite member** to send the invitation.
Once the invited person accepts, they can join the studio from their account.
You can also go to **Settings**, open **Manage studio**, add the member email there, and click **Invite member**.
## Notes
* Use the studio where you want the new member to be added before sending the invite.
* This page documents the current UI flow shown in Reap.
# Manually adjust the framing to make it more precise
Source: https://docs.reap.video/help-center/manually-adjust-the-framing-to-make-it-more-precise
Adjust the framing manually from inside the editor when the automatic framing needs a more precise result.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If automatic framing is close but not perfect, you can manually adjust the framing inside the editor and position the shot exactly where you want it.
This page includes a product walkthrough video, followed by the same workflow as written steps below.
## Step-By-Step Workflow
Click the **Edit** button to open your clip in the editor.
Select the layout that best fits your segment before making manual framing adjustments.
Click the video on the timeline, then move the clip on the canvas to adjust the framing more precisely.
Preview your changes and, when you are satisfied, click **Export**. Your updated clip will be ready to download after export is completed.
# My video has screen sharing and it's not framed correctly
Source: https://docs.reap.video/help-center/my-video-has-screen-sharing-and-its-not-framed-correctly
Use presentation mode for videos with screen sharing so Reap can detect and frame shared content more accurately.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If your video includes screen sharing and the framing looks off, use **Presentation** mode when generating clips. Reap will automatically detect shared screens and include them in the generated clips.
![Presentation mode selected for screen-sharing videos]()
## Recommended Workflow
Upload your video or paste your link into Reap to begin clip generation.
Select **Presentation** as the video type when your content includes slides, demos, or screen sharing.
Reap will detect the shared screen and include it in the output. Review the result and continue editing if needed.
## What To Know
* Presentation mode is designed for videos that include screen sharing.
* It helps Reap include the shared screen as part of the final clip instead of focusing only on the speaker.
* If you still want finer control, continue with layout and manual framing adjustments in the editor.
# Posting Limits & Best Practices
Source: https://docs.reap.video/help-center/posting-limits-and-best-practices
Learn recommended posting volume, timing guidelines, and platform limits for scheduling content from Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Posting at the right time and following platform best practices is one of the easiest ways to improve consistency, avoid publishing issues, and get better reach from your content.
With Reap, you can connect your social accounts, prepare clips, and schedule content ahead of time from one place. To get the best results, it helps to follow a few timing and posting guidelines before you publish.
## Timing Is Everything
Posting when your audience is online gives your content a better chance of getting early engagement.
As a general rule, strong posting windows are usually:
* Morning
* Lunch time
* Evening
These are common periods when users are more active across short-form platforms. The exact best time depends on your audience, location, and platform, so it is a good idea to test a few time slots and stay consistent with the ones that perform best.
## Recommended Posting Limits By Platform
| Platform | Recommended daily posting volume | Recommended rate limit | Caption or content limits |
| --------------- | -------------------------------- | ------------------------------- | ----------------------------------------------------------------------- |
| TikTok | `5-10` videos per day | `1` video every `20-30` minutes | Captions up to `2,200` characters |
| Instagram Reels | `3-7` videos per day | `1` video every `20-30` minutes | Captions up to `2,200` characters |
| YouTube Shorts | `2-5` videos per day | `1` video every `30` minutes | Titles up to `100` characters and descriptions up to `5,000` characters |
| LinkedIn | `1-3` videos per day | `1` video every `2-3` hours | Captions up to `3,000` characters |
These posting ranges are recommended best practices, not guaranteed platform allowances.
Platform-side rules, account health, permissions, and media validation can still affect whether a post succeeds.
## General Best Practices
* Start with lower posting volume on new or inactive accounts.
* Avoid scheduling too many posts too close together.
* Keep captions platform-appropriate and within the supported character limits.
* Reconnect social accounts if publishing permissions expire.
* Export important clips before the scheduled posting time whenever possible.
## Important Note
If a scheduled clip has not finished exporting before the scheduled time, the post may fail.
## Before You Post From Reap
Before scheduling or publishing through Reap, make sure:
* Your social account is connected.
* Your clip is ready for publishing.
* Your caption fits the platform.
* Your scheduled time gives enough room for export if the clip has not been exported yet.
You can connect social accounts from **Settings** > **Connect Socials** and schedule or publish directly from the **Calendar** or from a project.
If a clip has not been exported yet, Reap can still schedule it, but the export must finish before the scheduled posting time. Reap currently uses a built-in buffer for scheduled unexported clips to help them process in time.
# Project Expiry
Source: https://docs.reap.video/help-center/project-expiry
How long your projects remain available in Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Project Expiry defines how long your projects remain available based on your plan. Each project expires after a fixed number of days from the day it’s created. Expiry is time-based, so editing or using a project does not extend it.
## How Project Expiry Works
When you create a project:
1. Reap assigns an expiry duration based on your plan.
2. Your project stays available until it reaches its expiry date.
3. After that date, the project becomes **Expired**.
**Example:** A project created on the **Creator** plan expires **60 days** after creation.
## Plan Expiry Timelines
| Plan | Project expires after |
| ------- | --------------------- |
| Trial | 7 days |
| Free | 7 days |
| Creator | 60 days |
| Studio | 120 days |
## How It Appears In The App
You’ll see one of these statuses on your projects:
* **Expires in X days**: the project is still available.
* **Expired**: the project has reached its expiry date.
## Scheduling Posts And Expiry
You can schedule posts even if the publish date is after your project expires.
* Scheduled posts are saved at the time you schedule them.
* Expiry does not cancel scheduled posts.
**Example:** If a project expires in 10 days, you can still schedule a post for a later date and it will still publish.
## FAQs
**Does editing extend expiry?**\
No. Expiry depends only on project creation date and plan duration.
**Will scheduled posts stop after expiry?**\
No. Scheduled posts remain queued because they are saved at scheduling time.
# Publish & Schedule Clips With MCP
Source: https://docs.reap.video/help-center/publish-and-schedule-with-reap-mcp
Post or schedule clips to YouTube, TikTok, Instagram, LinkedIn, and X by asking your AI agent through Reap MCP — with confirmation before anything goes public.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can publish a clip immediately or schedule clips for later, posting to your connected social accounts: YouTube, TikTok, Instagram, LinkedIn, and X.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Connect your social accounts in Reap first. See [Connect Social Media Accounts](/help-center/how-to-connect-social-media-accounts).
## Check Connected Accounts
```text theme={"system"}
Which social accounts do I have connected in Reap?
```
## Publish A Clip Now
```text theme={"system"}
Publish the best clip from that project to my YouTube and TikTok.
```
You can also set a title, description, and hashtags:
```text theme={"system"}
Post clip 1 to TikTok with the caption "The pricing mistake founders make" and tag it #startups #pricing.
```
## Schedule Clips For Later
```text theme={"system"}
Schedule these three clips to LinkedIn, one per day starting tomorrow at 9am.
```
Your agent spaces out the posts and sets the schedule for you.
## Platform Options
Describe platform-specific settings in plain language and your agent applies them — for example:
* **YouTube** — privacy (public / unlisted / private), made-for-kids, embeddable.
* **TikTok** — privacy, disable comments / duet / stitch.
* **Instagram** — share to feed.
* **LinkedIn** — visibility (public / connections).
```text theme={"system"}
Publish to YouTube as unlisted and to TikTok with comments disabled.
```
## Manage Scheduled Posts
```text theme={"system"}
Show me my scheduled and published posts.
```
```text theme={"system"}
Reschedule that LinkedIn post to Friday at noon.
```
Publishing and scheduling post **publicly** to your social accounts. These actions always require explicit confirmation — your agent shows you exactly what it's about to post and asks before doing anything.
## Related
* [Connect Social Media Accounts](/help-center/how-to-connect-social-media-accounts)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Create Clips With Reap MCP](/help-center/create-clips-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Reap Credit System
Source: https://docs.reap.video/help-center/reap-credit-system-complete-guide
Learn how media credits and AI credits work across clipping, captions, reframing, dubbing, and editor processing.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap uses a dual-credit system so you can use credits across projects and features more flexibly. Instead of locking minutes to one project, credits can be used wherever you need them most.
This guide covers:
* what media credits are
* what AI credits are
* how credits are consumed by different features
* real usage examples
## 1. Credit Types In Reap
### Media Credits
Media Credits are a shared pool measured in minutes.
You can use them for:
* `Clipping`
* `Captions`
* `Reframing`
* `Transcription`
* `Audiogram`
* `Editor processing`
### AI Credits
AI Credits are tracked separately for more AI-intensive features:
* `AI Voiceovers (Text-to-Speech)`
* `Multilingual Dubbing`
* `Emoji Highlighter (inside the editor)`
## 2. How Media Credits Are Consumed
| Feature | Credit usage |
| ------------------- | ---------------------------- |
| `Clipping` | `1 minute = 1 Media Credit` |
| `Captions` | `1 minute = 1 Media Credit` |
| `Reframing` | `1 minute = 2 Media Credits` |
| `Editor Processing` | `1 minute = 2 Media Credits` |
## 3. How AI Credits Are Consumed
| Feature | Credit usage |
| ---------------------- | ---------------------------- |
| `AI Voiceover (TTS)` | `1 generation = 1 AI Credit` |
| `Multilingual Dubbing` | `2 minutes = 1 AI Credit` |
## 4. Real Usage Examples
### Clipping
A `10-minute` clip uses:
* `10 × 1 = 10 Media Credits`
### Captions
A `5-minute` video uses:
* `5 × 1 = 5 Media Credits`
### Reframing
A `12-minute` video uses:
* `12 × 2 = 24 Media Credits`
### Dubbing
A `10-minute` clip uses:
* `10 × 0.5 = 5 AI Credits`
## 5. Why This System Is More Flexible
* credits are not stuck on one project
* you can use them on any project
* you can focus more credits on high-priority work
* you avoid leaving unused minutes behind in older projects
If you want to reduce media-credit usage while clipping, use the time-frame slider to process only the section of the video you actually need.
# Reap MCP Guide
Source: https://docs.reap.video/help-center/reap-mcp-guide
Get the most out of Reap MCP — use your brand templates, caption styles, and the full clip-to-publish workflow straight from your AI agent.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
When you connect Reap MCP to your AI agent, you can run your entire video workflow in plain language — clip, caption, reframe, dub, transcribe, and publish — without leaving your chat. This guide is a set of tips for getting better results, including how to use your own brand templates when creating clips through MCP.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples below use Claude, but the same prompts work in any MCP-compatible agent.
Reap MCP requires a paid plan with API access enabled. To confirm the connection is live, ask your agent: *"What Reap tools do you have access to?"*
## Step-By-Step Guides
Each task has its own walkthrough with sample prompts:
Turn a URL or upload into short, social-ready clips.
Animated captions in 100+ languages, with translation.
Auto-crop to 9:16 or 1:1 with face tracking.
Voice-dub into 80+ languages with AI voice matching.
Timestamped transcript with speaker labels.
Apply your logo, intro/outro, music, and caption style.
Post or schedule clips to your social accounts.
Check status, find projects, get clip links.
## Use Your Brand Templates In Clips
This is the tip most people miss. A **brand template** in Reap can carry your logo, intro and outro, background music, and a customized caption style — and your agent can apply it automatically when it generates clips.
Build it once in the dashboard: [Create Brand Template](https://app.reap.video/branding/caption-styles). Add your logo, intro/outro, background music, and caption styling. See [Brand templates](/help-center/caption-presets-are-now-brand-templates) for details.
> List my Reap brand templates.
Your agent lists your saved presets so you can pick the one you want.
> Clip this video and use my "Podcast Brand" template: `https://youtube.com/watch?v=...`
Your agent passes the template to the clipping job, so every clip comes out on-brand.
This works for captioning too: *"Add captions to this video using my brand template."* Your branded caption style is applied instead of the default. Full walkthrough: [Use Brand Templates With MCP](/help-center/use-brand-templates-with-reap-mcp).
## Pick A Caption Style On The Fly
If you don't have a saved template, you can still choose from Reap's built-in caption styles (Karaoke, Bold, Minimal, and 50+ more):
```text theme={"system"}
Show me the available caption styles, then clip this video using the Karaoke style.
```
Your agent looks up the styles, describes how each one looks, and applies your pick.
## Let Reap Pick The Moments — Then Get Specific Only When Needed
For broad requests, don't over-direct. Reap's auto-selection finds strong moments better when you keep it simple:
```text theme={"system"}
Clip the best moments from this video and keep them under 60 seconds.
```
Add detailed direction only when you have a clear editorial goal — specific topics, counts, ordering, or a mix of lengths:
```text theme={"system"}
Give me three sub-30s hooks about pricing, two 60-90s clips on the demo, and skip the intro.
```
A single clipping job returns **many** clips — there's no need to ask for several separate projects from the same video. Full walkthrough: [Create Clips With MCP](/help-center/create-clips-with-reap-mcp).
## Just Name The Language — Your Agent Handles The Codes
You don't need to know Reap's language codes. Say the language in plain words and your agent looks up the right code:
```text theme={"system"}
Add captions and translate them into Spanish.
```
```text theme={"system"}
Dub this video from English into Hindi.
```
This applies to clipping, captions, dubbing, and transcription.
## Reframe And Dub Work From An Upload
Reframing and dubbing run on a video uploaded to Reap, not a public URL. Just ask your agent to upload first:
```text theme={"system"}
Upload ~/Videos/panel.mov, then reframe it to vertical 9:16 with the speaker centered.
```
```text theme={"system"}
Upload ~/Videos/launch.mp4 and dub it from English into Spanish.
```
For clipping, captions, and transcription you can use either a public URL (like YouTube) or an upload. Full walkthroughs: [Reframe Videos With MCP](/help-center/reframe-videos-with-reap-mcp) and [Dub Videos With MCP](/help-center/dub-videos-with-reap-mcp).
## Find And Reuse Past Work
Your agent can search your workspace, so you don't have to dig through the dashboard:
```text theme={"system"}
Show me my clipping projects from the last week.
```
```text theme={"system"}
Find my project called "Founder interview" and get its finished clips.
```
```text theme={"system"}
Which of my recent jobs are still processing?
```
More on this: [Track & Download Results With MCP](/help-center/track-and-download-results-with-reap-mcp).
## Polish Clips Before You Publish
You can tweak a clip's title or caption text through your agent before it goes out:
```text theme={"system"}
Rename clip 2 to "The pricing mistake" and update its caption to match.
```
## Publish Or Schedule — Safely
Once clips are ready, post them to your connected social accounts (YouTube, TikTok, Instagram, LinkedIn, X):
```text theme={"system"}
Which social accounts do I have connected in Reap?
```
```text theme={"system"}
Publish the best clip to my YouTube and TikTok.
```
```text theme={"system"}
Schedule these three clips to LinkedIn, one per day starting tomorrow at 9am.
```
You can also set platform-specific options — for example, YouTube privacy (public/unlisted/private) or TikTok comment settings — just by describing them. Full walkthrough: [Publish & Schedule Clips With MCP](/help-center/publish-and-schedule-with-reap-mcp).
Publishing and scheduling post publicly to your social accounts. These actions always require explicit confirmation — your agent shows you exactly what it's about to post and asks before doing anything.
## Track Long Jobs Without Babysitting
Reap jobs run asynchronously. You'll get an email when a job finishes, and your agent can check progress on demand:
```text theme={"system"}
What's the status of that clipping job, and how long until it's done?
```
When clips are ready, your agent returns each one as a link you can open in Reap or download directly.
## A Few Prompts To Start With
```text theme={"system"}
Clip this podcast into portrait clips with my brand template:
```
```text theme={"system"}
Add Spanish captions to this video and tell me when it's done.
```
```text theme={"system"}
Reframe my last upload to vertical and publish the result to TikTok.
```
## Troubleshooting
* **No Reap tools available?** Make sure the Reap connector is enabled for the conversation, then reconnect or restart your AI tool.
* **Template not found?** Confirm the brand template is saved in your workspace and you authorized that same workspace during sign-in.
* **Publishing fails?** Check that your social accounts are connected in Reap.
* **Wrong workspace?** Your agent only has access to the workspace you authorized. Reconnect and pick the correct one if needed.
## Learn More
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [Add Captions & Translate With MCP](/help-center/add-captions-with-reap-mcp)
* [Transcribe Videos With MCP](/help-center/transcribe-videos-with-reap-mcp)
* [Brand templates](/help-center/caption-presets-are-now-brand-templates)
* [MCP API Reference](/api-reference/mcp)
* [Connect Social Media Accounts](/help-center/how-to-connect-social-media-accounts)
* [Reap Dashboard](https://app.reap.video)
# Reap Zapier Integration
Source: https://docs.reap.video/help-center/reap-zapier-integration
Connect Reap to 8,000+ apps with Zapier — automatically create clips, captions, transcriptions, dubbing, and reframes, then track projects, all without writing code.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
Reap's Zapier integration helps you connect Reap with the tools your team already uses. You can automatically send video links, uploaded files, form responses, spreadsheet rows, RSS items, and other content into Reap, then use Reap actions to create clips, captions, transcriptions, dubbing projects, reframes, and project lookups.
## What You Can Do With Reap and Zapier
With Reap on Zapier, you can build automated workflows such as:
* Create Reap clips when a new file is added to Google Drive or Dropbox.
* Create Reap clips from new YouTube playlist videos.
* Create Reap clips from new RSS feed items.
* Create Reap clips from new Airtable records, Google Sheets rows, or form responses.
* Add captions to a video URL automatically.
* Create transcriptions from new video links.
* Create dubbing projects from uploaded videos.
* Reframe uploaded videos for vertical or square formats.
* Look up a Reap project's status, details, or generated clips.
## Before You Start
You will need:
* A Reap account.
* A Reap API key.
* A Zapier account.
* At least one source app connected to Zapier, such as Google Drive, YouTube, Google Sheets, Airtable, Dropbox, RSS by Zapier, or Google Forms.
The Zapier integration requires a paid Reap plan with API access enabled. You can generate your Reap API key from the [Reap Dashboard](https://app.reap.video).
## How to Connect Reap to Zapier
Go to Zapier and create a new Zap.
Search for `reap` as the app, then choose the Reap trigger or action you want to use.
When Zapier asks you to connect Reap, paste your Reap API key.
Give the connection a clear name, such as `Reap production account`, then click Continue and test the connection.
If the connection succeeds, Zapier can now use your Reap account in Zaps.
## Available Reap Triggers
### New Project
Triggers when a new project is created in Reap.
Use this when you want another app to react after a Reap project exists, such as sending a Slack message, adding a row to Google Sheets, or logging the project in Airtable.
### New Upload
Triggers when a new upload is created in your Reap studio.
Use this when you want to track uploaded videos or start follow-up workflows after a video enters Reap.
## Available Reap Actions
### Create Clips
Creates AI-powered short clips from a video URL or uploaded video in Reap.
Common use cases:
* Turn new YouTube videos into short clips.
* Create clips from videos submitted through a form.
* Create clips when a new video file appears in Google Drive or Dropbox.
### Create Captions
Adds AI-generated captions to a video URL in Reap.
Common use cases:
* Automatically caption new videos before publishing.
* Create captioned versions of campaign videos.
### Create Transcription
Creates an AI-generated transcription from a video URL in Reap.
Common use cases:
* Send meeting recordings to Reap for transcription.
* Create text from webinars, podcasts, or interviews.
### Create Dubbing
Creates an AI-generated dubbed version of an uploaded video in Reap.
Common use cases:
* Localize uploaded videos into another language.
* Create multilingual versions of training or marketing content.
### Create Reframe
Automatically reframes an uploaded Reap video for portrait or square output.
Common use cases:
* Turn landscape videos into vertical social clips.
* Prepare content for TikTok, Instagram Reels, YouTube Shorts, or LinkedIn.
### Get Project Status
Finds the current processing status for a Reap project.
Common use cases:
* Check whether a project is completed before running the next step.
* Update a CRM, spreadsheet, or database with the current project status.
### Get Project Details
Finds details for a Reap project.
Common use cases:
* Pull metadata about a Reap project into another app.
* Look up project information before sending a notification.
### Get Project Clips
Finds the clips generated for a Reap project.
Common use cases:
* Send generated clip links to Slack or email.
* Add generated clips to a spreadsheet, database, or content tracker.
## Example Zap: Create Reap Clips From a New Google Drive Video
Use this Zap when your team uploads videos to Google Drive and wants Reap to automatically create clips.
Trigger app: **Google Drive**. Trigger event: **New File in Folder**. Choose the folder where your videos are uploaded.
Action app: **Reap**. Action event: **Create Clips**. Connect your Reap account.
Map the Google Drive file or public file URL into the Reap video URL field, then configure the clip options.
Test the Zap, then publish it.
After publishing, every new matching Google Drive video can be sent to Reap automatically.
## Example Zap: Track New Reap Projects in Google Sheets
Use this Zap when you want a simple log of new Reap projects.
1. Trigger app: Reap.
2. Trigger event: New Project.
3. Connect your Reap account.
4. Test the trigger and select a sample project.
5. Action app: Google Sheets.
6. Action event: Create Spreadsheet Row.
7. Map Reap fields such as project ID, project type, source, and status.
8. Test the row creation.
9. Publish the Zap.
## Example Zap: Check a Reap Project Status
Use this Zap when you have a Reap project ID and want to check whether processing is complete.
1. Add Reap as an action step.
2. Choose Get Project Status.
3. Select your connected Reap account.
4. Enter or map the Reap Project ID.
5. Test the step.
If successful, Zapier returns fields such as project ID, project type, source, and status.
## Tips for Best Results
* Use direct video URLs when possible.
* Make sure files from cloud storage apps are accessible to Zapier and Reap.
* Keep your Reap API key private.
* Use clear Zap names, such as `Create Reap Clips from New Drive Videos`.
* Test each Zap before publishing.
* For multi-step workflows, use Get Project Status before sending completed outputs to another app.
## Troubleshooting
### Zapier says the Reap account needs to reconnect
Reconnect the account and paste a valid Reap API key. If the key was rotated or deleted, generate a new key in Reap and reconnect.
### The Zap test says the API key is invalid
Check that you copied the full Reap API key and did not include extra spaces. Reconnect the Reap account in Zapier after updating the key.
### Create Clips is not working with a file URL
Make sure the file URL is accessible. If the video is stored in Google Drive, Dropbox, or another file app, confirm that Zapier is passing a usable file link.
### A project is still processing
Use Get Project Status to check the project status. If it is not completed yet, wait and try again later.
### I do not see generated clips yet
Use Get Project Clips after the Reap project has completed. If the project is still processing, clips may not be available yet.
## Frequently Asked Questions
Yes. Each user needs a Reap account and a valid Reap API key.
Yes. Zapier can connect Reap with thousands of apps, including Google Drive, YouTube, Airtable, Google Sheets, Google Forms, Dropbox, RSS by Zapier, Slack, and more.
Yes. Use the Create Clips action in Reap. Pair it with a trigger such as new Google Drive file, new Dropbox file, new YouTube playlist video, new RSS item, or new form response.
Yes. Use the Get Project Status action with the Reap project ID.
Yes. Use the Get Project Clips action with the Reap project ID.
## Summary
The Reap Zapier integration lets you automate video workflows without writing code. You can send content into Reap from your favorite apps, create clips, captions, transcriptions, dubbing projects, and reframes, then use Reap project lookup actions to track progress and retrieve results.
# Reframe Videos With MCP
Source: https://docs.reap.video/help-center/reframe-videos-with-reap-mcp
Auto-crop landscape video to portrait (9:16) or square (1:1) with face tracking by asking your AI agent through Reap MCP.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can reframe a video to a social-friendly aspect ratio — portrait (9:16) or square (1:1) — using auto-tracking that keeps the active speaker centered.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Reframing runs on a video **uploaded** to Reap — a public URL is not supported for reframe. Ask your agent to upload the file first.
## Reframe An Upload
```text theme={"system"}
Upload ~/Videos/panel.mov, then reframe it to vertical 9:16 with the speaker centered.
```
```text theme={"system"}
Reframe my last upload to square.
```
## Options You Can Ask For
* **Orientation** — portrait (9:16, default) or square (1:1).
* **Face tracking** — keep the active speaker centered (on by default), or ask for a fixed crop instead.
* **Auto-split** — Reap can split scenes automatically; ask to keep the video as one piece if you prefer.
```text theme={"system"}
Reframe my last upload to portrait, fixed crop, and keep it as one piece.
```
## How Your Agent Handles It
Reframe needs an upload, so your agent uploads your `.mp4` or `.mov` first if it isn't already in Reap.
Your agent shows the planned orientation and face-tracking choice, then asks you to confirm.
Reframing runs asynchronously — ask for status anytime, and you'll get an email when it completes.
## Related
* [Create Clips With Reap MCP](/help-center/create-clips-with-reap-mcp)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Social Media Publishing
Source: https://docs.reap.video/help-center/social-media-publishing
Connect your social accounts, schedule posts, and publish content directly from Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap's social publishing tools help you connect your platforms, plan content in advance, and publish clips directly from your workflow. Once your accounts are connected, you can move from finished content to scheduled or live publishing without leaving Reap.
## What You Can Do
* Connect multiple social media accounts.
* Schedule content from the calendar or from a project.
* Bulk schedule multiple clips from one video.
* Publish exported clips directly to connected platforms.
* Queue un exported clips for scheduled publishing.
## Publishing Guides
See supported platforms and learn that you can connect multiple accounts.
Link your social accounts so Reap can schedule and publish content for you.
Use the calendar or a project to schedule posts or publish content.
Schedule multiple clips from the same video in one flow.
Review recommended posting volume, timing windows, and caption limits by platform.
Understand why publishing is blocked until an export is ready.
Remove Reap from connected accounts through each platform's third-party app settings.
## Before You Publish
* Make sure the correct social accounts are connected.
* Reap supports `YouTube`, `Instagram`, `TikTok`, and `LinkedIn`.
* You can connect multiple accounts when you need to publish across more than one destination.
* Double-check your caption, platform, date, and time before scheduling.
* Export clips first if you want to publish them immediately.
Scheduling is more flexible than direct publishing. You can schedule content ahead of time, but direct publishing still requires a finished export.
# Subscribe for one month
Source: https://docs.reap.video/help-center/subscribe-for-one-month
Use a monthly plan and cancel before renewal.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you only need Reap for one month, choose a monthly plan and cancel before the next billing cycle so you are not charged for another month.
## What To Know
* Monthly plans renew automatically unless you cancel.
* Canceling before the next billing cycle prevents another charge.
# Subscriptions
Source: https://docs.reap.video/help-center/subscriptions
Manage your plan, billing, and subscription settings in Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the guides below to update your plan, cancel a subscription, or manage billing details.
## Subscription Guides
Change your plan from the billing page or settings.
Stop your subscription from the billing page.
Choose monthly billing and cancel before renewal.
Buy extra media credits as a one-time purchase.
Buy additional plan packs from the billing flow.
Add or update the payment method on your account.
# Supported Languages
Source: https://docs.reap.video/help-center/supported-languages
See language support for captions, translation, and AI dubbing in Reap.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap supports a wide range of languages across captions, translation, and AI dubbing. The available language list can vary over time as new languages and regional variants are added.
## Language Support At A Glance
Reap supports:
* `100+ languages` for captions
* `100+ languages` for translation
* `80+ languages` for AI dubbing
These counts were verified against Reap's live API and may change as language support expands.
## Supported Languages For Captions
Reap supports `100+ languages` for captions.
Captions support these languages:
`Afrikaans`, `Amharic`, `Arabic`, `Assamese`, `Azerbaijani`, `Bashkir`, `Belarusian`, `Bulgarian`, `Bengali`, `Tibetan`, `Breton`, `Bosnian`, `Catalan`, `Czech`, `Welsh`, `Danish`, `German`, `Greek`, `English`, `Spanish`, `Estonian`, `Basque`, `Persian`, `Finnish`, `Faroese`, `French`, `Galician`, `Gujarati`, `Hausa`, `Hawaiian`, `Hebrew`, `Hindi`, `Croatian`, `Haitian Creole`, `Hungarian`, `Armenian`, `Indonesian`, `Icelandic`, `Italian`, `Japanese`, `Javanese`, `Georgian`, `Kazakh`, `Khmer`, `Kannada`, `Korean`, `Latin`, `Luxembourgish`, `Lingala`, `Lao`, `Lithuanian`, `Latvian`, `Malagasy`, `Maori`, `Macedonian`, `Malayalam`, `Mongolian`, `Marathi`, `Malay`, `Maltese`, `Myanmar`, `Nepali`, `Dutch`, `Nynorsk`, `Norwegian`, `Occitan`, `Punjabi`, `Polish`, `Pashto`, `Portuguese`, `Romanian`, `Russian`, `Sanskrit`, `Sindhi`, `Sinhala`, `Slovak`, `Slovenian`, `Shona`, `Somali`, `Albanian`, `Serbian`, `Sundanese`, `Swedish`, `Swahili`, `Tamil`, `Telugu`, `Tajik`, `Thai`, `Turkmen`, `Tagalog`, `Turkish`, `Tatar`, `Ukrainian`, `Urdu`, `Uzbek`, `Vietnamese`, `Yiddish`, `Yoruba`, `Cantonese`, `Chinese`
## Supported Languages For Translation
Reap supports `100+ languages` for translation.
Translation supports these target languages:
`Afrikaans`, `Amharic`, `Arabic`, `Assamese`, `Azerbaijani`, `Bashkir`, `Belarusian`, `Bulgarian`, `Bengali`, `Tibetan`, `Breton`, `Bosnian`, `Catalan`, `Czech`, `Welsh`, `Danish`, `German`, `Greek`, `English`, `Spanish`, `Estonian`, `Basque`, `Persian`, `Finnish`, `Faroese`, `French`, `Galician`, `Gujarati`, `Hausa`, `Hawaiian`, `Hebrew`, `Hindi`, `Croatian`, `Haitian Creole`, `Hungarian`, `Armenian`, `Indonesian`, `Icelandic`, `Italian`, `Japanese`, `Javanese`, `Georgian`, `Kazakh`, `Khmer`, `Kannada`, `Korean`, `Latin`, `Luxembourgish`, `Lingala`, `Lao`, `Lithuanian`, `Latvian`, `Malagasy`, `Maori`, `Macedonian`, `Malayalam`, `Mongolian`, `Marathi`, `Malay`, `Maltese`, `Myanmar`, `Nepali`, `Dutch`, `Nynorsk`, `Norwegian`, `Occitan`, `Punjabi`, `Polish`, `Pashto`, `Portuguese`, `Romanian`, `Russian`, `Sanskrit`, `Sindhi`, `Sinhala`, `Slovak`, `Slovenian`, `Shona`, `Somali`, `Albanian`, `Serbian`, `Sundanese`, `Swedish`, `Swahili`, `Tamil`, `Telugu`, `Tajik`, `Thai`, `Turkmen`, `Tagalog`, `Turkish`, `Tatar`, `Ukrainian`, `Urdu`, `Uzbek`, `Vietnamese`, `Yiddish`, `Yoruba`, `Cantonese`, `Chinese`, `Klingon`, `High Valyrian`, `Dothraki`, `Na'vi`
## Supported Languages For AI Dubbing
Reap supports `80+ languages` for AI dubbing.
AI Dubbing supports these target languages:
`Afrikaans (South Africa)`, `Amharic (Ethiopia)`, `Arabic (United Arab Emirates)`, `Arabic (Bahrain)`, `Arabic (Algeria)`, `Arabic (Egypt)`, `Arabic (Iraq)`, `Arabic (Jordan)`, `Arabic (Kuwait)`, `Arabic (Lebanon)`, `Arabic (Libya)`, `Arabic (Morocco)`, `Arabic (Oman)`, `Arabic (Qatar)`, `Arabic (Saudi Arabia)`, `Arabic (Syria)`, `Arabic (Tunisia)`, `Arabic (Yemen)`, `Assamese (India)`, `Azerbaijani (Latin, Azerbaijan)`, `Bulgarian (Bulgaria)`, `Bangla (Bangladesh)`, `Bengali (India)`, `Bosnian (Bosnia and Herzegovina)`, `Catalan`, `Czech (Czechia)`, `Welsh (United Kingdom)`, `Danish (Denmark)`, `German (Austria)`, `German (Switzerland)`, `German (Germany)`, `Greek (Greece)`, `English (Australia)`, `English (Canada)`, `English (United Kingdom)`, `English (Hong Kong SAR)`, `English (Ireland)`, `English (India)`, `English (Kenya)`, `English (Nigeria)`, `English (New Zealand)`, `English (Philippines)`, `English (Singapore)`, `English (Tanzania)`, `English (United States)`, `English (South Africa)`, `Spanish (Argentina)`, `Spanish (Bolivia)`, `Spanish (Chile)`, `Spanish (Colombia)`, `Spanish (Costa Rica)`, `Spanish (Cuba)`, `Spanish (Dominican Republic)`, `Spanish (Ecuador)`, `Spanish (Spain)`, `Spanish (Equatorial Guinea)`, `Spanish (Guatemala)`, `Spanish (Honduras)`, `Spanish (Mexico)`, `Spanish (Nicaragua)`, `Spanish (Panama)`, `Spanish (Peru)`, `Spanish (Puerto Rico)`, `Spanish (Paraguay)`, `Spanish (El Salvador)`, `Spanish (United States)`, `Spanish (Uruguay)`, `Spanish (Venezuela)`, `Estonian (Estonia)`, `Basque`, `Persian (Iran)`, `Finnish (Finland)`, `Filipino (Philippines)`, `French (Belgium)`, `French (Canada)`, `French (Switzerland)`, `French (France)`, `Irish (Ireland)`, `Galician`, `Gujarati (India)`, `Hebrew (Israel)`, `Hindi (India)`, `Croatian (Croatia)`, `Hungarian (Hungary)`, `Armenian (Armenia)`, `Indonesian (Indonesia)`, `Icelandic (Iceland)`, `Italian (Italy)`, `Japanese (Japan)`, `Javanese (Latin, Indonesia)`, `Georgian (Georgia)`, `Kazakh (Kazakhstan)`, `Khmer (Cambodia)`, `Kannada (India)`, `Korean (Korea)`, `Lao (Laos)`, `Lithuanian (Lithuania)`, `Latvian (Latvia)`, `Macedonian (North Macedonia)`, `Malayalam (India)`, `Mongolian (Mongolia)`, `Marathi (India)`, `Malay (Malaysia)`, `Maltese (Malta)`, `Burmese (Myanmar)`, `Norwegian Bokmål (Norway)`, `Nepali (Nepal)`, `Dutch (Belgium)`, `Dutch (Netherlands)`, `Odia (India)`, `Punjabi (India)`, `Polish (Poland)`, `Pashto (Afghanistan)`, `Portuguese (Brazil)`, `Portuguese (Portugal)`, `Romanian (Romania)`, `Russian (Russia)`, `Sinhala (Sri Lanka)`, `Slovak (Slovakia)`, `Slovenian (Slovenia)`, `Serbian (Cyrillic, Serbia)`, `Sundanese (Indonesia)`, `Swedish (Sweden)`, `Kiswahili (Kenya)`, `Kiswahili (Tanzania)`, `Tamil (India)`, `Tamil (Sri Lanka)`, `Tamil (Malaysia)`, `Tamil (Singapore)`, `Telugu (India)`, `Thai (Thailand)`, `Turkish (Türkiye)`, `Ukrainian (Ukraine)`, `Urdu (India)`, `Urdu (Pakistan)`, `Uzbek (Latin, Uzbekistan)`, `Vietnamese (Vietnam)`, `Chinese (Cantonese, Simplified)`, `Chinese (Mandarin, Simplified)`, `Chinese (Guangxi Accent Mandarin, Simplified)`, `Chinese (Cantonese, Traditional)`, `Chinese (Taiwanese Mandarin, Traditional)`, `isiZulu (South Africa)`
## Script Mode
Some Reap workflows also support script handling options:
* `Native` for captions in the original writing system of the selected language
* `Roman` for romanized output written in Latin characters
## Where You’ll See Language Settings
You can choose language settings in workflows like:
* [How to add captions](/help-center/how-to-add-captions-to-your-videos)
* [How to Generate a Transcript](/help-center/how-to-generate-a-transcript)
* [How to Create an Audiogram](/help-center/how-to-create-an-audiogram)
* [How to use AI Dubbing](/help-center/how-to-use-the-dubbing-feature)
## API Reference
If you need the full live language list for automation or integrations, use:
* [Get Translation Languages](/api-reference/get-translation-languages)
* [Get Dubbing Languages](/api-reference/get-dubbing-languages)
# Supported Social Media Platforms
Source: https://docs.reap.video/help-center/supported-social-media-platforms
See which social platforms you can connect in Reap and know that you can link multiple accounts.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap supports direct social publishing workflows for the following platforms:
* `YouTube`
* `Instagram`
* `TikTok`
* `LinkedIn`
You can connect multiple accounts, which makes it easier to publish across different brands, channels, or client profiles from the same workspace.
## What To Know
* You can connect more than one social account in Reap.
* Multiple connected accounts can be used when scheduling or publishing content.
* Make sure you choose the correct destination account before you publish a clip.
## Where To Manage Connections
To start connecting accounts, use [How to Connect Social Media Accounts](/help-center/how-to-connect-social-media-accounts).
To remove access later, use [How to Disconnect Your Social Media Accounts](/help-center/how-to-disconnect-your-social-media-accounts).
# Switch Studios
Source: https://docs.reap.video/help-center/switch-studios
Move between studios you already have access to from the studio button on the top left corner.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you belong to more than one studio, you can move between them from the studio button on the top left corner. Reap shows the studios attached to your account in the same menu where member invitations are managed.
## Step-By-Step Workflow
Click the studio button on the top left corner of the app.
Look through the list of studios shown in the dropdown menu.
Click the studio you want to open.
Reap switches you into that studio so you can keep working in the correct workspace.
## Notes
* Only studios you already belong to will appear in the list.
* Switching studios changes the workspace context for the rest of your session.
# How to buy additional plan packs
Source: https://docs.reap.video/help-center/top-up-additional-minutes
Buy additional plan packs from the billing page.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can add additional plan packs from **Manage billing** or **Settings**.
## Step-By-Step Workflow
From your home page, click **Manage billing**, or open **Settings**.
Click **Update Plan** and add the quantity you want for the top up.
# Top up media credits
Source: https://docs.reap.video/help-center/top-up-media-credits
Buy extra media credits as a one-time purchase when your monthly plan credits run low.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If you run out of monthly media credits before your plan renews, you can top up with extra credits instead of upgrading your plan. Top-ups are a one-time purchase, not a subscription, and the credits **never expire**.
Top-up credits work like this:
* credits are sold in packs of `100 Media Credits`
* you can buy preset bundles or a custom quantity
* payment is a one-time card charge through Stripe
* credits are added to your account within a few seconds of payment
* your monthly plan credits are always used first; top-up credits are only consumed after they run out
Top-ups apply to **Media Credits** only (clipping, captions, reframing, transcription, audiograms, and editor processing). AI Credits cannot be topped up. See the [Reap Credit System guide](/help-center/reap-credit-system-complete-guide) for how each credit type is consumed.
## Who Can Top Up
* You need an **active paid plan** (any paid or AppSumo plan). Free and trial users can't buy top-up credits.
* Only **workspace admins** can make the purchase. The option is hidden for members.
## Step-By-Step Workflow
Go to **Settings**, or click **Add credits** in the lower left corner.
In Settings, click **Billing & Usage**, then click **Buy credits**. The **Top-up Credits** popup opens.
Pick one of the preset bundles, or select **Custom** to enter your own quantity (up to `1,000` packs in a single purchase). The popup shows the total price and the total credits before you pay.
If you have a promo code, enter it in the **Promo code** field and it's applied at checkout.
Click **Buy credits**. You're redirected to Stripe Checkout to pay with your card. This is a **one-time payment** and it doesn't change your subscription or renewal date.
After payment you'll see a short **"Finalizing your credits"** screen, and the credits are added to your account within a few seconds. Your top-up balance appears in **Settings → Billing & Usage** under **Top-up Credits**.
## How Top-Up Credits Are Used
* **Plan credits first.** Reap always spends your monthly plan credits before touching your top-up balance.
* **No expiry.** Top-up credits never expire and roll over across billing cycles.
* **Active plan required to spend.** Top-up credits can only be spent while you have an active paid plan.
## What Happens If My Plan Lapses?
If your subscription is cancelled or a payment fails, your top-up balance is **frozen, not deleted**. You'll see a `Frozen` badge next to your Top-up Credits in billing settings. As soon as you're back on an active paid plan, the full balance becomes spendable again.
Topping up is ideal for a one-off busy month. If you find yourself topping up every month, [updating your subscription plan](/help-center/update-subscription-plan) is usually better value.
# Track & Download Results With MCP
Source: https://docs.reap.video/help-center/track-and-download-results-with-reap-mcp
Check job status, find past projects, and get clip download and share links by asking your AI agent through Reap MCP.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap jobs run asynchronously. With Reap MCP connected, your AI agent can check progress, search your workspace, and hand back finished clips with download and share links — so you don't have to dig through the dashboard.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
## Check Job Status
```text theme={"system"}
What's the status of that clipping job, and how long until it's done?
```
Your agent reports the time elapsed and an estimate of time remaining. You'll also get an email when processing completes.
## Find Past Projects
Your agent can search and filter your workspace:
```text theme={"system"}
Show me my clipping projects from the last week.
```
```text theme={"system"}
Find my project called "Founder interview".
```
```text theme={"system"}
Which of my recent jobs are still processing?
```
You can filter by project type (clipping, captions, transcription, reframe, dubbing, audiogram, editor), status, search text, and date.
## Get Finished Clips
```text theme={"system"}
Get the finished clips from that project with download and share links.
```
Your agent returns each clip as a link you can open in Reap or download directly.
## Polish Before Publishing
You can tweak a clip's title or caption text before it goes out:
```text theme={"system"}
Rename clip 2 to "The pricing mistake" and update its caption to match.
```
## Related
* [Create Clips With Reap MCP](/help-center/create-clips-with-reap-mcp)
* [Publish & Schedule Clips With Reap MCP](/help-center/publish-and-schedule-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Transcribe Videos With MCP
Source: https://docs.reap.video/help-center/transcribe-videos-with-reap-mcp
Get a timestamped transcript with speaker labels by asking your AI agent through Reap MCP — optionally translated into another language.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
With Reap MCP connected, your AI agent can transcribe a video into text with word-level timestamps and speaker diarization (speaker labels).
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
Reap MCP requires a paid plan with API access enabled.
## Transcribe A Video
You can transcribe a public URL or a video you upload:
```text theme={"system"}
Transcribe this video and give me the text with timestamps:
https://www.youtube.com/watch?v=XXXXXXXXXXX
```
```text theme={"system"}
Upload ~/Videos/interview.mp4 and transcribe it.
```
## Translate The Transcript
```text theme={"system"}
Transcribe my last upload in English and also translate the transcript into French.
```
## Options You Can Ask For
* **Language** — name the spoken language, or leave it out to auto-detect.
* **Translation** — translate the transcript into another language.
* **Script** — native script or romanized (Latin) transliteration.
## Download Your Transcript
Once the transcription project is created and finishes processing, the transcript files become available to download. Just ask your agent for them:
```text theme={"system"}
Get the download links for that transcript.
```
Your agent returns links you can open in Reap or download directly, and you can also open the project in the Reap app to grab the files there. See [Track & Download Results With MCP](/help-center/track-and-download-results-with-reap-mcp) for more.
## How Your Agent Handles It
Transcription runs asynchronously. Ask your agent for status anytime, and you'll get an email when it completes. The result includes word-level timestamps and speaker labels.
## Related
* [Add Captions & Translate With Reap MCP](/help-center/add-captions-with-reap-mcp)
* [Track & Download Results With Reap MCP](/help-center/track-and-download-results-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Update subscription plan
Source: https://docs.reap.video/help-center/update-subscription-plan
Switch your plan from the billing page.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
You can update your subscription plan from **Manage billing** or **Settings**.
## Step-By-Step Workflow
From your home page, click **Manage billing**, or open **Settings**.
Click **Update Plan** and choose the plan you want to switch to.
# Use Brand Templates With MCP
Source: https://docs.reap.video/help-center/use-brand-templates-with-reap-mcp
Apply your saved brand template — logo, intro/outro, background music, and caption style — when your AI agent creates clips or captions through Reap MCP.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
A **brand template** in Reap can carry your logo, intro and outro, background music, and a customized caption style. With Reap MCP connected, your AI agent can apply that template automatically when it generates clips or captions — so everything comes out on-brand without manual editing.
If you have not connected Reap yet, start with [Connect Reap MCP Server](/help-center/connect-reap-mcp-server). The examples use Claude, but the same prompts work in any MCP-compatible agent.
## Where You Can Use Brand Templates
Brand templates apply to the two features that produce styled video:
* **[Creating clips](/help-center/create-clips-with-reap-mcp)** — every generated clip gets your logo, intro/outro, background music, and caption style.
* **[Adding captions](/help-center/add-captions-with-reap-mcp)** — your branded caption style is applied instead of the default.
Reframe, dubbing, and transcription don't use brand templates — they produce reframed video, dubbed audio, and text, not styled clips.
## Use Your Template In A Clip
Build it once in the dashboard: [Create Brand Template](https://app.reap.video/branding/caption-styles). Add your logo, intro/outro, background music, and caption styling. See [Brand templates](/help-center/caption-presets-are-now-brand-templates) for details.
> List my Reap brand templates.
Your agent lists your saved presets so you can pick the one you want.
> Clip this video and use my "Podcast Brand" template: `https://youtube.com/watch?v=...`
Your agent applies the template to the clipping job, so every clip comes out on-brand.
## Use Your Template In Captions
Brand templates also work when you're only adding captions:
```text theme={"system"}
Add captions to this video using my brand template.
```
Your branded caption style is applied instead of the default.
## No Template Yet? Pick A Built-In Style
If you haven't saved a brand template, you can still choose from Reap's built-in caption styles:
```text theme={"system"}
Show me the available caption styles, then clip this video using the Karaoke style.
```
Save a brand template once and reuse it across every clip and caption job — it's the easiest way to keep a consistent look without re-specifying settings each time.
## Related
* [Brand templates](/help-center/caption-presets-are-now-brand-templates)
* [Create Clips With Reap MCP](/help-center/create-clips-with-reap-mcp)
* [Add Captions & Translate With Reap MCP](/help-center/add-captions-with-reap-mcp)
* [Connect Reap MCP Server](/help-center/connect-reap-mcp-server)
* [MCP API Reference](/api-reference/mcp)
# Why can’t I use AI Clipping?
Source: https://docs.reap.video/help-center/why-cant-i-use-ai-clipping
Find the most common reasons AI clipping may fail and what to check before trying again.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If AI clipping is failing, it is usually because the video does not have enough usable content for the AI to analyze, the video quality is affecting transcription, or your monthly usage has already been consumed.
## Common Reasons
### 1. The Video Is Too Short
* Reap recommends videos longer than `10 minutes` for the best clipping results.
* The minimum video length for AI clipping is `2 minutes`.
* The maximum supported length for AI clipping is `3 hours`.
### 2. The Audio Quality Is Limiting Analysis
AI clipping depends on strong transcription quality. Results may be affected by:
* heavy background music
* blurred or unclear speech
* strong accents that reduce transcription accuracy
* poor overall audio quality
### 3. The Source Video Has Technical Issues
Clipping can also fail when the source file itself has structural problems, for example:
* missing orientation metadata
* corrupted frames
* no clear audio detected
### 4. Your Monthly Usage Has Been Used
AI clipping may also fail if you have already used your monthly credits.
## Monthly Usage By Plan
* `Free Plan`: `60 credits`
* `Creator Plan`: `600 credits`
* `Studio Plan`: `1200 credits`
## What To Try
* Upload a longer video with clearer speech.
* Reduce audio issues when possible.
* Re-export or re-upload the source file if you suspect the video has damaged frames.
* Check that the uploaded file has the correct orientation data.
* Check whether you still have credits available in your plan.
* Review the latest pricing and plan limits on [Reap Pricing](https://reap.video/pricing).
## If The Project Already Failed
* If you see a **Retry** button, retry the video first.
* If there is no retry option, contact support for help.
If you contact support, include the project or video ID so the team can investigate the failure faster.
# Why I can’t select the layout in Landscape videos?
Source: https://docs.reap.video/help-center/why-i-cant-select-the-layout-in-landscape-videos
Layout selection is available in portrait and square clips, but not in landscape videos.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
The layout feature is available in **portrait** and **square** clips. It is not available in **landscape** videos because there is no alternate layout to apply in that format.
## What To Know
* Layout controls are meant for clips where the frame needs to be adapted for portrait or square output.
* In landscape videos, the original wide frame already matches the output format.
* If you need layout options, switch to a portrait or square orientation first.
# Why is the framing/cropping not precise?
Source: https://docs.reap.video/help-center/why-is-the-framing-cropping-not-precise
Troubleshoot framing issues by changing the clip layout or manually adjusting the framing in the editor.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
If the framing or cropping does not look precise, start by testing different layout options. If the result still is not right, manually adjust the framing in the editor.
## What To Try
* Try a different layout to improve the framing for the current segment.
* If the framing still feels off, manually adjust the shot on the canvas.
* Preview the result before exporting so you can confirm the updated framing looks right.
# Why the “Publish” Button Is Disabled for Un Exported Clips
Source: https://docs.reap.video/help-center/why-the-publish-button-is-disabled-for-un-exported-clips
Understand why direct publishing is disabled until a clip is exported and how scheduled publishing works for un exported clips.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Reap lets you schedule posts even before your clips are exported, but direct publishing still requires a finished export. If the **Publish** button is disabled, it usually means the clip has not been exported yet.
## Export vs. Schedule
| Action | Purpose | When you can do it | Requirement |
| ----------------- | -------------------------------------------------------- | ------------------------------------ | -------------------------------------------- |
| **Export Clip** | Process and render the final video file | Anytime after editing | Required before direct publishing |
| **Schedule Post** | Add the clip to the calendar for automatic posting later | Even if the clip is not exported yet | Export must finish before the scheduled time |
## How Scheduling Works For Un Exported Clips
* You can schedule an un exported clip for a future date and time.
* Reap queues the export in the background.
* Once export finishes, the clip becomes ready for publishing.
* If export does not complete before the scheduled time, the scheduled post can fail.
Reap uses a built-in buffer before the scheduled publish time so un exported clips have time to finish processing in the background.
## Why The Publish Button Is Disabled
If the **Publish** button is greyed out:
* The clip has not been exported yet.
* Direct publishing from the project dashboard requires a finished export file.
* Export ensures the final video is fully processed before it is sent to the connected platform.
## How To Fix It
Go to the project where the clip is located.
Click **Export Clip** and wait for the processing to start.
Let the export complete fully before trying to publish.
Return to the dashboard or calendar. Once the export is ready, the **Publish** button becomes active.
## What To Remember
* Scheduling can happen before export is finished.
* Direct publishing cannot happen before export is finished.
* If you want to publish immediately, export the clip first.
# Workspace Management
Source: https://docs.reap.video/help-center/workspace-management
Invite members and move between studios from the studio button on the top left corner.
> **For AI agents:** a documentation index is at [/llms.txt](/llms.txt). Every page is also available as markdown, just append `.md` to the URL.
## Overview
Use the studio button on the top left corner to manage collaboration inside Reap. From there, you can invite new members into the current workspace and switch between studios you already have access to.
## What You Can Do
* Invite people into your current workspace.
* Switch between studios linked to your account.
## Workspace Guides
Add teammates to your current studio from the studio menu.
Move between studios you already belong to from the same menu.