Creatomate alternative, JSON video at $0.04 a minute

Rendobar’s Compose API renders a JSON timeline for $0.04 per minute of output, while Creatomate’s Essential plan works out to about $1.01 a minute of 1080p at 30 fps, and its largest listed plan, billed yearly, to about 20 cents. Compose needs no subscription and its credit never expires. Creatomate keeps the better tool for teams where a designer builds the template by hand, and the last section is about them.

Creatomate is the competitor I am writing about here, and Rendobar is the product I build, so every Creatomate figure links to its pricing page or docs as they read on 2026-10-20. I’d argue Compose costs less, renders faster and does more than Creatomate, and of those three the price has the widest margin.

Turning Creatomate credits into minutes#

Creatomate bills credits, and a credit is 100 million rendered pixels. Its docs give the rule: width × height × frame rate × seconds ÷ 100,000,000, rounded up per render, at least 1 credit. A minute of 1080p at 30 fps is 1920 × 1080 × 30 × 60 ÷ 100,000,000, about 37.3 credits. Its pricing page uses 720p at 25 fps as the example, about 14 credits a minute.

The monthly prices for Essential and Growth come from Creatomate’s pricing docs. The pricing page I read showed the yearly totals, which are ten months’ price for twelve. It did not show Beyond’s monthly price, so that row is yearly only. The per-minute column divides each price by its minutes: $54 ÷ 53.6 is $1.01.

At 25 fps every Creatomate figure drops by a sixth, because the frame rate is part of the formula. At 4K it rises fourfold, since a 4K frame has four times the pixels. Compose does neither: the rate is $0.04 a minute at any frame size and frame rate a plan renders, billed per second, rounded up, with a 15-second minimum. 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. Animated graphics stop at 1080p and 30 fps on every plan.

Two more differences decide the bill in a quiet month. Creatomate’s credits do not carry over, so an Essential plan you use for ten minutes still costs $54. Rendobar has no plan to keep, the $5 signup credit covers 125 minutes, and credit never expires. Creatomate’s trial is 50 credits with no card, a little over a minute of 1080p.

Speed#

I found no render time in Creatomate’s documentation, so there is nothing of theirs to set our figure against. On our own measurements, Compose renders a 21-minute timeline in 373 seconds on its new engine, down from 837 on the old one, and short videos of 6 to 20 seconds in 17 to 24 seconds. The compose changelog entry has the details. That is a claim about Compose, not a race against Creatomate.

Features side by side#

Of the JSON video APIs I compare, Creatomate is the closest to Compose on motion. Its element reference documents keyframes on most properties, x_rotation, y_rotation and perspective for 3D, and text animations that split a title into lines.

Where Compose pulls ahead is the edges of that table: Lottie as a clip, transparent WebM for overlays, a free check that returns the price before you spend anything, and an FFmpeg job on the same key for whatever a timeline cannot express. Where Creatomate pulls ahead is the editor. The Compose features page shows every Compose feature rendered.

The same edit in RenderScript and in Compose#

A video with a title that fades in, written as RenderScript from Creatomate’s element reference. I wrote this one from the docs and did not render it on Creatomate.

{
  "output_format": "mp4",
  "width": 1920,
  "height": 1080,
  "elements": [
    { "type": "video", "track": 1, "source": "https://cdn.rendobar.com/compose/showcase/media/road.mp4" },
    {
      "type": "text", "track": 2, "time": 0.3, "duration": 2.6,
      "text": "TAKE THE LONG WAY", "font_family": "Montserrat", "fill_color": "#ffffff",
      "animations": [ { "time": 0, "duration": 0.6, "type": "fade" } ]
    }
  ]
}

The Compose request for the same edit, 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": "fade", "duration": 0.6 } }
          },
          "transform": { "position": { "x": "50%", "y": "50%" } }
        }
      ] }
    ]
  }
}

Converting is mostly renaming.

• track numbers become the order of tracks. The first track is the background in Compose.
• time and duration become start and length. Leave both out and a clip follows the one before it at its own length.
• source becomes src, font_family becomes style.font, and fill_color becomes style.color. Compose loads any Google Font by name.
• An animation flagged as a transition becomes a transition item between the two clips it joins.
• Template modifications have no Compose equivalent. Your code writes the finished JSON, then POST /compose/validate checks it for free.

Save the Compose version as timeline.json and run 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"));

// Checks the timeline and returns the price, without rendering or charging.
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 Creatomate is the better choice#

Choose Creatomate when the person who owns the look is a designer, not a developer. Its template editor builds the video visually and writes the RenderScript for you, and code only sends modifications. Rendobar has no editor, so on Compose someone has to write or generate the JSON.

It also suits renders that need transcription inside one request, through transcript_source, and image-heavy work, where an image costs one credit at any size. If your volume is mostly stills, compare its image pricing before you look at minutes.

JSON video API pricing compared sets Creatomate beside five other vendors at three monthly volumes, and Rendobar vs Creatomate is the short comparison. Rendobar vs Shotstack for JSON video covers the other template-first API.

If developers or an agent write your videos, I would put them on Compose. You pay for the seconds you render at one rate, nothing lapses at the end of the month, and the features that matter most for code-written video are already in the request format.