# JSON2Video alternative, cheaper per minute of video

Canonical: https://rendobar.com/blog/json2video-alternative/
Author: Abdelrahman Essawy
Published: 2026-10-20

---

## Key takeaways

- A JSON2Video workload costs less on Rendobar at every published tier, and the free credit renders video you can ship, with no watermark and no commercial-use restriction.
- I'd argue Compose costs less, renders faster and does more than JSON2Video. Here the price gap is wide and sourced. The speed figures are ours and theirs, measured differently, so treat them as a ballpark.
- You do not have to give up scenes to move. Compose accepts a scene list with overlays, the same shape JSON2Video uses, or full tracks when a layer has to run across scene boundaries.
- Stay on JSON2Video if you depend on its built-in text-to-speech voices, its HTML element, or cached re-renders of identical movies.

Rendobar's Compose API renders the same scene-by-scene videos as JSON2Video for $0.04 per minute of output, with no subscription and no watermark on free renders. JSON2Video's published plans work out to between about 20 and 42 cents a minute, depending on whether you subscribe or buy a credit pack. It still wins on built-in voice-overs, which Compose does not generate, and the last section says where else.

I make Rendobar, so every competitor figure below links to JSON2Video's own pricing page or documentation, read on 2026-10-20. I'd argue Compose costs less, renders faster and does more than JSON2Video, and this post checks each of those claims in turn.

## What a minute costs on each JSON2Video plan

JSON2Video bills one credit per second of rendered video, at any resolution its plan allows. Subscription credits expire at the end of each month. Pre-paid packs do not expire.

| JSON2Video plan | Price | Credits | Minutes | Per minute | Same minutes on Rendobar |
|---|---:|---:|---:|---:|---:|
| Free | $0 | 600 once | 10 | $0, watermarked | $0.40 |
| Hobby (yearly) | $199.50/yr | 3,000/mo | 50/mo | $0.333 | $2.00 |
| Professional | $49.95/mo | 12,000/mo | 200/mo | $0.250 | $8.00 |
| Startup | $99.95/mo | 30,000/mo | 500/mo | $0.200 | $20.00 |
| Pre-paid pack | $49.95 once | 7,200 | 120 | $0.416 | $4.80 |
| Pre-paid pack | $99.95 once | 15,600 | 260 | $0.384 | $10.40 |

Each per-minute figure is the price over its minutes. Hobby is $16.63 a month billed as $199.50 a year, so 50 minutes cost 33 cents each. The best published JSON2Video rate, Startup at just under 20 cents, is about five times the Compose rate. The pre-paid packs, the closest thing JSON2Video has to pay as you go, run about ten times it.

The free plans differ more than the prices. JSON2Video's free plan is 600 credits once, for personal and evaluation use only, with a watermark, a 60-second cap per video and a 1080p ceiling. Rendobar's $5 signup credit covers 125 minutes of Compose output with no card, renders up to 1080p at 30 fps with no watermark, and never expires.

Two smaller billing differences. Compose rounds each render up to the whole second and bills at least 15 seconds, 1 cent. JSON2Video says a failed render is not billed. On Rendobar a render that fails on our side is free, and one that fails because your input may be the cause, such as a source that will not decode, pays twice the compute it used. Video length differs too: JSON2Video caps one movie at 30 minutes on every paid plan, and a Compose video has no length cap of its own beyond the job's run time, an hour on Free and nine hours on Pro and Studio.

## Render speed, with the caveat

On our measurements a 21-minute timeline renders in 373 seconds on the new Compose engine, about 18 seconds per minute of video, and short videos of 6 to 20 seconds come back in 17 to 24 seconds. The [compose changelog](/changelog/compose-faster-priced-by-length/) has the numbers against our previous engine.

JSON2Video publishes a typical render time of 30 to 90 seconds for a one-minute video, and its docs say scenes render in parallel, so the longest scene sets the time. I have not run the same movie on both, so this is their published estimate against our measured job. It points one way, and it is not a benchmark.

## Scenes, tracks and features

JSON2Video describes a movie as scenes played back to back, each with its own elements, plus movie-level elements such as a soundtrack that span the whole video. Scenes cannot overlap in time, except for the transition into the next one. Compose takes the same shape as `timeline.scenes` with `overlays`, or full `timeline.tracks` when one layer has to cross scene boundaries.

| | Rendobar Compose | JSON2Video |
|---|---|---|
| Structure | Scenes with overlays, or tracks | Scenes in sequence, plus movie-level elements |
| Keyframes | Position, scale, rotation, opacity, size, colour, effect settings and volume | `x`, `y`, `width`, `height` and `zoom` |
| Kinetic text | Titles arrive and leave by letter, word or line | Preset text styles and animated components |
| 3D | `rotateX`, `rotateY` and `perspective` on overlays and tracks | 2D rotate |
| Lottie | `animation` asset | Not among its element types |
| Effects | Grades, blurs, keys, glows and named filters on a clip, track or the whole video | Chroma key and masks per element |
| Voice-over | Not generated. Bring an audio file | `voice` element with text-to-speech |
| Subtitles | `subtitles` clip from cues or an SRT or VTT file, transcription as a separate `captions.animate` job | `subtitles` element, generated automatically |
| HTML | No | `html` element |
| Check before rendering | `POST /compose/validate`, free, returns the price | `validate_movie` in its CLI's MCP server, against the schema |
| MCP | Hosted server, no install, every plan | Local server from the `@json2video/cli` package |
| Output | MP4, WebM, GIF, MP3, JPG, PNG, transparent WebM and PNG | MP4 by default, and movies with a transparent background |
| Raw FFmpeg on the same key | Yes | No |

The "most advanced" half of that table is the motion and effects rows. JSON2Video's keyframes move and size an element, and Compose keyframes nearly every numeric field, adds 3D turns and Lottie, and applies a grade to a whole track or the finished picture. The [Compose features page](/compose/features/) shows each one rendered.

## Moving a movie across: scenes to scenes

JSON2Video's own docs build a property listing out of scenes like these:

```json
{
  "resolution": "full-hd",
  "scenes": [
    { "duration": 4, "transition": { "style": "fade", "duration": 0.5 }, "elements": [ { "type": "image", "src": "https://cdn.json2video.com/assets/images/sample-house-front.jpg" }, { "type": "text", "text": "Exterior", "position": "bottom-left", "x": 60, "y": -60 } ] },
    { "duration": 4, "transition": { "style": "fade", "duration": 0.5 }, "elements": [ { "type": "image", "src": "https://cdn.json2video.com/assets/images/sample-house-kitchen.jpg" }, { "type": "text", "text": "Chef's Kitchen", "position": "bottom-left", "x": 60, "y": -60 } ] }
  ]
}
```

The Compose version of two titled scenes with a crossfade between them, which passed `validate_compose` with no warnings:

```json
{
  "schemaVersion": 1,
  "output": { "format": "mp4", "size": "1080p", "fps": 30 },
  "timeline": {
    "scenes": [
      {
        "duration": 3,
        "clips": [
          { "asset": { "type": "video", "src": "https://cdn.rendobar.com/compose/showcase/media/coast-a.mp4" } },
          { "asset": { "type": "text", "text": "ONE", "style": { "font": "Bebas Neue", "size": 88, "color": "#FFFFFF" } } }
        ]
      },
      {
        "duration": 3,
        "transition": { "transition": "crossfade", "duration": 0.8 },
        "clips": [
          { "asset": { "type": "video", "src": "https://cdn.rendobar.com/compose/showcase/media/coast-b.mp4" } },
          { "asset": { "type": "text", "text": "TWO", "style": { "font": "Bebas Neue", "size": 88, "color": "#FFFFFF" } } }
        ]
      }
    ]
  }
}
```

The mapping is close to one to one.

- A JSON2Video scene's `elements` become a Compose scene's `clips`. The first clip is the background and later clips draw over it, which replaces `z-index` in most scenes.
- `"transition": { "style": "fade" }` becomes `"transition": { "transition": "crossfade" }`. Compose also has fade through black, slide, push, wipe and zoom.
- Movie-level `elements`, such as a logo or a soundtrack, become `overlays`, which span the whole video when you leave out their length.
- `"resolution": "full-hd"` becomes `"size": "1080p"`, and named social sizes such as `shorts` replace `instagram-story`.
- `variables` and `template` have no Compose equivalent. You fill the values in code before you send the JSON.
- `voice` elements need an audio file. Generate the speech elsewhere and point an `audio` clip at it.

Save the Compose version as `timeline.json`, check it, then render it:

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

// Free: the same checks a render runs, plus the price.
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={`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 JSON2Video is the better choice

Pick JSON2Video if narration is the product. Its `voice` element turns text into speech inside the same movie, with subtitles generated from it, and on Rendobar you would produce the audio first and add it as a clip.

It also fits a team that builds in its visual editor and fills templates from a spreadsheet, and anyone who re-renders identical movies. Its docs say a resubmitted movie with the same JSON comes back from cache, essentially free and instant. If your graphics already exist as HTML, its `html` element renders them directly.

For the same comparison across more vendors, [JSON video API pricing compared](/blog/json-video-api-pricing-compared/) prices three monthly volumes on six of them, and [Rendobar vs JSON2Video](/vs/json2video/) has the short form.

If your own code writes the movie, I would switch. The scene model carries over almost field for field, the per-minute price drops to about a fifth or less, and the free credit renders something you are allowed to publish.