You already have a Remotion composition. You want an MP4 out of it, and you do not want to deploy Remotion Lambda, or keep an AWS account, S3 bucket and function in step with your Remotion version.

This walkthrough uses PennyCompute's remotion.render.v1 job. You bundle the project, host the bundle (here or at your own public link), submit the composition and its props, then download the finished file. The same flow is documented on the Remotion rendering guide. Field names and paths below are taken from the public OpenAPI document at https://api.pennycompute.com/openapi.json (buyer API 1.10.1).

What you need

  • A Remotion project built with 4.0.530, the version the renderers run. Bundles from this version are relocatable.
  • A PennyCompute account and a server API key from https://app.pennycompute.com. Keys start with pc_live_ and are shown once. Send the key as Authorization: Bearer <key> on every API call. Uploads to a returned upload_url do not use the key.
  • Node.js 18 or later, for the bundle-upload script (it uses fetch and node:crypto). curl is enough once you already have a public serve_url.

A new account starts with $5 in its prepaid balance. Failed, cancelled and expired jobs are not charged.

What a render costs

Live rates are on https://pennycompute.com/pricing. A successful remotion.render.v1 job is billed $0.0037 per render plus $0.0048 per minute of output up to 1080p, or $0.017 per minute above 1080p, billed by the second. A still frame rendered as a PNG is $0.0037. Queue time is not charged.

Those rates, applied as arithmetic rather than as a timed run of a particular composition, give:

  • one minute of output up to 1080p: $0.0037 + $0.0048 = $0.0085
  • ten minutes of output up to 1080p: $0.0037 + (10 × $0.0048) = $0.0517
  • one minute above 1080p: $0.0037 + $0.017 = $0.0207

Always confirm the live card before you budget a production run.

POST /v1/jobs/estimate takes the same service_id and input as a job. It creates no job, reserves nothing, and does not fetch your bundle. For Remotion, price_is_final is false. The price_micros figure is not computed by opening the bundle or reading the composition: it uses frame_range when you send one (the inclusive frame count divided by 30 fps), or a 20-second default when frame_range is absent. The completed job is charged for the length of its actual output.

Remotion publishes its own AWS Lambda compute examples at https://www.remotion.dev/docs/lambda/cost-example (accessed 22 November 2026). Those figures are for named compositions in us-east-1, with 2048 MB RAM and 10240 MB disk, and Remotion states that they cover only Lambda compute — not S3, CloudWatch, or a company license for teams of four or more. They are not a like-for-like benchmark against a PennyCompute job. A longer comparison, with the same caveat, is on Cheap Remotion rendering. Remotion's own license terms still apply to your project.

1. Bundle the project

npx remotion bundle 

The default output folder is build. It must contain index.html at the root. A bundle can have up to 256 nonempty files, each up to 100 MB, and 1 GB in all.

2. Host the bundle

You can point serve_url at the index.html of a bundle you already host, as long as the whole folder stays readable until the job has ended. Or you can host it through POST /v1/assets.

For a bundle, the request body is a files array: every nonempty regular file in build, with its relative path (no leading slash), exact byte length, and SHA-256 in hex. Skip symbolic links. One of the paths must be index.html. The response is a serve_url for that index.html on an isolated origin, plus an upload_url for each file. PUT the bytes to each upload_url with a Content-Length that matches bytes. Those PUTs need no API key and return 201. The bytes must match the SHA-256 you declared; a mismatch is digest_mismatch.

The same manifest returns the same serve_url. Uploaded files stop being served 24 hours after their PUT, and are swept after a further 48-hour margin, so submit the render while the bundle is still readable.

Here is a self-contained Node.js script that walks build, prepares the manifest, uploads every file, estimates the job, submits it, waits until a final status, and downloads the MP4.

// render-remotion.mjs import { createHash } from "node:crypto"; import { readdir, readFile, writeFile } from "node:fs/promises"; import { join } from "node:path"; const API = "https://api.pennycompute.com"; const KEY = process.env.PENNYCOMPUTE_API_KEY; const JOB_KEY = process.env.PENNYCOMPUTE_JOB_KEY; // 8–128 characters, unique for this submission if (!KEY) throw new Error("Set PENNYCOMPUTE_API_KEY"); if (!JOB_KEY || JOB_KEY.length < 8) throw new Error("Set PENNYCOMPUTE_JOB_KEY (8–128 characters)"); async function api(method, path, { body, idempotencyKey } = {}) { const headers = { Authorization: "Bearer " + KEY, Accept: "application/json", }; if (body !== undefined) headers["Content-Type"] = "application/json"; if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey; const res = await fetch(API + path, { method, headers, body: body !== undefined ? JSON.stringify(body) : undefined, }); const text = await res.text(); const data = text ? JSON.parse(text) : null; if (!res.ok) { const err = new Error((data && data.error) || res.statusText); err.status = res.status; err.body = data; throw err; } return data; } async function bundleFiles(directory, prefix = "") { const files = []; for (const entry of await readdir(directory, { withFileTypes: true })) { const path = prefix ? prefix + "/" + entry.name : entry.name; const local = join(directory, entry.name); if (entry.isSymbolicLink()) continue; if (entry.isDirectory()) { files.push(...(await bundleFiles(local, path))); continue; } if (!entry.isFile()) continue; const bytes = await readFile(local); if (bytes.length === 0) continue; // empty files are refused files.push({ path, bytes: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex"), body: bytes, }); } return files; } const files = await bundleFiles("build"); if (!files.some((f) => f.path === "index.html")) { throw new Error("build/index.html is missing. Run npx remotion bundle first."); } const prepared = await api("POST", "/v1/assets", { body: { files: files.map(({ path, bytes, sha256 }) => ({ path, bytes, sha256 })) }, }); for (const upload of prepared.uploads) { const file = files.find((f) => f.path === upload.path); const put = await fetch(upload.upload_url, { method: "PUT", body: file.body, headers: { "Content-Length": String(file.bytes) }, }); if (put.status !== 201) { throw new Error("Upload failed for " + upload.path + ": " + put.status + " " + (await put.text())); } } const input = { serve_url: prepared.serve_url, composition_id: "MyComposition", input_props: { title: "Point Reyes" }, // Optional: render only the first second at 30 fps, inclusive. // frame_range: [0, 29], }; const estimate = await api("POST", "/v1/jobs/estimate", { body: { service_id: "remotion.render.v1", input }, }); console.log("estimate USD:", Number(estimate.price_micros) / 1e6, "final?", estimate.price_is_final); console.log("typical render seconds once started:", estimate.estimated_render_seconds); console.log("free slots:", estimate.free_slots); const job = await api("POST", "/v1/jobs", { idempotencyKey: JOB_KEY, body: { service_id: "remotion.render.v1", input }, }); console.log("job", job.id, job.status); const final = new Set(["succeeded", "failed", "cancelled", "expired"]); let current = job; while (!final.has(current.status)) { await new Promise((r) => setTimeout(r, 3000)); current = await api("GET", "/v1/jobs/" + job.id); console.log(current.status); } if (current.status !== "succeeded") { throw new Error( current.status + " " + (current.failure_code || "") + " " + (current.failure_message || ""), ); } const { url } = await api("GET", "/v1/jobs/" + job.id + "/output"); const mp4 = await fetch(url, { signal: AbortSignal.timeout(120000) }); if (!mp4.ok) throw new Error("Download failed: " + mp4.status); await writeFile("output.mp4", Buffer.from(await mp4.arrayBuffer())); console.log("wrote output.mp4, duration_seconds:", current.result && current.result.duration_seconds); console.log("final charge USD:", Number(current.charged_fee_micros) / 1e6); 

The official guide also shows this flow with the v1.mjs client from the API quickstart (uploadBundle and submit). The script above talks to the same endpoints, so you can run it without that client file.

3. The same calls in curl

Once serve_url is known — from the upload above, or from a bundle you host yourself — the job is three HTTP calls. Idempotency-Key is required on POST /v1/jobs (8–128 characters). Repeating the same key with the same body returns the original job and does not create or charge a second one. The same key with a different body returns 409 idempotency_conflict.

# Preview the charge. This does not create a job. curl -sS https://api.pennycompute.com/v1/jobs/estimate \ -H "Authorization: Bearer $PENNYCOMPUTE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "service_id": "remotion.render.v1", "input": { "serve_url": "https://example.com/your-bundle/index.html", "composition_id": "MyComposition", "input_props": { "title": "Point Reyes" }, "frame_range": [0, 29] } }' 

The estimate includes price_micros, price_is_final, estimated_render_seconds (typical time once a renderer starts; queue time is extra), free_slots, and low/high ranges for start and completion in estimated_start_seconds and estimated_complete_seconds. You can also read slot counts alone with GET /v1/services/remotion.render.v1/capacity. A free_slots value of 0 means a new job waits in the queue, up to max_wait_seconds; it is not refused.

curl -sS https://api.pennycompute.com/v1/jobs \ -H "Authorization: Bearer $PENNYCOMPUTE_API_KEY" \ -H "Content-Type: application/json" \ -H "Idempotency-Key: $PENNYCOMPUTE_JOB_KEY" \ -d '{ "service_id": "remotion.render.v1", "input": { "serve_url": "https://example.com/your-bundle/index.html", "composition_id": "MyComposition", "input_props": { "title": "Point Reyes" } } }' 

The response is a job with status set to queued. Poll until it is final:

curl -sS "https://api.pennycompute.com/v1/jobs/$JOB_ID" \ -H "Authorization: Bearer $PENNYCOMPUTE_API_KEY" 

Statuses are queued (waiting for a renderer, occupying no slot), active (a renderer is working), cancelling, then one of succeeded, failed, cancelled, or expired. A queued job waits up to max_wait_seconds (default 900) for a renderer; after that it becomes expired with failure_code no_capacity and is not charged. An organization can have 8 jobs running and 50 queued; a submission beyond that returns 429.

When status is succeeded, request the public link and download the file. The link needs no API key, accepts byte ranges, and remains valid for 3 days after the render finishes.

curl -sS "https://api.pennycompute.com/v1/jobs/$JOB_ID/output" \ -H "Authorization: Bearer $PENNYCOMPUTE_API_KEY" # -> { "url": "https://..." } curl -sS -o output.mp4 "$OUTPUT_URL" 

The job's charged_fee_micros is the final charge in millionths of a US dollar. result includes measured duration_seconds, width and height. If the job has not succeeded, the output endpoint returns 409 output_not_ready.

Optional input you will actually use

The required input fields are serve_url and composition_id. Everything else is optional.

  • input_props is any JSON your composition reads. For props too large for the request, host a JSON file of up to 64 MB and pass input_props_url instead (not together with a non-empty input_props).
  • frame_range is [first, last], inclusive. Omit it to render every frame.
  • still_frame renders one frame as a PNG instead of a video, for $0.0037. It cannot be combined with frame_range or the sound and bitrate fields.
  • remote_assets is a list of up to 64 public https files, each up to 1 GB. The renderer downloads the file and writes its local path into input_props at input_props_path (for example voiceover.src). Use it only for media the page cannot fetch itself; https media already named in your props is loaded by the page.
  • output_container is mp4 (default), webm or mov. video_codec defaults to h264; webm needs vp8 or vp9.

If you set nothing else, the output is H.264 in an MP4 at CRF 18, with the x264 preset medium, frames captured as JPEG at quality 80, and yuv420p. Sound is AAC at 320 kbps and 48,000 Hz. Bundle the fonts your composition draws with; system fonts differ between renderers and are not something to count on. Details on codecs, sound finishing, resolved_props, and the Chrome build the renderers use are on the Remotion rendering guide.

To burn captions, stitch clips, or mix a soundtrack after the render, send the finished file's output link into a second FFmpeg job (ffmpeg.caption_burn.v1, ffmpeg.stitch_export.v1, or ffmpeg.audio_mix.v1). That output link is kept for 3 days.

When something goes wrong

A 400 on submit means the request did not validate (error is invalid_request, with an issues list). A call with no key, or with an unknown or revoked one, is 401 unauthorized. Repeating an idempotency key with a different body is 409 idempotency_conflict. A renderer problem, a link that could not be fetched, or a composition that failed to render lands on failed with a failure_code and failure_message; that job is not charged. Cancel with POST /v1/jobs/{id}/cancel if you no longer need a queued or running job.

See also

Adam King