Shotstack alternative, the cheapest JSON video API

If you render video from JSON on Shotstack, Rendobar’s Compose API renders the same kind of timeline for $0.04 per minute of output, with no subscription. That is a fifth of Shotstack’s 20-cent pay-as-you-go rate, and still below the 5 cents a minute on its $499 Volume plan. Shotstack keeps a real edge for teams that embed its editor in their own product, and the last section names those cases.

I build Rendobar, and I’d argue Compose costs less, renders faster and does more than Shotstack. This post holds each of those three claims up against Shotstack’s own pricing page, API schema and docs, read on 2026-10-20.

What each Shotstack plan costs per minute#

Shotstack sells minutes of rendered output. Pay as you go is a $10 block of 50 minutes that lasts 12 months. The monthly plans include more minutes, roll unused ones over for 3 months, and pause rendering when you run out until you top up at the plan’s rate.

The per-minute column is the plan price divided by its minutes: $39 ÷ 250 is 15.6 cents, $499 ÷ 10,000 is 4.99 cents. The Rendobar column is the same minutes at $0.04. Compose costs the same on every plan, so the Rendobar figure needs no plan at all.

A few billing details change the comparison at the edges.

• Rounding. Shotstack counts each render by the second, rounded down. Compose rounds up to the whole second and bills at least 15 seconds, which is 1 cent. On a 7-second clip the minimum matters more than the rate.
• Free tier. Shotstack gives 10 credits on sign-up, valid for 30 days. Rendobar gives $5 of credit with no card that never expires, 125 minutes of Compose output.
• Resolution. Shotstack’s pay as you go and Starter render up to 1080p, with 4K from the $99 Pro plan. Rendobar’s Free plan renders up to 1080p at 30 fps, Pro ($9 a month) a plain edit up to 1440p, and Studio ($29 a month) a plain edit up to 4K at 60 fps, all at the same rate. Animated graphics, meaning kinetic text and 3D turns, render up to 1080p at 30 fps on every Rendobar plan.
• Failures. A Compose render that fails on our side costs nothing.

The subscription is optional on Rendobar. Pro and Studio include $5 and $20 of monthly credit and add 25% to credit you buy, so they pay for themselves only if you want their limits or that bonus.

Speed, measured against our old engine#

Compose moved to a new render engine with this release. On our measurements a 21-minute customer timeline renders in 373 seconds, down from 837, and videos of 6 to 20 seconds come back in 17 to 24 seconds. The changelog entry has the before and after.

The 21-minute render works out to about 18 seconds per minute of video. Shotstack’s limitations page estimates “approximately 20 seconds per minute of video”, more with effects and transitions. Those two numbers sit close, and theirs is an estimate while mine is one job, so I am not calling a winner on speed against Shotstack. A per-minute figure also hides startup time, which is why short videos of very different lengths all land in the same 17 to 24 seconds on Compose.

Features side by side#

Both APIs take a timeline of tracks holding clips, and both render MP4 from it. The differences are in what a clip can do and in the tooling around the render.

The case for “most advanced” is the top half of that table, where Compose turns things Shotstack leaves to a JavaScript layer, like Lottie and 3D, into fields you validate before you pay. The bottom half is where Shotstack stays ahead. Its html5 asset is a real escape hatch: anything a browser can draw, it can render. Every feature in Compose is shown rendered on the Compose features page.

Migrating a timeline: the same edit in both formats#

Here is one edit, a video with a title over it for 2.6 seconds, written for each API. The Shotstack version follows its conventions doc, which recommends rich-text and a font loaded by URL.

{
  "timeline": {
    "fonts": [
      { "src": "https://fonts.gstatic.com/s/montserrat/v31/JTUSjIg1_i6t8kCHKm45xW5rygbi49c.ttf" }
    ],
    "tracks": [
      {
        "clips": [{
          "asset": {
            "type": "rich-text",
            "text": "TAKE THE LONG WAY",
            "font": { "family": "JTUSjIg1_i6t8kCHKm45xW5rygbi49c", "size": 120, "color": "#ffffff" }
          },
          "start": 0.3, "length": 2.6
        }]
      },
      {
        "clips": [{
          "asset": { "type": "video", "src": "https://cdn.rendobar.com/compose/showcase/media/road.mp4", "volume": 0 },
          "start": 0, "length": "auto"
        }]
      }
    ]
  },
  "output": { "format": "mp4", "resolution": "1080", "fps": 30 }
}

The same edit as a Compose request, which passed validate_compose with no warnings:

{
  "schemaVersion": 1,
  "output": { "format": "mp4", "size": "1080p", "fps": 30 },
  "timeline": {
    "tracks": [
      { "clips": [
        { "asset": { "type": "video", "src": "https://cdn.rendobar.com/compose/showcase/media/road.mp4", "volume": 0 } }
      ] },
      { "clips": [
        {
          "start": 0.3, "length": 2.6,
          "asset": {
            "type": "text", "text": "TAKE THE LONG WAY",
            "style": { "font": "Montserrat", "size": 120, "color": "#FFFFFF", "align": "center",
                       "animate": { "type": "slideUp", "duration": 0.7 } }
          },
          "transform": { "position": { "x": "50%", "y": "50%" } }
        }
      ] }
    ]
  }
}

What changes when you convert one:

• Reverse the tracks. Shotstack’s tracks[0] is the top layer, and its own docs list getting this wrong as the first mistake. In Compose the first track is the background, so a title track copied across in the same position ends up behind the video.
• Drop the font URLs. Compose loads any Google Font by its family name, and your own files go in the job’s fonts input. Both APIs substitute a font that does not resolve without failing the render, so check names in the validate response.
• Map smart clips. Shotstack’s "length": "auto" is a Compose clip with no length, and "start": "auto" is a clip with no start, which follows the clip before it. "length": "end" means the same thing in both.
• Turn transitions into items. A Shotstack fade is an in or out on one clip, and crossfading two shots means putting them on separate tracks. In Compose you put { "type": "transition", "transition": "crossfade", "duration": 0.8 } between two clips on one track and the engine overlaps them for you. JSON to video API, one timeline to MP4 walks through a longer timeline built that way.
• Replace merge fields with your own templating. Shotstack’s merge find-and-replace has no Compose equivalent. You build the JSON in code, which is where the variable data already lives.

To render the Compose version, save it as timeline.json and submit it:

import { readFile } from "node:fs/promises";
import { createClient } from "@rendobar/sdk";

const rb = createClient({ apiKey: process.env.RENDOBAR_API_KEY });
const params = JSON.parse(await readFile("timeline.json", "utf8"));

// Free: checks the timeline and returns the price without rendering.
const check = await rb.compose.validate(params);
if (!check.valid) throw new Error(JSON.stringify(check));

const job = await rb.jobs.run({ type: "compose", inputs: {}, params });
console.log(job.output.file.url);

curl -X POST https://api.rendobar.com/jobs \
-H "Authorization: Bearer $RENDOBAR_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"type\": \"compose\", \"inputs\": {}, \"params\": $(cat timeline.json)}"

When Shotstack is the better choice#

Pick Shotstack if your customers edit their own videos inside your product. Its white-label Studio SDK comes with every plan, and Rendobar has no editor to embed. The same goes for a team where a designer builds templates by hand and code only fills in merge fields.

It also wins on captions inside one request. A rich-caption clip transcribes the audio and styles the words in the same render, where on Rendobar you run captions.animate first or pass an SRT. And if your graphics already exist as HTML and JavaScript, the html5 asset renders them as they are.

For pricing across more vendors, JSON video API pricing compared runs the same three monthly volumes through six of them. Rendobar vs Shotstack keeps the short version of this comparison.

If your code writes the timeline, I would move it. Every Shotstack plan costs more per minute than Compose, and the conversion is a short script you can check for free before the first render.