How Remotion Licensing Works

“Is Remotion free?” tends to be the first question developers ask before writing their first composition, the React component that defines a video. The honest answer covers a range: free for a large portion of users, including many building commercial products, but with a specific point at which a paid license becomes mandatory.

Getting the licensing wrong in either direction costs you. Assume you need to pay when you do not, and you may delay a project indefinitely. Assume you are covered when you are not, and the gap appears during an acquisition audit or a client’s legal review.

This guide covers who can use Remotion at no cost, when a paid license kicks in, how the two paid pricing structures work, and what the rules mean for agencies, template marketplaces, and cloud rendering. License terms evolve, so the authoritative source is always remotion.dev/license.

---

Remotion’s Source-Available Model

Remotion ships under its own license rather than an MIT or Apache license, which means the source code is public but usage conditions apply. The full code is on GitHub; you can read it, step through it while debugging, modify it for your own purposes, and contribute changes back. Day-to-day development feels identical to working with any open-source library.

The difference from a truly open-source library shows up in two places. First, free use is conditional: certain categories of users get Remotion at no charge, while others need a paid license, whereas an MIT library imposes no such condition. Second, redistribution is restricted: you cannot copy or modify Remotion’s code in order to sell, rent, or sublicense your own version of the framework.

What the license does not restrict is your output and your own code. Videos, GIFs, and images you render belong to you entirely, and the component code you write is yours to license however you choose. One license decision covers the core remotion package and every official package under the @remotion/ prefix.

---

Who Can Use Remotion for Free

The free license applies to four groups: individual developers, freelancers, and hobbyists; for-profit organizations with up to three employees; non-profit and not-for-profit organizations; and anyone evaluating Remotion before committing to production.

The part that surprises most teams is that the free tier explicitly allows commercial use. A two-person startup can build and sell a video product without paying anything, and a solo freelancer can render client videos for money. The trigger for a paid license is organization size, not whether money changes hands.

Two details matter on the employee count. The “up to 3 employees” threshold counts every person at the organization, not just developers who touch Remotion. A ten-person company with a single Remotion developer is already over the limit. The free license carries no usage cap, but it is conditional on staying eligible, so when your team grows past three people you are expected to upgrade.

Here is what a typical composition looks like for a developer on the free tier:

import {
  AbsoluteFill,
  useCurrentFrame,
  useVideoConfig,
  spring,
  interpolate,
} from 'remotion';

export const LaunchTitle: React.FC<{ title: string }> = ({ title }) => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const enter = spring({
    frame,
    fps,
    config: { mass: 0.6, stiffness: 160, damping: 14 },
  });

  const translateY = interpolate(enter, [0, 1], [50, 0]);
  const opacity = interpolate(enter, [0, 1], [0, 1], {
    extrapolateRight: 'clamp',
  });

  return (
    <AbsoluteFill
      style={{
        backgroundColor: '#0a0a0a',
        alignItems: 'center',
        justifyContent: 'center',
      }}
    >
      <h1
        style={{
          fontFamily: '-apple-system, "Segoe UI", Roboto, sans-serif',
          fontSize: 90,
          fontWeight: 800,
          color: '#ffffff',
          transform: `translateY(${translateY}px)`,
          opacity,
        }}
      >
        {title}
      </h1>
    </AbsoluteFill>
  );
};

Nothing in this code changes when you cross the licensing threshold. The license concerns who you are, not which functions you call.

---

When a Paid License Is Required

Once a for-profit organization has four or more people, a Company License is required. The paid model offers two structures that map to how teams actually use the framework.

Seat-based pricing for teams building by hand

A Seat covers one person who writes Remotion compositions directly, including when they use AI coding tools to help write that code. This structure fits teams where developers produce videos through code: motion design systems, internal tooling, and marketing content built programmatically. If three developers at a twenty-person company work on Remotion compositions, that is three Seats. Colleagues who only watch the finished videos do not need Seats, and neither does anyone who works on non-Remotion parts of the codebase.

Usage-based pricing for automated pipelines

For companies building video automation — a prompt-to-video product, a personalized video pipeline, or a product that embeds the player so end users can preview content — licensing is counted by the number of Renders. A Render is one successful, programmatically triggered export of a video, audio file, GIF, PDF, or still image:

import { bundle } from '@remotion/bundler';
import { renderMedia, selectComposition } from '@remotion/renderer';

// Bundling and selecting a composition — not a render yet
const serveUrl = await bundle({ entryPoint: './src/index.ts' });

const composition = await selectComposition({
  serveUrl,
  id: 'LaunchTitle',
  inputProps: { title: 'Launch Week' },
});

// This call, completing successfully, is what counts as one Render
await renderMedia({
  composition,
  serveUrl,
  codec: 'h264',
  outputLocation: 'out/launch-week.mp4',
  inputProps: { title: 'Launch Week' },
});

The same count applies to renderMediaOnLambda(), renderStill(), and CLI commands like npx remotion render.

Browser previews do not count as Renders. You can scrub through a composition in the Remotion Studio development environment, iterate on it, and let end users preview it in the browser without touching your Render count. Only the actual encoding of an output file counts.

For current packaging and prices, check remotion.dev/license directly rather than relying on a blog post.

---

Client Work and Agency Projects

Agency and freelance work is confusing because two organizations are involved. The license resolves this with one principle: the obligation to purchase a license falls on whoever ultimately owns the project’s intellectual property.

In a typical engagement where the client owns the deliverable, the client’s organization size determines licensing. A solo freelancer building a video pipeline for a fifty-person company means the company carries the obligation, not the freelancer.

A second rule covers collaborations. When the combined headcount of the teams working together reaches four or more people, company licensing applies, so two two-person studios jointly building a Remotion project are treated as a four-person team with the obligations that follow.

Practical guidance for agencies running client projects: settle the question in the statement of work by specifying at contract time who owns the project and therefore who carries the license obligation. If you retain ownership of the pipeline and license only the rendered videos to clients, the obligation stays with your organization and scales with your own headcount. Each project’s owner is assessed separately, so one client’s license never covers your work for another.

---

Licensing for Templates

Templates stack two independent licenses, and the distinction matters whether you are buying, selling, or redistributing them.

A template is the author’s own code. This composition depends on Remotion as a dependency, but every line belongs to the author:

import { AbsoluteFill, Sequence } from 'remotion';

export type PromoTemplateProps = {
  headline: string;
  bullets: string[];
  brandColor: string;
};

export const PromoTemplate: React.FC<PromoTemplateProps> = ({
  headline,
  bullets,
  brandColor,
}) => {
  return (
    <AbsoluteFill style={{ backgroundColor: '#0a0a0a' }}>
      <Sequence durationInFrames={60}>
        <TitleScene text={headline} color={brandColor} />
      </Sequence>
      {bullets.map((bullet, i) => (
        <Sequence key={i} from={60 + i * 45} durationInFrames={45}>
          <BulletScene text={bullet} color={brandColor} />
        </Sequence>
      ))}
    </AbsoluteFill>
  );
};

Selling templates is permitted because you are selling your own code that happens to use Remotion, the same way you might sell any React component library. The restriction in the Remotion license targets selling modified versions of Remotion itself, not products built with it. Buying a template does not license Remotion for you: an individual buyer can run a purchased template on the free tier, but a ten-person company running the same template still needs its own Company License. Template terms vary by vendor, so check whether a given license permits client work, resale, or inclusion in a product before purchasing. RenderComp templates ship with full editable TypeScript source intended for exactly that kind of reuse.

One further distinction matters if you build a product around templates. Letting users create and render their own personalized videos based on your template is explicitly permitted. What is not permitted is operating a general-purpose render farm where users can submit arbitrary Remotion projects. Parameterizing your own compositions is fine; reselling Remotion rendering as an open service is not.

The ecosystem’s free and open-source Remotion templates are a good place to see how template authors structure their code and licenses before buying anything.

---

Cloud Rendering

A common misconception is that cloud rendering carries a separate license fee. It does not. The packages that handle cloud rendering on AWS and Google Cloud fall under the same Remotion license, and your obligations are identical wherever rendering happens: your laptop, a build server, or a fleet of cloud functions.

import { renderMediaOnLambda } from '@remotion/lambda/client';

const { renderId, bucketName } = await renderMediaOnLambda({
  region: 'us-east-1',
  functionName: 'remotion-render-4-0-345-mem2048mb-disk2048mb-120sec',
  serveUrl:
    'https://remotionlambda-abcdef.s3.us-east-1.amazonaws.com/sites/promo/index.html',
  composition: 'PromoTemplate',
  codec: 'h264',
  inputProps: {
    headline: 'Q3 Product Update',
    bullets: ['Faster onboarding', 'New reporting', 'API v2'],
    brandColor: '#0B84FF',
  },
});

Three things to keep straight. Your Remotion license and your cloud infrastructure bill are separate: the license is paid to Remotion, while compute costs are billed by AWS or Google directly to your account. A successful cloud render counts the same as a successful local render, so distributing one video across many cloud functions still produces one output and one Render. Running in your own cloud account does not change eligibility, and a four-or-more-person company needs a Company License whether it renders on cloud functions, a dedicated server, or a machine under someone’s desk.

For the actual setup, including deploying functions, managing sites, and handling concurrency, see the Remotion Lambda cloud rendering guide.

---

How Remotion Compares to Open-Source Alternatives

If the source-available model is a blocker for your organization, it is worth understanding the alternatives honestly.

Motion Canvas is an MIT-licensed animation framework that lets you write programmatic animations in TypeScript with no usage conditions at any team size. It uses its own component model rather than React, and it is designed around interactive editing rather than server-side rendering at scale.

FFmpeg is a command-line video processing tool, licensed under LGPL or GPL depending on build configuration, and battle-tested across decades of production use. It imposes no usage conditions, but compositing with FFmpeg means writing filter graphs, a configuration-driven approach to layering clips and effects, and anything beyond cuts, overlays, and simple text quickly becomes difficult to maintain.

Proprietary video APIs sit at the opposite end of the spectrum, offering no source access, no self-hosting, and template logic locked to a vendor’s editor. Those trade-offs are covered in depth in the Remotion vs Creatomate comparison.

Remotion’s license is the price of a React-native programming model with production-grade cloud rendering maintained by a dedicated team. For individuals and small teams that price is zero. For larger companies, the question is whether writing videos as React components improves developer speed enough to justify the cost, and for teams already working in TypeScript the answer is usually yes.

---

Summary

Remotion is source-available, not MIT-licensed: full public source code with usage conditions attached.

The free tier covers individuals, for-profit teams of up to three employees (all employees counted), non-profits, and evaluation use, with commercial projects permitted.

A Company License is required at four or more people. Seat-based pricing covers people who write Remotion code. Render-based pricing covers automated pipelines, where each successful export counts as one Render and browser previews never count.

For client work, the obligation falls on whoever owns the project. Combined headcounts of four or more across collaborating teams trigger company licensing.

Template sales are permitted because you are selling your own code. Buying a template never substitutes for your own Remotion license. Personalized-video products built on your own templates are allowed, but open render farms are not.

Cloud rendering changes nothing about licensing: same rules, same Render counting, with infrastructure billed separately by your cloud provider.

Verify current terms at remotion.dev/license before committing to a production project.

---

Skip the Blank Canvas with RenderComp

Once licensing is settled, the next bottleneck is build time. RenderComp offers a catalog of production-ready Remotion templates covering intros, lower thirds, data visualizations, social formats, and more, each shipping as full editable TypeScript source with typed prop interfaces, ready to drop into your licensed or free-tier project and start rendering on day one.

Browse the collection at rendercomp.com.