Xora vs. Rendi: Cloud FFmpeg API Comparison

Executing media processing commands programmatically can introduce heavy local dependencies. Installing the ffmpeg binary on your application host or inside Docker containers creates server maintenance overhead, codec updates, scaling limits, and resource queues.

This has led to the rise of cloud-based FFmpeg-as-a-Service APIs. Instead of maintaining local infrastructure, developers can replace local shell scripts with a simple curl request to an external API.

Two of the leading developer-focused platforms for running cloud FFmpeg commands are Xora and Rendi. In this guide, we do a head-to-head comparison of their developer experience, billing mechanics, storage architectures, and features to help you choose the best infrastructure for your app.

1. The Core Developer Workflow: Replacing the local binary

Both Xora and Rendi allow you to submit raw, custom FFmpeg arguments. You map your media inputs and outputs to placeholder variables in a JSON payload, and the platforms handle the remote execution, file fetching, and uploading.

For example, suppose you want to overlay a confidential watermark and compress a video.

The Local CLI Way (Before)

ffmpeg -i source.mov -vf "drawtext=text='CONFIDENTIAL':x=10:y=10:fontsize=24" -c:v libx264 -crf 23 output.mp4

The Cloud API Way (After)

With both platforms, you submit a POST request wrapping the inputs, outputs, and parameters. The remote cloud system takes care of downloading the input, running the command, and saving the output.

Rendi Custom Command Payload

Rendi accepts the FFmpeg arguments as a single command string (the leading ffmpeg is implied):

{
  "ffmpeg_command": "-i {{in_1}} -vf \"drawtext=text='CONFIDENTIAL':x=10:y=10:fontsize=24\" -c:v libx264 -crf 23 {{out_1}}",
  "input_files": { "in_1": "https://example.com/source.mov" },
  "output_files": { "out_1": "output.mp4" }
}

Xora Custom Command Payload

Xora accepts the arguments as a JSON array — there is no shell string to assemble, so nothing to quote or escape:

{
  "mode": "ffmpeg",
  "input_files": { "in_1": "https://example.com/source.mov" },
  "output_files": { "out_1": "output.mp4" },
  "ffmpeg": {
    "args": [
      "-i", "{{in_1}}",
      "-vf", "drawtext=text='CONFIDENTIAL':x=10:y=10:fontsize=24",
      "-c:v", "libx264",
      "-crf", "23",
      "{{out_1}}"
    ]
  }
}

Workflow Winner: Tie. Both platforms let you execute custom, arbitrary FFmpeg arguments without local installation, though Xora’s argument array shape is less prone to shell string escaping errors.

2. Billing Mechanics: Credits vs. Gigabytes

The biggest difference between Rendi and Xora lies in how they bill for media processing.

Rendi: Processed Gigabyte Billing

Rendi charges based on the total file sizes of your inputs and outputs (measured in GB).

• The Pro Plan ($25/month) includes 100 GB of processing — an effective $0.25/GB. More capacity comes as bigger plan tiers, which bring the rate as low as $0.10/GB at the top end.
• The Advantage: It is simple to calculate when your files are small, and execution durations don’t affect your cost.
• The Disadvantage: You pay the same price to process a file regardless of how much CPU time it actually takes.

Xora: Credit Billing

Xora charges credits for the work a job actually performs: 1 credit per minute of processing (metered per second), plus 10 credits per GB of output the job produces.

• The Rate: about 4¢ per credit on paid plans ($15/mo includes 400 credits).
• The Advantage: Billing is proportional to actual work — a thumbnail from a huge file costs a fraction of a credit.
• The Disadvantage: You estimate in credits rather than file sizes (every job returns its exact cost, so estimates converge fast).

Head-to-Head Scenarios

Scenario A: Pulling a 1-second Thumbnail from a 2 GB MOV file

• Rendi’s Math: You process a 2 GB input to produce a 100 KB output. Rendi bills you for 2.0001 GB processed — about $0.50 of plan value at the Pro plan’s $25 / 100 GB, and still $0.20 even at the $0.10/GB rate of their largest tiers.
• Xora’s Math: Xora reads just the bytes it needs, streams the frame, and exits in seconds. Total: ~0.1 credits — about $0.004.
• Winner: Xora (Save over 99%).

Scenario B: Heavy Compression of a 50 MB MP4 file (takes 3 minutes)

• Rendi’s Math: You process a 50 MB file to output a 25 MB compressed file. Rendi bills you for 75 MB processed (~0.07 GB). Cost: about $0.02 at the Pro plan’s effective rate.
• Xora’s Math: An intensive re-encode uses 3 minutes of processing (3 credits) plus 0.25 credits for the 25 MB output: ~3.3 credits — about $0.12.
• Winner: Rendi, honestly — size-based billing is cheaper when a tiny file needs heavy CPU.

Billing Winner: it depends on your shape — and most media workloads are the first shape. For common operations like thumbnail extraction, video trimming, or stream demuxing, processed-GB pricing introduces massive markups on file size. Credit billing charges the work, not the bytes you happened to attach.

3. Storage & Bandwidth: Bring Your Own Bucket (BYOB)

Where do your files live before and after processing?

Why BYOB Wins

Rendi keeps output files in its hosted storage — public by default, with private storage and presigned URLs reserved for paid plans — metered per GB-month. If you run a high-volume application, pulling those files back to your app hosts adds a network hop to every job.

Xora is designed to be BYOB (Bring Your Own Bucket) first. By adding a simple configuration mapping, your outputs are delivered directly to your own Cloudflare R2 bucket. Because files land in storage you control the moment a job completes, you pay $0.00 in egress bandwidth fees and keep custody of user data.

Storage Winner: Xora. Direct bucket delivery eliminates egress markup and storage locks.

4. Pre-built Recipes vs. Custom CLI Commands

While raw FFmpeg arguments are the primary value, writing custom options arrays for standard, everyday tasks can slow down development.

• Rendi requires you to write the full custom FFmpeg command string for every single task, whether you are doing a complex filter mapping or a simple format conversion.
• Xora features 9 built-in recipes plus a dedicated probe job mode. Recipes include webReady, proxy, compress, trim, thumbnail, concat, and extractAudio. Use mode: "probe" to inspect media metadata without transcoding.

For example, Xora’s webReady recipe doesn’t just run an encode. It probes the source container first. If the file is already browser-compatible, it passes it through instantly. If it only needs faststart optimization (moving metadata to the front), it remuxes in milliseconds. It only re-encodes when it has to — and when a remux is enough, the job bills fractions of a credit instead of a full re-encode’s processing minutes.

Feature Winner: Xora. Pre-configured recipes handle standard tasks out-of-the-box, while the FFmpeg mode is always available as an escape hatch.

Head-to-Head Comparison Summary

Conclusion: Which should you choose?

If you are a senior media engineer who prefers writing raw command strings, has files of moderate sizes, and doesn’t mind storing media on third-party servers, Rendi provides a highly scalable execution runtime.

However, if you are building a SaaS application, course platform, or developer tool where:

1. You want to bypass egress bandwidth markups by delivering files directly to your own buckets.
2. You want fair pricing that doesn’t penalize you for extracting small thumbnails from large files.
3. You want pre-built recipes to handle standard tasks without writing complex FFmpeg command parameters.

Xora provides a more cost-effective, compliant, and developer-friendly infrastructure.

Sign up for a free Xora account and get 25 free credits every month to run your first cloud commands.