Why compare Rendi FFmpeg API pricing and documentation?
Rendi is a hosted FFmpeg API that runs standard FFmpeg commands in the cloud. Very Good FFmpeg follows the same approach: raw FFmpeg syntax through a REST API, no abstraction layer, pay for what you use.
This page compares Rendi FFmpeg API pricing, documentation quality, feature support, and runtime limits against Very Good FFmpeg. If you are deciding between the two, you want to know which one fits your workload, budget, and team.
Key takeaways: Rendi vs Very Good FFmpeg
Rendi uses subscription pricing with a monthly minimum. Very Good FFmpeg uses usage-based billing with no minimum.
Here is the short version:
| Comparison | Rendi (Pro) | Very Good FFmpeg |
|---|---|---|
| Pricing model | $25/month subscription + GB quota | Usage-based per GB, no monthly minimum |
| Entry price | $25/month minimum | Per GB (entry price), minimum charge |
| Included quota | 100 GB processed | Unlimited at per-GB rate |
| Max job runtime | 10 minutes (Pro) | 6 hours |
| GPU support | Upon request (Enterprise) | On demand (Nvidia RTX and A-series) |
| Official SDKs | No | TypeScript + Python |
| MCP server | Yes | Yes |
| RBAC / teams | No | Yes |
| Realtime logs | No | Yes |
| Auto-diagnosis | No | Yes |
What is Rendi FFmpeg API?
Rendi is a RESTful API that accepts FFmpeg commands via HTTP POST, runs them on cloud infrastructure, and returns the output. You submit a command with input file URLs, and Rendi processes it on auto-scaling AMD machines with up to 32 vCPUs per command.
The product launched around April 2025 with a Show HN post. It is built by a small team led by Peter Naftaliev. Rendi claims 99.9% uptime, no cold starts, and auto-scaling with demand. It supports raw FFmpeg syntax only: there is no visual editor, no JSON DSL, and no template system. You must know FFmpeg CLI to use it.
A unique differentiator is Rendi's MCP server for AI coding agents. Rendi ships a documentation MCP server compatible with Claude Code, Cursor, VS Code Copilot, Codex CLI, and Gemini CLI. Docs are also published as plain markdown with an llms.txt index and OpenAPI spec.
What is Very Good FFmpeg?
Very Good FFmpeg is also a REST API that runs exact FFmpeg commands on cloud infrastructure. Same approach: post your command, get output. No DSL, no visual editor. If your command works on the terminal, it works on the API.
The differences are in infrastructure, billing, and polish. Every CPU job runs on a dedicated 16 vCPU / 32 GB DDR5 RAM / NVMe instance with 5+ GHz cores. GPU jobs run on Nvidia RTX 4090, RTX 5090, A4000, or A5000 hardware. Jobs can run up to 6 hours. Rate limits start at 10 req/s and increase to 100 req/s with a prepaid balance.
Very Good FFmpeg ships official TypeScript and Python SDKs, an MCP server, and a Make.com integration. It also provides realtime stderr streaming in the dashboard, auto-diagnosis on command failure, team-based role access control, and temporary file uploads.
How does Rendi pricing work?
Rendi has three tiers: Free, Pro, and Enterprise.
Free tier: $0 per month. Includes 50 GB of processing, 4 vCPUs, 1-minute maximum runtime per command, 5 GB of storage, and 4 commands per minute. Requires a credit card for a $5 refundable verification deposit.
Pro tier: $25 per month. Includes 100 GB of processing, 4 vCPUs, 10-minute runtime per command (unlimited on paid plans), 50 GB of storage, unlimited commands per minute, webhooks, chained commands, dynamic input and output files, priority processing, one 1-on-1 consultation session, and email support.
Enterprise: Custom pricing. Includes uptime SLAs, SOC2 compliance, dedicated infrastructure, and custom terms or DPA.
Rendi calculates processing as the sum of your input and output file sizes. A 1 GB input that produces a 0.5 GB output counts as 1.5 GB processed. There are no egress or ingress fees. There is no special pricing per encoding type, resolution, or video duration.
The effective cost on the Pro tier is roughly $0.06 per GB if you use the full 100 GB quota. Rendi's own comparison page claims "$0.15 per GB processed" against Cloudinary at $1.20, Shotstack at $2.30, and Creatomate at $10.25.
How does Very Good FFmpeg pricing work?
Very Good FFmpeg uses a straightforward usage-based model. You pay per GB processed, with volume discounts that apply automatically as your usage grows.
There is no subscription fee and no monthly minimum. You do not pay for a quota you do not use. If you process 1 GB in a month, you pay for 1 GB. If you process 5 TB, volume discounts kick in and reduce the per-GB rate.
Processing is measured as input plus output bytes, the same approach Rendi uses. There are no egress fees, no storage fees, and no per-command fees. Failed or cancelled jobs still count the bytes processed before they stopped.
Which pricing model is cheaper for 50 GB per month?
Rendi at 50 GB on the Free tier costs $0, but the free tier has a 1-minute runtime cap per command and only 4 vCPUs. If your jobs run longer than 1 minute, you need the Pro tier at $25 per month.
Very Good FFmpeg at 50 GB costs the per-GB rate multiplied by 50, with no monthly minimum. For light workloads that fit within Rendi's free tier limits and do not exceed the 1-minute runtime cap, Rendi's free tier is cheaper. For any workload that requires the Pro tier, Very Good FFmpeg is cheaper at low volumes.
Which pricing model is cheaper for 500 GB per month?
Rendi at 500 GB on the Pro tier costs $25 per month for the first 100 GB and then you pay for overages. Rendi's overage pricing is listed as contact-support.
Very Good FFmpeg at 500 GB benefits from automatic volume discounts. The per-GB rate drops as volume increases. There is no hard quota cap and no subscription floor.
For 500 GB per month, Very Good FFmpeg is cheaper because there is no $25 subscription fee eating into the budget and volume discounts reduce the effective rate. Rendi's $25 floor means you pay the same $25 whether you process 1 GB or 100 GB, which is good for light users but inefficient at higher volumes.
Which service has better documentation?
Rendi's documentation is clean, focused, and endpoint-oriented. It covers the core API endpoints (/v1/run-ffmpeg-command, /v1/run-chained-ffmpeg-commands, /v1/run-multiple-ffmpeg-commands), file management, webhooks, and FFprobe integration. The docs include an OpenAPI spec and a markdown-based format designed for AI ingestion.
Rendi's documentation is also available through an MCP server, which lets AI coding agents read and reference the docs directly. This is rare among FFmpeg APIs and is a genuine advantage for developers who work heavily with AI coding tools.
Very Good FFmpeg's documentation covers the same endpoint surface with comparable detail. What sets it apart is auto-diagnosis: when a command fails, the API analyzes the FFmpeg error output and tells you what went wrong. This saves significant debugging time when you are iterating on FFmpeg commands.
Here is a comparison of documentation quality:
| Documentation factor | Rendi | Very Good FFmpeg |
|---|---|---|
| Endpoint coverage | Full (run, chain, multiple, webhooks, file management) | Full (run, chain, webhooks, file management) |
| OpenAPI spec | Yes | Yes |
| MCP / AI agent ingestion | Yes (MCP server + markdown) | Yes (MCP server) |
| Code examples | curl, JSON request bodies | curl, JSON, TypeScript SDK, Python SDK |
| Quickstart time | Minutes | Minutes |
| Auto-diagnosis on errors | No | Yes (AI explains FFmpeg errors) |
| Realtime logs | No (polling only) | Yes (dashboard stderr streaming) |
How do features compare between Rendi and Very Good FFmpeg?
Both services support raw FFmpeg syntax as their core model. Both support chained commands, webhooks, file storage, and MCP integration. Here is the full feature comparison:
| Feature | Rendi | Very Good FFmpeg |
|---|---|---|
| Raw FFmpeg syntax | Yes | Yes |
| GPU acceleration | Enterprise request only | On demand (RTX 4090, 5090, A4000, A5000) |
| Max job runtime | 10 min (Pro), unlimited (Enterprise) | 6 hours |
| vCPUs per job | Up to 32 (account pool) | 16 dedicated (5+ GHz) |
| Rate limit | 4 commands/min (Free), unlimited (Pro) | 10 req/s (100 req/s with prepaid) |
| Webhooks | Yes (with retry schedule) | Yes |
| Command chaining | Yes (up to 10 commands) | Yes (array of commands) |
| Built-in storage | Yes (no egress fees) | Yes (no egress fees) |
| Temporary file uploads | No | Yes |
| Realtime job logs | No (polling only) | Yes (stderr streaming in dash) |
| Auto-diagnosis | No | Yes |
| Official SDKs | No | TypeScript, Python |
| MCP server | Yes | Yes |
| RBAC / teams | No | Yes |
| Input sources | HTTP/HTTPS, Google Drive, Dropbox, S3/GCS signed URLs | HTTP/HTTPS, S3/GCS signed URLs, temporary uploads |
| Dynamic input files | Yes (wildcards, compressed folders) | Yes |
| FFprobe integration | Yes | Yes |
| Make.com integration | Yes | Yes |
| n8n integration | Yes | Coming soon |
| Zapier integration | Yes | Not yet |
Rendi has gaps in GPU access, runtime limits, SDK coverage, realtime observability, and team management. Very Good FFmpeg matches or exceeds Rendi on every feature in this table.
Does Rendi support GPU acceleration?
Rendi does not offer GPU acceleration on its Free or Pro plans. GPU access is available only through custom enterprise requests with custom pricing and terms.
Very Good FFmpeg provides Nvidia GPU on demand. You set machine: "nvidia" on your request to route the job to a worker with current-generation Nvidia hardware. GPU options include RTX 4090, RTX 5090, A4000, and A5000 cards.
This gap matters for workloads that benefit from GPU acceleration: H.265 and AV1 encoding, complex filter graphs, scaling, and high-resolution transcoding. If your pipeline relies on GPU codecs like h264_nvenc, hevc_nvenc, or hevc_vaapi, Rendi cannot run those commands efficiently on standard plans.
How long can a single job run on each service?
Rendi caps the Pro tier at 10 minutes of runtime per command. The Free tier is limited to 1 minute. The Enterprise tier can remove this cap with custom terms.
Very Good FFmpeg allows up to 6 hours of runtime per job. This covers entire feature-length film encodes, large batch processing, and complex multi-step filter chains that cannot finish in 10 minutes.
The 10-minute cap on Rendi Pro is a meaningful constraint. If you transcode a 2-hour video at high quality with a slow preset, or run complex filter graphs on high-resolution source files, you will hit that limit. You would need to split the work into chunks or upgrade to Enterprise.
Do either service charge egress or storage fees?
Neither Rendi nor Very Good FFmpeg charges egress or storage fees on their published plans. Both include output URL delivery and webhook notification in the per-GB processing cost.
Rendi: "No egress/ingress fees" is stated on the pricing page. Outputs are stored on Rendi's infrastructure and served via URL.
Very Good FFmpeg: Output URLs and webhook delivery are included in the per-GB price. There are no separate storage or bandwidth charges.
This is a contrast with platforms like Cloudinary, which charge separately for storage and delivery bandwidth on top of transformation costs.
Do either have official SDKs?
Rendi does not ship official SDKs. You interact with the API using direct HTTP calls with curl, fetch, or your own HTTP client wrapper.
Very Good FFmpeg ships official TypeScript and Python SDKs via npm and PyPI. The TypeScript SDK is @verygoodffmpeg/sdk and the Python SDK is very-good-ffmpeg. Both provide client classes, bearer token authentication, and error handling.
The lack of SDKs on Rendi is not a blocker for most developers, but it means more boilerplate code for integration. If your team uses TypeScript or Python, the official VGF SDKs save time on request construction and error handling.
Can I use these with AI coding agents?
Both services support AI coding agent integration through MCP servers.
Rendi ships an MCP server at https://rendi.dev/docs/mcp that works with Claude Code, Cursor, VS Code Copilot, Codex CLI, and Gemini CLI. It also provides docs as plain markdown with an llms.txt index for easy AI ingestion.
Very Good FFmpeg also provides an MCP server at https://verygoodffmpeg.com/api/mcp. It is compatible with the same tools. The combination of MCP support plus auto-diagnosis means that when an AI agent writes an FFmpeg command and it fails, the system can explain what went wrong and help the agent fix it.
MCP support is a wash between the two: both have it, and both implement it well.
Do either support team or role-based access?
Rendi does not appear to offer team management or role-based access control on its published plans. There is no mention of team accounts, member invitations, or permission levels in the docs.
Very Good FFmpeg includes team and role-based access control. You can create teams, invite members, and assign permissions from the dashboard. This is useful for organizations where multiple developers need access to the same account with different permission levels.
If you work alone, this does not matter. If you work on a team, VGF's RBAC is a practical advantage.
Who should use Rendi?
Rendi is a good fit in these situations:
- Your jobs complete within 1 minute (Free) or 10 minutes (Pro).
- You want a predictable $25 monthly bill for light to moderate processing.
- You value MCP and AI-agent-ready documentation and work heavily with AI coding tools.
- You need free tier processing for small batch jobs under tight runtime limits.
- You are comfortable with direct HTTP calls and do not need SDKs.
Rendi works well for hobby projects, lightweight automation, and developers who process small files on a predictable schedule.
Who should use Very Good FFmpeg?
Very Good FFmpeg is a better fit in these situations:
- Your jobs need more than 10 minutes of runtime (up to 6 hours).
- You need GPU acceleration for encoding, scaling, or filter-heavy workloads.
- You have variable monthly volume and do not want a subscription floor.
- You want official TypeScript or Python SDKs for cleaner integration.
- You need realtime visibility into running jobs via the dashboard.
- You want auto-diagnosis to debug failed commands faster.
- Your team needs role-based access control.
- You process more than 100 GB per month and want volume discounts.
Very Good FFmpeg suits production video pipelines, team environments, GPU-reliant workflows, and any workload that cannot fit inside a 10-minute runtime window.
What do real users say about Rendi?
Rendi displays customer logos from Amazon, IKEA, Airtable, Wix, Runway, Gamma, Riverside.fm, Pipedream, Durable, Arcads, and Artlist. Testimonials from Thomas Frank (YouTuber), Aaron Francis (Try Hard Studios), and several automation agency CEOs are positive.
Hacker News traction has been modest: an 8-point Show HN post in April 2025 and a 40-point deep-dive post on FFmpeg 8.0 in November 2025. There are no G2 reviews or ProductHunt page for Rendi.
Very Good FFmpeg has G2 reviews, a ProductHunt presence, and a published case study with Reelo Video (209 GB processed per month). Both services have positive user sentiment, but VGF has more verifiable third-party review sources.
FAQ
Can I use the same FFmpeg command on both Rendi and Very Good FFmpeg?
Yes. Both services accept raw FFmpeg syntax. If your command works on the terminal, it works on both APIs. You may need to adjust input and output file references to match each API's request format, but the FFmpeg flags, filters, and codec options are identical.
Which is cheaper for 50 GB per month?
Rendi Free tier is $0 for 50 GB if your jobs finish within 1 minute. If your jobs run longer, Rendi Pro is $25. Very Good FFmpeg charges the per-GB rate for 50 GB with no monthly minimum. For very light workloads that fit the free tier, Rendi is cheaper. For any paid plan need, VGF is cheaper at 50 GB.
Which is cheaper for 500 GB per month?
Very Good FFmpeg is cheaper at 500 GB. Rendi Pro covers 100 GB for $25, and overage pricing applies beyond that. VGF volume discounts reduce the per-GB rate automatically, and there is no $25 subscription floor.
Does Rendi have a free tier?
Yes. Rendi's free tier includes 50 GB of processing per month, 4 vCPUs, 1-minute max runtime, 5 GB of storage, and 4 commands per minute. Requires a credit card for a $5 refundable verification deposit.
Does Very Good FFmpeg have a free tier?
Very Good FFmpeg offers a free trial with a small amount of free processing. No credit card is required to start.
Can I run GPU-accelerated commands on Rendi?
No, not on standard plans. GPU is only available through custom enterprise requests. Very Good FFmpeg provides GPU on demand with Nvidia RTX and A-series hardware.
How long can a single job run on each?
Rendi Free: 1 minute. Rendi Pro: 10 minutes (unlimited on Enterprise). Very Good FFmpeg: 6 hours.
Do either charge egress fees?
No. Neither Rendi nor Very Good FFmpeg charges egress or storage fees.
Do either have official SDKs?
Rendi does not have official SDKs. Very Good FFmpeg has official TypeScript and Python SDKs.
Which has better documentation for beginners?
Both have clear documentation, but Very Good FFmpeg's auto-diagnosis feature helps beginners debug failed commands faster. Rendi's MCP server is useful for developers who work with AI coding tools.
Can I use these with AI coding agents (Claude, Cursor, Copilot)?
Yes. Both services offer MCP servers compatible with Claude Code, Cursor, VS Code Copilot, Codex CLI, and Gemini CLI.
Do either support team or role-based access?
Very Good FFmpeg supports teams and RBAC. Rendi does not appear to offer this on standard plans.
References
- Rendi homepage: https://rendi.dev
- Rendi pricing: https://rendi.dev/pricing
- Rendi API reference: https://rendi.dev/docs/api-reference/endpoint/run-ffmpeg-command
- Rendi blog: https://rendi.dev/blog
- Rendi status page: https://status.rendi.dev
- Rendi GitHub FFmpeg cheatsheet: https://github.com/rendi-api/ffmpeg-cheatsheet
- Rendi MCP documentation: https://rendi.dev/docs/mcp
- Rendi vs competitors comparison: https://rendi.dev/blog/best-video-generation-apis
- Very Good FFmpeg homepage: https://verygoodffmpeg.com
- Very Good FFmpeg documentation: https://verygoodffmpeg.com/docs
- Very Good FFmpeg TypeScript SDK: https://www.npmjs.com/package/@verygoodffmpeg/sdk
- Very Good FFmpeg Python SDK: https://pypi.org/project/very-good-ffmpeg/
- Very Good FFmpeg G2 reviews: https://www.g2.com/products/very-good-ffmpeg/reviews
- Very Good FFmpeg ProductHunt: https://www.producthunt.com/products/very-good-ffmpeg
- Very Good FFmpeg MCP server: https://verygoodffmpeg.com/api/mcp
- Hacker News Rendi Show HN (April 2025): https://news.ycombinator.com/item?id=42978392
- Hacker News FFmpeg 8.0 deep-dive: https://news.ycombinator.com/item?id=42978395