# How to Set Up Serverless Rendering with Remotion and AWS Lambda: A Complete Guide

> Set up serverless rendering for Remotion videos on AWS Lambda. Discover how to build a scalable, automatic video pipeline without managing servers using the @remotion/lambda package.

- Repository: [Remotion/remotion](https://github.com/remotion-dev/remotion)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Deploy your Remotion video pipeline to AWS Lambda using the `@remotion/lambda` package to create a fully serverless architecture that scales automatically without managing servers.**

Serverless rendering with Remotion and AWS Lambda transforms your video generation workflow into an on-demand service that runs only when needed. The `remotion-dev/remotion` repository provides a complete Lambda integration through dedicated packages that handle deployment, execution, and monitoring of video renders in the AWS cloud.

## Architecture of Serverless Rendering with Remotion and AWS Lambda

The serverless architecture consists of three core components that work together to process video renders without persistent infrastructure.

### Lambda Function Runtime

The **Lambda function** is a Node.js runtime that executes the actual video rendering. According to the source code in [`packages/lambda/src/index.ts`](https://github.com/remotion-dev/remotion/blob/main/packages/lambda/src/index.ts), this function bundles Chrome headless and the Remotion rendering engine to execute video generation inside the AWS environment. The `@remotion/lambda` package provides the `deployFunction()` helper to provision this runtime with specific memory and timeout configurations.

### S3 Site Hosting

Static assets from your Remotion project—including compiled JavaScript bundles, HTML entry points, and media files—must reside in S3. The `deploySite()` function in [`packages/lambda-client/src/index.ts`](https://github.com/remotion-dev/remotion/blob/main/packages/lambda-client/src/index.ts) handles uploading your entry point to a versioned S3 bucket, returning a **serve URL** that the Lambda function fetches at runtime to load your composition code.

### IAM Role and User

Security relies on two IAM entities created in your AWS account: the `remotion-lambda-role` (attached to the Lambda function execution) and the `remotion-user` (owning the access keys used by the CLI and Node APIs). As documented in `packages/docs/docs/lambda/setup.mdx` (lines 18-70), you generate policy JSON via the CLI commands `npx remotion lambda policies role` and `npx remotion lambda policies user`, then apply these policies in the AWS console.

## Prerequisites and Installation

Install the Lambda packages into your existing Remotion project:

```bash
npm install @remotion/lambda

# For backend integration

npm install @remotion/lambda/client

```

The `@remotion/lambda` package contains deployment utilities and the runtime definition, while `@remotion/lambda/client` provides the typed Node.js SDK for rendering workflows.

## Step-by-Step Setup Guide

### Configure AWS IAM Permissions

Generate the required IAM policies using the Remotion CLI as implemented in [`packages/cli/src/lambda-command.ts`](https://github.com/remotion-dev/remotion/blob/main/packages/cli/src/lambda-command.ts):

```bash

# Generate the trust policy for the Lambda execution role

npx remotion lambda policies role

# Generate the user policy for CLI/API access

npx remotion lambda policies user

```

Create the `remotion-lambda-role` in AWS IAM and attach the generated role policy. Create the `remotion-user`, attach the user policy, and generate an access key pair.

### Validate IAM Configuration

Store the credentials in your environment variables:

```bash
REMOTION_AWS_ACCESS_KEY_ID=your_access_key_id
REMOTION_AWS_SECRET_ACCESS_KEY=your_secret_access_key

```

Validate the setup before proceeding:

```bash
npx remotion lambda policies validate

```

### Deploy the Lambda Function

Deploy using the CLI:

```bash
npx remotion lambda functions deploy

```

Or programmatically using the Node.js API from [`packages/lambda-client/src/index.ts`](https://github.com/remotion-dev/remotion/blob/main/packages/lambda-client/src/index.ts):

```typescript
import {deployFunction} from '@remotion/lambda';

const {functionName} = await deployFunction({
  region: 'us-east-1',
  timeoutInSeconds: 120,
  memorySizeInMb: 2048,
  createCloudWatchLogGroup: true,
});

console.log('Deployed function:', functionName);

```

### Deploy Your Remotion Site to S3

Deploy your bundled composition code via CLI:

```bash
npx remotion lambda sites create src/index.ts --site-name=my-video

```

Or programmatically:

```typescript
import path from 'path';
import {getOrCreateBucket, deploySite} from '@remotion/lambda';

const {bucketName} = await getOrCreateBucket({region: 'us-east-1'});

const {serveUrl} = await deploySite({
  bucketName,
  entryPoint: path.resolve(process.cwd(), 'src/index.ts'),
  region: 'us-east-1',
  siteName: 'my-video',
});

console.log('Site URL:', serveUrl);

```

### Render Videos via Lambda

Execute a render using the CLI:

```bash
npx remotion lambda render <serve-url> <composition-id>

```

For backend integration, use the client SDK:

```typescript
import {
  getFunctions,
  renderMediaOnLambda,
  getRenderProgress,
} from '@remotion/lambda/client';

const functions = await getFunctions({
  region: 'us-east-1',
  compatibleOnly: true,
});
const functionName = functions[0].functionName;

const {renderId, bucketName} = await renderMediaOnLambda({
  region: 'us-east-1',
  functionName,
  serveUrl: '<serve-url>',
  composition: '<composition-id>',
  inputProps: {},
  codec: 'h264',
  imageFormat: 'jpeg',
  maxRetries: 1,
  framesPerLambda: 20,
  privacy: 'public',
});

while (true) {
  await new Promise(r => setTimeout(r, 1000));
  const progress = await getRenderProgress({
    renderId,
    bucketName,
    functionName,
    region: 'us-east-1',
  });
  if (progress.done) {
    console.log('Render finished! File:', progress.outputFile);
    break;
  }
  if (progress.fatalErrorEncountered) {
    console.error('Render failed:', progress.errors);
    break;
  }
}

```

## Key Implementation Details

### Version-Locked Functions

Each Lambda function is baked with a specific Remotion version to ensure consistent rendering behavior. When upgrading Remotion, you must redeploy the function using `npx remotion lambda functions deploy` or the `deployFunction()` API. Old functions remain available but should be cleaned up once active renders complete.

### Stateless Rendering Architecture

The Lambda function operates as a stateless worker according to the implementation in [`packages/lambda/src/index.ts`](https://github.com/remotion-dev/remotion/blob/main/packages/lambda/src/index.ts). It receives a serve URL, pulls the compiled JavaScript bundle from S3, runs Chrome headless inside the Lambda runtime, and streams the output back to S3. No persistent storage is required on the function itself, making the architecture inherently scalable and fault-tolerant.

### Concurrency and Quotas

AWS imposes a per-region concurrent invocation quota (default 1000). A single Remotion render can utilize up to 200 concurrent Lambda invocations, meaning the quota directly limits how many videos you can render in parallel. Check your current quota using `npx remotion lambda quotas` and request increases through AWS Support if you need higher throughput.

## Summary

- **Serverless rendering with Remotion and AWS Lambda** eliminates infrastructure management by executing video generation in ephemeral Lambda functions that scale automatically.
- The architecture requires three components: a **Lambda function** (runtime), an **S3 bucket** (static assets), and **IAM roles** (security permissions).
- Use `@remotion/lambda` for deployment operations and `@remotion/lambda/client` for rendering workflows in Node.js applications.
- Always redeploy Lambda functions when upgrading Remotion versions to maintain compatibility and consistent rendering behavior.
- Monitor AWS concurrency quotas carefully, as each video render can consume up to 200 parallel Lambda invocations.

## Frequently Asked Questions

### What AWS region should I use for Remotion Lambda?

Choose a region geographically close to your users or infrastructure to minimize latency. The `us-east-1` region is commonly used and well-supported by Remotion. When deploying, specify the same region consistently across `deployFunction()`, `deploySite()`, and `renderMediaOnLambda()` calls to ensure all components communicate within the same AWS region.

### How do I update the Remotion Lambda function when upgrading versions?

Lambda functions are version-locked to ensure consistent rendering behavior. After upgrading the `@remotion/lambda` package in your project, run `npx remotion lambda functions deploy` to provision a new function with the updated runtime. Old functions remain available for active renders but should be removed using `npx remotion lambda functions rm` once all renders complete to avoid confusion and reduce costs.

### What is the maximum video duration supported by Remotion Lambda?

Video duration is limited by the Lambda function timeout (maximum 900 seconds or 15 minutes) and memory allocation. For longer videos, increase the `timeoutInSeconds` parameter up to the AWS Lambda limit when calling `deployFunction()`, or split the composition into shorter segments that can be rendered in parallel and concatenated afterward using Remotion's stitching capabilities.

### How does Remotion Lambda handle concurrent video renders?

Each video render distributes frames across multiple Lambda invocations (up to 200 per render). AWS imposes a per-region concurrent invocation quota (default 1000), which directly limits how many videos you can render in parallel. Check your current quota using `npx remotion lambda quotas` and request increases through AWS Support if your application requires higher throughput for simultaneous video generation.