Notion to Video: Auto-Render on Row Change with Make

You've got a Notion database full of product names, launch dates, and promo copy. Every time you add or update a row, someone has to manually open a video editor, swap in the new text, export, and upload. That process takes 15 minutes if you're fast. If you're doing it 20 times a week, you've lost a full day.

There's a better way. You can connect Notion to Make.com, hit the FFmpeg Micro API on every row change, and get a rendered video back automatically.

Why Notion + Make + FFmpeg Micro

Notion works well as a lightweight CMS. A lot of no-code founders already use it to manage product catalogs, content calendars, and launch schedules. Make.com (formerly Integromat) watches for changes in that Notion database and fires off actions. FFmpeg Micro handles the actual video rendering via a simple REST API.

The full loop looks like this: Notion row updates, Make picks it up, Make calls FFmpeg Micro with the row data as a text overlay on a template video, and the rendered file URL comes back in the response.

No video editing software. No manual exports. No context switching.

Setting Up the Notion Database

Your Notion database needs at least these properties:

The Status property is important. You'll use it in Make to filter out rows that have already been processed, so you don't re-render the same video every time someone edits a typo in an unrelated column.

Building the Make.com Scenario

In Make.com, create a new scenario with these modules:

- URL: https://api.ffmpeg-micro.com/v1/transcodes
- Method: POST
- Headers:
- Authorization: Bearer YOUR_API_KEY
- Content-Type: application/json
- Body type: Raw
- Content type: JSON
- Request content: (see below)

The FFmpeg Micro API Request

The key part is the @text-overlay option, which burns text directly onto your template video.

{
  "inputs": [
    {"url": "{{1.properties.Template Video URL.url}}"}
  ],
  "outputFormat": "mp4",
  "options": [
    {
      "option": "@text-overlay",
      "argument": {
        "text": "{{1.properties.Title.title[0].plain_text}}",
        "style": {
          "fontSize": 48,
          "charsPerLine": 20,
          "lineSpacing": 12,
          "x": "(w-text_w)/2",
          "y": "(h-text_h)/2"
        }
      }
    }
  ]
}

The double-brace syntax ({{1.properties.Title...}}) is Make.com's way of referencing data from the Notion module. You're pulling the title directly from the row and injecting it into the video overlay.

If you want to test this outside of Make first, here's the equivalent curl:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [
      {"url": "https://storage.example.com/template-background.mp4"}
    ],
    "outputFormat": "mp4",
    "options": [
      {
        "option": "@text-overlay",
        "argument": {
          "text": "Product Launch: Acme Widget",
          "style": {
            "fontSize": 48,
            "charsPerLine": 20,
            "lineSpacing": 12,
            "x": "(w-text_w)/2",
            "y": "(h-text_h)/2"
          }
        }
      }
    ]
  }'

The FFmpeg Micro API returns a JSON response with the URL of your rendered video. You can grab that URL in the next Make module and write it back to Notion, send it via Slack, or upload it wherever you need.

Adding a Second Text Line

Want both a title and a description on the video? Add another object to the options array with a different y position:

{
  "option": "@text-overlay",
  "argument": {
    "text": "{{1.properties.Description.rich_text[0].plain_text}}",
    "style": {
      "fontSize": 32,
      "charsPerLine": 30,
      "x": "(w-text_w)/2",
      "y": "(h/2)+80"
    }
  }
}

This puts the description text below center. Adjust the y math and fontSize to match your template's layout.

Common Pitfalls

Triggering on every edit. Without the Status filter, your Make scenario fires on every single property change. Someone fixes a typo in the description and you've burned an API call re-rendering a video that was already done. Always gate renders behind a Status value like "Ready to Render."

Template video not publicly accessible. FFmpeg Micro needs to fetch your template video via URL. If it's behind auth or in a private S3 bucket without a presigned URL, the request will fail. Make sure the URL is reachable.

Text overflow. If your Notion title is 200 characters and your charsPerLine is set to 20, you'll get 10 lines of text that might extend beyond the video frame. Set reasonable charsPerLine values and consider truncating long text in Make before sending it to the API.

Make.com timeout settings. Video rendering can take a few seconds depending on the input file size. Bump the HTTP module's timeout in Make to at least 60 seconds so it doesn't cut the connection early.

FAQ

Can I use a Notion formula field as the overlay text? Yes. As long as the formula outputs plain text, you can reference it in Make the same way you'd reference any other Notion property. Map it into the `text` field of the `@text-overlay` argument.

Does Make.com trigger on new rows or just updates? The Notion module in Make.com supports both. You can use "Watch Database Items" for updates or "Watch Database Items (Created)" for new rows only. For this workflow, watching for updates with a Status filter gives you the most control.

What video formats does FFmpeg Micro support for the template? FFmpeg Micro accepts any format FFmpeg can decode as an input, including MP4, MOV, WebM, and AVI. Set `outputFormat` to your desired output. MP4 is the safest choice for broad compatibility.

How long does a typical render take? For a 30-second template video with a text overlay, expect 3 to 8 seconds. Longer videos or higher resolutions take more time, but most social-format clips come back in under 10 seconds.

Can I chain multiple Notion databases into one Make scenario? You can. Add multiple Notion watch modules in the same Make scenario, each monitoring a different database, and route them all into the same HTTP module. Use Make's router to adjust the overlay text or template URL per database.

Start Rendering

Grab an FFmpeg Micro API key at ffmpeg-micro.com, set up the Make scenario, and run a test with one Notion row. Once you see that first video come back rendered with your Notion data burned in, you'll want to automate every template you've got.