HomeBlog

Make.com YouTube Transcript Scenario: Video to Docs on Autopilot

Make.com scenario canvas with an RSS watcher, HTTP module, router, and Google Docs and Airtable branches

Building a Make.com YouTube transcript scenario takes four modules and about ten minutes: watch a channel, fetch the transcript with one HTTP call, parse the JSON, and route the text into Google Docs or Airtable. Here's the exact setup I run, including the config values for the HTTP module.

The scenario shape

  1. RSS — Watch RSS feed items (or the YouTube watch module)
  2. HTTP — Make a request to the transcript API
  3. Router splitting the flow
  4. Google Docs — Create a Document on one path, Airtable — Create a Record on the other

Module 1: watching the channel

You have two options. The YouTube watch module works but wants a Google connection. I prefer the RSS — Watch RSS feed items module, because every YouTube channel already publishes a feed and no connection is needed:

https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID

Swap in the channel's ID (the UC... string from its /channel/ URL or the page source). Each feed item carries the video's title and link; the link is what feeds the next module.

Module 2: HTTP — Make a request

Add the HTTP > Make a request module:

Tell the module to parse the response as JSON (or drop a JSON parse module right after) so the fields become mappable instead of one opaque string. A successful call gives you:

{"result": {"videoId": "...", "title": "...", "pubDate": "...",
            "content": "transcript text ...", "contentSize": 12345, "truncated": false}}

The url parameter accepts any YouTube URL form, or even a bare 11-character video id, so the RSS link maps straight in. For a key, hit https://youtube2text.org/api/demo-key once — it returns a free shared key (yt_...) good for 5 videos a month per IP, enough to build and test the scenario.

Modules 3 and 4: route the text

Add a Router after the HTTP module. On the first path, a Google Docs — Create a Document module with result.title as the name and result.content as the body gives you a readable archive. On the second, an Airtable — Create a Record module with columns for video id, title, publish date, and transcript makes the whole thing filterable and API-queryable later. I keep both: Docs for humans, Airtable for scripts.

If your destination is Notion instead, the mapping is nearly identical — I wrote that variant up in the Notion guide.

The error path you actually need

Videos without captions exist — fresh live streams, music videos, channels that turned captions off. Those return TRANSCRIPT_UNAVAILABLE with status 404, and by default one of them halts your scenario. Attach an error handler to the HTTP module (Resume or Ignore) so caption-less videos pass through quietly. If you're bulk-processing a backlog you may also see RATE_LIMIT_EXCEEDED (429); the response includes retryAfterSeconds, which pairs nicely with a retry.

The operations math

The honest limitation here is Make's own metering: the free tier gives you 1,000 operations a month and won't poll more often than every 15 minutes. This scenario burns roughly five operations per video, so a couple of active channels fit comfortably — but a high-volume setup will want a paid Make tier, or self-hosted n8n, which runs the identical loop with no operation counter. For comparison shopping, the Zapier version exists too, though its task pricing is steeper.

Your own key

The shared demo key is for kicking tires. For a real scenario, sign in with Google at youtube2text.org/app/keys — no phone, no card. Free gets you 5 videos a month; $5.99 covers 50, $9.99 covers 500, and $19.99 is unlimited. At that point the transcript fetching is the cheapest module on your canvas.