RenderIO FFmpeg API Pricing

RenderIO FFmpeg API pricing starts at $12 a month, but command packing decides whether that price is cheap or misleading. Growth becomes cheaper than Starter at 838 monthly command credits, Business becomes cheaper than Growth at 2,201, and runtime, chaining, downloads, storage, or webhooks can force the upgrade even sooner.

RenderIO FFmpeg API Pricing at a Glance

RenderIO has three monthly plans, and Business is the only genuine volume bargain. Starter is the low-cost evaluation tier. Growth mainly buys a longer runtime, a larger chain, and video downloading. Business cuts the included-credit cost sharply and adds the operational headroom that a production video pipeline is most likely to need.

I verified every row against RenderIO's live pricing page on 14 September 2026.

At full use, the subscription portion works out to $0.024 per included credit on Starter, $0.039 on Growth, and $0.00495 on Business. Growth is more expensive per included credit than Starter. Its value is capability, not a volume discount. Business is different: it includes 20 times Growth's credits for about 2.5 times the price.

All three plans list n8n, Zapier, and Make integrations. RenderIO also says there are no egress fees, so downloading a processed output again does not consume bandwidth charges. That should not be confused with the separate video-downloader feature, which consumes command credits to fetch a public source through yt-dlp.

RenderIO Command Cost: What Uses a Credit?

RenderIO's billing unit is a submitted FFmpeg execution, not a minute, byte, or output file. The live pricing page defines one API call with one FFmpeg command as one command credit. A 10 MB clip and a 2 GB video therefore consume the same credit when each is processed by one command.

The documented cases are clear:

• One API call containing one FFmpeg command consumes 1 credit.
• One hundred videos sent as 100 separate API calls consume 100 credits.
• A sequential chain in one request consumes 1 credit when it stays within the plan's chain limit.
• One eligible yt-dlp video download consumes 3 credits.

That makes the request shape part of the price. Four sequential passes submitted separately cost four credits. Put the same dependent passes inside an allowed chain and the vendor says the request costs one. File size can change runtime and whether a command finishes inside the plan ceiling, but it does not directly change the command charge.

The edges are less complete. RenderIO's command response reference recognizes single, chained, and multiple-command job types. The parallel endpoint can place several independent jobs inside one HTTP request and returns a command ID for each contained job. RenderIO does not publish whether that batch consumes one credit for the request or one credit for each FFmpeg execution. Do not price a parallel batch as one credit without written confirmation.

Failed work is also unspecified. The service returns FAILED statuses and full FFmpeg errors, but the public billing page does not say whether a job that fails after starting, times out, is cancelled, or is rejected consumes a credit. The homepage promises built-in deduplication when the same command is submitted twice, yet it does not say whether an idempotent replay is free. A production budget needs a retry reserve until those rules are confirmed.

RenderIO Chained Commands Change the Unit Economics

RenderIO chained commands can make the $39 plan cheaper than the $12 plan before the ordinary command crossover. The saving comes from packing dependent operations into one billable request, not from getting a lower Growth overage rate.

Consider a direct-input pipeline that requires four sequential FFmpeg passes. Each pass needs the output of the one before it, so they cannot be collapsed into independent parallel work.

Starter allows two commands in a chain. The four-pass pipeline therefore needs two chained requests and consumes two credits per finished output. Its 500 included credits cover 250 outputs, which puts the fully used subscription cost at $0.048 per output.

Growth allows five commands in a chain. The same four passes fit in one request, so 1,000 credits cover 1,000 outputs at $0.039 each. Starter remains cheaper through 418 finished outputs. At 419, Starter needs 838 credits and costs $39.04 after overage, while Growth remains $39.

This is the practical value of chain capacity: it changes the number of finished assets a credit buys. It also keeps intermediate files and sequential state inside one execution environment, rather than making your application coordinate every handoff.

There is one serious contract mismatch to resolve before buying Business for long chains. The pricing page advertises up to 20 chained commands on Business. The current Run Chained Commands API reference describes the ffmpeg_commands array as maximum 10 and says a request with more than 10 produces HTTP 422. A RenderIO vendor article repeats the 10-step endpoint ceiling while also citing the 2, 5, and 20 plan limits.

Treat 10 as the documented API ceiling until support confirms that Business accepts 11 through 20 in the production endpoint. The advertised 20-step capacity is not safe to architect around while the request contract says otherwise.

RenderIO Overage Pricing: Exact Upgrade Crossovers

Starter should be replaced by Growth at 838 monthly credits, and Growth should be replaced by Business at 2,201, provided the lower plan still clears every technical limit. Those thresholds come directly from the published base prices and overage rates.

For Starter versus Growth, the equation from the published rates is $12 + $0.08 x (credits - 500) = $39. The exact crossing sits at 837.5 credits. Whole credits make the decision clean:

• At 837 credits, Starter costs $38.96 and remains 4 cents cheaper.
• At 838 credits, Starter costs $39.04, so Growth is 4 cents cheaper.

For Growth versus Business, the equation is $39 + $0.05 x (credits - 1,000) = $99.

• At 2,200 credits, Growth and Business both cost $99.
• At 2,201 credits, Growth costs $99.05, so Business becomes cheaper.

The jump from 2,201 to Business's 20,000 included credits is unusually large. If the workload is stable near that crossing, Business buys 17,799 credits of additional headroom without increasing the current monthly bill.

The formulas have one operational catch. RenderIO says upgrades and downgrades take effect on the next billing cycle. If usage accelerates halfway through a month, the public page does not promise an immediate prorated upgrade. Forecast the full current cycle at the existing overage rate, and ask support how an urgent upgrade is handled before a traffic launch.

RenderIO Video Download Credits: Price the Whole Pipeline

RenderIO video download credits make Growth a 250-output plan for a common two-request workflow, not a 1,000-output plan. Each yt-dlp download consumes three credits, and the feature is available on Growth and Business but not Starter.

If every credit is used only for downloading, Growth holds about 333 complete downloads and Business about 6,666. Overage changes the upgrade point much earlier than the Business allowance suggests. At 733 downloads, Growth costs $98.95. At 734, the 2,202 credits cost $99.10 on Growth, so Business at $99 is cheaper.

Now price a public-video workflow that uses two documented requests:

1. Fetch one public video with the yt-dlp download endpoint for 3 credits.
2. Submit one allowed chained FFmpeg request to normalize, crop, caption, and export for 1 credit.

That is a four-credit pipeline. Growth's 1,000 credits cover 250 finished outputs. Business's 20,000 cover 5,000. Growth and Business both cost $99 at 550 outputs after Growth overage; Business becomes cheaper at 551, when Growth costs $99.20.

Chaining is doing meaningful work here. If the four FFmpeg passes were sent separately after the download, each output would consume seven credits instead of four. The pipeline should still preserve separate requests when isolation or recovery requires it, but that reliability choice belongs in the unit economics.

RenderIO also documents a combined POST /api/v1/run-ytdlp-command endpoint that downloads and then processes in one job. Its public pricing page does not say whether that combined job consumes the downloader's 3 credits or 4 credits for download plus processing. Use the conservative two-request calculation above until the combined endpoint's meter is confirmed.

Runtime, Storage, Chaining, or Webhooks May Force the Upgrade First

Runtime is the first hard wall because overage cannot buy more time. A command that needs longer than the plan maximum does not become valid when you pay another command fee.

Starter fits only when every command finishes within 1 minute, each dependent chain has no more than 2 steps, 5 GB of published storage is enough, and the workflow does not need the video downloader. It is strongest for direct media URLs, compact transformations, prototypes, and side projects whose request count is easy to bound.

Growth fits when every command finishes within 5 minutes, every chain stays within 5 steps, 10 GB of storage is enough, and polling can replace account-level webhook notifications. It is the first paid destination for yt-dlp downloads after the trial.

Business is forced when a required command takes more than 5 and no more than 90 minutes, a chain needs more than 5 steps, retained working files exceed 10 GB, or the application depends on the webhook capability listed only in the Business row. It is also the price choice above the calculated Growth crossover.

Storage needs extra care. The plans advertise 5 GB, 10 GB, and 200 GB, and the RenderIO homepage says files auto-expire according to the plan. It does not publish the retention period behind any of those allowances or explain what happens at the storage limit. If an output must remain durable, copy it into storage you control and treat RenderIO's output URL as a working artifact, not an archive.

Webhook language is inconsistent too. Pricing lists webhook notifications only under Business, while the chained-command reference exposes an optional webhook_url field without a plan label. Budget Business if callbacks are mandatory, then ask whether per-request webhooks differ from account-level webhook configuration.

RenderIO also does not publish numerical request-rate or concurrency limits alongside the plans, although the API reference documents HTTP 429 rate-limit responses. A workload can fit 20,000 monthly credits and still arrive in a burst the service throttles. Get the burst limit in writing when latency or fan-out matters.

The Free Trial Is an Evaluation Window

RenderIO is not permanently free. Its live terms give Starter a 3-day trial, after which it costs $12 per month for 500 credits unless you cancel before the trial ends.

The vendor describes the trial as full API access with no restrictions and explicitly includes video downloads during it, even though the paid Starter tier does not include that downloader. That makes the trial useful for validating a complete workflow, but three days is an evaluation window, not a sustainable free plan.

There is also a 30-day money-back guarantee on all plans. This is different from the trial: the trial delays the first charge, while the guarantee is the published refund protection after purchase. Cancellation is available from the dashboard, and the plan stays active through the current billing period.

Who never needs to pay? Only someone who finishes the evaluation inside three days and does not keep using the API. There is no recurring free allowance for a low-volume production job. If permanent free usage matters, Rendi's byte-based Free plan is the relevant alternative.

RenderIO vs Rendi and Very Good FFmpeg

RenderIO wins when jobs are large and command count is predictable. Rendi can win on small files and offers a permanent free tier. Very Good FFmpeg can win on irregular use, long jobs, or months when doing no work should cost $0.

Normalize the comparison around 1,000 one-command jobs in a month. Each job reads a 1 GB input and writes a 0.5 GB output, so a byte-priced service sees 1,500 GB of processing.

Rendi

Rendi prices input plus output bytes rather than API calls. Its current $25 Pro entry includes 250 GB, 4 vCPUs, a 10-minute command cap, and 50 GB-month of storage.

The first published Rendi row that clears 1.5 TB is the $200 configuration with 2 TB of processing, 32 vCPUs, 500 GB-month of storage, and a 10-minute cap. RenderIO Growth handles the same 1,000-command scenario for $39 if every command finishes within 5 minutes. For a full explanation of Rendi's byte meter and runtime ladder, see the current Rendi pricing analysis.

That result reverses when files are tiny. Rendi Free includes 50 GB of monthly processing for commands that finish within 1 minute, while RenderIO has no permanent free plan. Rendi's meter is friendlier to many small files; RenderIO's is friendlier to fewer, very large files.

Very Good FFmpeg

Very Good FFmpeg has no monthly subscription minimum, includes the first 2 GB without a card, and bills the input and output bytes a command reads and writes.

Its published bands are $0.50 per GB from 0 to 10 GB, $0.10 from 10 to 100 GB, and $0.08 above 100 GB. The page does not state whether crossing a band reprices all usage or only the marginal bytes. The 1,500 GB scenario therefore lands between $120 if the top rate applies retroactively and $126 if the bands are marginal. Confirm the invoice method before using either figure as a quote.

Very Good FFmpeg also publishes a 6-hour single-job ceiling. That makes it the clearer choice when a command can exceed RenderIO Business's 90-minute maximum. It is not automatically cheaper: a month full of large outputs can cost far more than RenderIO's command subscription, while a quiet month costs nothing.

The decision is the meter. Pick RenderIO for stable call counts and large files, Rendi for a byte quota with a useful free entry and account compute choices, and Very Good FFmpeg for usage-only billing or longer execution. Do not compare the three headline prices without fixing command count, input bytes, output bytes, longest runtime, and storage behavior.

Who Should Pick RenderIO?

Pick RenderIO when you already have FFmpeg commands, can keep the required runtime inside 90 minutes, and value a predictable command-count bill more than a permanent free tier. Its strongest economic case is a pipeline that chains several dependent transforms around large media files.

Skip RenderIO when a required job can run beyond 90 minutes, usage is too sporadic to justify a monthly floor, or the missing retry and failure rules make the bill unacceptable. Very Good FFmpeg publishes a 6-hour ceiling and usage-only pricing. Rendi gives low-volume pipelines a permanent Free path when its byte, runtime, storage, and vCPU limits fit.

The Monday Move

Use the 3-day trial to measure a production-shaped pipeline, not a hello-world transcode. The point is to learn which limit forces the tier and how many credits one finished customer outcome consumes.

1. 1

   List every submitted action

   Separate single FFmpeg calls, chained requests, parallel batches, yt-dlp downloads, combined download-and-process jobs, and retries. Price only the documented cases, then isolate the unknowns.

2. 2

   Pack dependent work

   Place sequential passes into the smallest valid chain and count the requests left after packing. Keep independent work separate when failure isolation matters more than credit savings.

3. 3

   Run the slowest representative job

   Measure wall-clock runtime with the largest normal input and the most expensive filter graph. Compare it with the 1-minute, 5-minute, and 90-minute plan ceilings.

4. 4

   Get the missing contract in writing

   Ask RenderIO how it bills failed work, cancellations, timeouts, idempotent replays, parallel batches, and the combined yt-dlp endpoint. Confirm retention periods, burst limits, Business webhook access, and whether 11 through 20 chained commands are accepted.

5. 5

   Apply the crossover

   Forecast one full billing cycle. Move to Growth at 838 ordinary credits or earlier when its capabilities are required. Move to Business at 2,201 ordinary credits, 734 download-only jobs, or 551 documented four-credit outputs, unless a technical limit forces it first.

RenderIO Pricing FAQ

Is RenderIO free?

No. RenderIO has no permanent free tier. Starter offers a 3-day trial with full API access, including video downloads during the trial, and then costs $12 per month unless cancelled before billing begins.

RenderIO student discount: is one available?

RenderIO's live pricing page does not list a student or education discount. The public no-charge option is the 3-day Starter trial, not a recurring student plan.

RenderIO refund policy: what is covered?

The vendor publishes a 30-day money-back guarantee on all plans. It also says cancellation leaves access active through the current billing period.

RenderIO annual billing: is it available?

Not as a public checkout plan. RenderIO says all published plans are monthly and invites buyers to contact the company about an annual discount.

Has RenderIO pricing changed?

RenderIO does not link a dated pricing changelog, so a defensible change history is not public. The live table verified on 14 September 2026 is $12 for Starter, $39 for Growth, and $99 for Business; use that instead of undated or third-party snapshots.

What counts as a RenderIO command?

One API call with one FFmpeg execution consumes one credit regardless of file size. An allowed chained request also consumes one credit, while an eligible yt-dlp video download consumes three.

Do failed RenderIO commands use credits?

The public pricing page and API reference do not say. Confirm how failures, timeouts, cancellations, rejected requests, and idempotent retries are metered before setting a production retry policy.

Before you lock a video automation budget, get the AI Business Workflow Audit Checklist.