How to Auto-Generate YouTube Thumbnails with Make.com (Step-by-Step)

Thumbnail creation is the last manual step in most content pipelines. You write the video title, edit the footage, write the description — and then you open Canva or Photoshop and spend 20 minutes designing an image you could have generated in under 30 seconds.

This guide closes that gap with Make.com (the visual no-code automation platform, formerly Integromat). By the end you will have a scenario that takes any title and returns a production-ready thumbnail you can save to Google Drive, attach to a Slack message, or set as a WordPress featured image. The whole setup is under 10 minutes if you use the public scenario template.

If you prefer code-first workflows in n8n, see the n8n version of this guide. This post is the Make.com-specific deep dive.

What You Are Building

The core scenario is:

1. Receive a trigger (RSS, YouTube watch videos, Google Sheets row, Webhook — anything that produces a title)
2. Send the title to ThumbAPI via an HTTP module
3. Decode the base64 image response into binary data
4. Upload the thumbnail to Google Drive, post to Slack, or push to your CMS

Make.com handles the entire flow in a visual canvas — no code required beyond a few small formulas in the variable transform step.

Prerequisites

Before starting, you need:

• A Make.com account (free tier covers 1,000 ops/month — more than enough for this scenario)
• A ThumbAPI account with an API key (free tier: 5 generations/month, no credit card)
• A Google Drive account if you want to use the Drive destination shown in the examples

Plug-and-Play: Clone the Public Scenario

The fastest path is to clone the ready-made scenario in one click:

Clone the Make.com scenario template →

The clone drops three modules into your Make account:

1. Set variable — a placeholder trigger holding a sample title.
2. HTTP — Make a request — POSTs to the ThumbAPI generate endpoint.
3. Set multiple variables — strips the base64 data URI prefix and computes a fileName + mimeType you can feed into any file module.

The cloned scenario ships with the public test key thumbapi_test. That key returns a static placeholder image so you can confirm the wiring works without spending credits. To generate real thumbnails, swap it for your own API key from app.thumbapi.dev.

If you want to understand what each module does (or build it from scratch in your own scenario), the next sections walk through every step.

Step 1: Get Your ThumbAPI Key

Sign up at app.thumbapi.dev and copy your API key from the dashboard. The free plan includes 5 generations per month — enough to test and build the scenario.

You will paste this key into the HTTP module's headers in the next step.

Step 2: Create a New Scenario and Add a Trigger

In Make.com, click Create a new scenario (top right of the dashboard). The trigger module determines what kicks off thumbnail generation:

• YouTube — Watch Videos — fires when you publish a new video.
• RSS — Watch RSS Feed Items — works for any blog or YouTube channel that exposes a public feed.
• Google Sheets — Watch Rows — for content calendars where each row is one title.
• Webhook — Custom Webhook — universal, your own app POSTs the title.
• Tools — Set variable — a manual placeholder useful while testing.

Connect your account, then Run this module once to load sample data. Make uses the sample to populate field mappings in downstream modules.

Step 3: Add the HTTP Module

Click + after your trigger and search for HTTP. Select Make a request. This is Make's built-in module for calling external APIs.

Configure it as follows:

URL:                 https://api.thumbapi.dev/v1/generate
Method:              POST

Headers (Add item):
  Name:  x-api-key
  Value: YOUR_THUMBAPI_KEY
  Name:  Content-Type
  Value: application/json

Body type:           Raw
Content type:        JSON (application/json)
Request content:     (see below)
Parse response:      Yes

In the Request content field, paste:

{
  "title": "{{1.title}}",
  "format": "youtube",
  "imageStyle": "faceless",
  "outputFormat": "webp"
}

The {{1.title}} expression pulls the title from the trigger module (module 1 in your scenario). When you click into the field, Make's right-side panel shows available variables — click the title variable to insert the reference automatically.

Format and Style Options

Parameter	Options
format	youtube, instagram, x, blogpost, linkedin
imageStyle	faceless, with-image, with-logo
outputFormat	webp (default), png

For YouTube, faceless generates text-and-graphic designs optimized for click-through. Switch to with-image if you have uploaded a profile photo in the ThumbAPI dashboard and want your face included.

Step 4: Test the HTTP Module

Right-click the HTTP module and select Run this module only. Make sends the request to ThumbAPI and displays the response:

{
  "image": "data:image/webp;base64,UklGR...",
  "format": "youtube",
  "outputFormat": "webp",
  "dimensions": {
    "width": 1280,
    "height": 720
  }
}

The image field is the full base64-encoded WebP. With Parse response: Yes, Make automatically extracts image, format, outputFormat, and dimensions as mappable variables for downstream modules.

If the module fails, check:

• The header name is exactly x-api-key (not Authorization)
• The API key is correct and active in your ThumbAPI dashboard
• The title field in your request body is not empty
• Body content is valid JSON (Make is strict about quotes and commas)

Step 5: Decode the Base64 Image

Make's toBinary() function converts a base64 string into binary data that file modules can consume directly. Add a Tools → Set multiple variables module after the HTTP module with three variables:

Variable name:  imageData
Variable value: {{toBinary(replace(2.data.image; "data:image/webp;base64,"; ""))}}

Variable name:  fileName
Variable value: thumbnail-{{formatDate(now; "X")}}.{{ifempty(2.data.outputFormat; "webp")}}

Variable name:  mimeType
Variable value: image/{{ifempty(2.data.outputFormat; "webp")}}

What this does:

• 2.data.image references the image field from the HTTP response (module 2).
• replace(...; "data:image/webp;base64,"; "") strips the data URI prefix.
• toBinary(...) converts the cleaned base64 string into a binary buffer.
• formatDate(now; "X") is a Unix timestamp — prevents filename collisions.
• ifempty(...) falls back to webp if outputFormat is missing.

Step 6: Upload the Thumbnail to Google Drive

Add a Google Drive — Upload a file module. Connect your Google account when prompted, then map the variables from the previous step:

Folder:          (pick your destination folder)
File name:       {{3.fileName}}
File data:       {{3.imageData}}

If you prefer Dropbox, S3, or any other file destination, the pattern is identical — every file module accepts the binary buffer produced by toBinary().

Step 7: Add a Slack Notification (Optional)

For team workflows, append a Slack — Send a Message module after the upload:

Channel:  #thumbnails
Text:     Thumbnail ready for: {{1.title}}
          Drive link: {{4.webViewLink}}

Your scenario now detects, generates, uploads, and notifies — fully hands-off.

Handling Multiple Platforms at Once

If you distribute the same content across YouTube, Instagram, and your blog, Make's Router module lets you fan out from a single trigger into parallel paths:

[Trigger]
   ↓
[Router]
   ├── Route 1: HTTP → format: youtube     → Google Drive: YouTube/
   ├── Route 2: HTTP → format: instagram   → Instagram: Create Post
   └── Route 3: HTTP → format: blogpost    → WordPress: Update Featured Image

Each route runs independently. If one fails, the others still complete. Add filters to routes to conditionally generate thumbnails based on category, post type, or any field from the trigger.

Error Handling for Production Scenarios

Make.com makes error handling straightforward:

• Enable error handlers on the HTTP module. Right-click the module and add an error route — typically a Slack alert plus a retry. Make retries the request automatically if you select the "Retry" handler type.
• Set "Allow storing of incomplete executions" in the scenario's advanced settings so failed runs don't disappear silently.
• Add a Sleep module between iterations in batch scenarios (1–2 seconds) to avoid hitting the ThumbAPI rate limit when processing many titles in a row.

Batch Processing From Google Sheets

For weekly content calendars, this pattern processes all titles in one Monday morning run:

[Schedule Trigger]    — every Monday at 9 AM
  ↓
[Google Sheets]       — Search Rows: this week
  ↓
[HTTP]                — POST to ThumbAPI with row title
  ↓
[Set multi variables] — decode base64 → binary
  ↓
[Google Drive]        — Upload thumbnail to weekly folder
  ↓
[Google Sheets]       — Update Row: mark "Thumbnail: Generated"

Each row can specify its own format and imageStyle columns, so YouTube, blog, and Instagram thumbnails all come from the same weekly run.

Why Make.com for Thumbnail Automation

Make's strengths show up in three places:

Visual flow. You see the entire pipeline as a connected diagram — easy to explain to non-developers on your team and easy to debug because each module shows its actual data on every run.

Router and Iterator modules. Fan out into parallel paths or batch-process hundreds of rows from a spreadsheet without writing a loop.

Operations-based pricing. Each module run is one operation. The free tier (1,000 ops/month) is enough for ~100 thumbnail generations including all the surrounding modules. Above that, plans start at $9/month for 10k ops.

If you prefer the code-first model with a Code node for custom JavaScript transforms, the n8n version of this guide covers the same flow with n8n's terminology.

Getting Started

The fastest path from zero to working Make.com thumbnail automation:

1. Sign up for Make.com — free tier, no credit card.
2. Sign up for ThumbAPI — free tier, 5 generations/month.
3. Clone the public scenario template.
4. Swap thumbapi_test for your real ThumbAPI key in the HTTP module headers.
5. Replace the Set variable placeholder with your real trigger (YouTube, RSS, Sheets, Webhook).
6. Add your destination module (Google Drive, Slack, WordPress, etc.) and map imageData, fileName, mimeType.

Total time: 10–15 minutes. Thumbnail generation itself runs in under 25 seconds per request.

For the canonical Make.com setup with all configuration details, see the ThumbAPI + Make.com integration guide.

---

Originally published at thumbapi.dev/integrations/make.