ThumbAPI + Make.com: Visual Thumbnail Automation for Any Workflow

Connect ThumbAPI to Make.com (formerly Integromat) and generate thumbnails automatically inside visual automation scenarios. Use Make's HTTP module to call the ThumbAPI endpoint, then route the generated images wherever you need them.

What You Can Build With ThumbAPI + Make.com

Make.com connects to over 1,500 apps with a visual drag-and-drop scenario builder. Adding ThumbAPI as an HTTP module turns any content workflow into an automated thumbnail pipeline. Make's router, iterator, and aggregator modules give you precise control over how and where thumbnails are generated.

This Make.com image automation setup handles everything from single thumbnails to batch processing hundreds of images from a spreadsheet.

• Generate multiple thumbnail formats from a single trigger using Make's Router module
• Batch-process rows from Google Sheets or Airtable with the Iterator module
• Build conditional workflows that pick formats based on content type
• Store generated thumbnails in Google Drive, Dropbox, or S3
• Post directly to Instagram, X, or Buffer with generated images
• Update CMS featured images on WordPress, Ghost, or Webflow

Plug & Play: Clone the Public Scenario

Don't have a Make.com account yet? Sign up free at Make.com — their free tier covers 1,000 operations/month, more than enough to run this scenario.

Skip the build and clone our ready-made Make.com scenario in one click. It includes the HTTP module pre-configured for the ThumbAPI generate endpoint and a Set-multiple-variables module that decodes the base64 response into binary, ready to feed into Google Drive, Dropbox, S3, or any file destination.

After You Clone It

1. 1.Sign up at app.thumbapi.dev (free, no credit card) and copy your personal API key from the dashboard.
2. 2.Open the cloned scenario in your Make dashboard and click the HTTP module.
3. 3.In Headers, replace thumbapi_test with the API key you just copied. This is the only required change to start generating real thumbnails.
4. 4.Replace the placeholder Set variable trigger with your real trigger — YouTube Watch Videos, Google Sheets Watch Rows, RSS, Webhook, anything that produces a title.
5. 5.Add your destination module after the Set-multiple-variables step — Google Drive Upload, Dropbox, WordPress, Slack, etc. Map imageData, fileName, and mimeType from the Set step into the file fields.
6. 6.Click Run once to test, then activate the scenario.

Want to build it from scratch instead? The full step-by-step setup is below.

Step-by-Step Setup: Connect ThumbAPI to Make.com

The setup takes about five minutes. You will use Make's built-in HTTP module to send POST requests to the ThumbAPI endpoint. No custom app or OAuth configuration needed.

Step 1: Get Your ThumbAPI Key

Sign up at ThumbAPI and copy your API key from the dashboard. The free plan includes 50 credits per month — enough to build and test your scenarios.

• Go to your ThumbAPI dashboard
• Navigate to API Keys and copy your API key
• You will paste this into the HTTP module headers in the next steps

Step 2: Create a New Scenario and Add a Trigger

Open Make.com and create a new scenario. Click the “+” button to add your first module — this is your trigger. Choose the app and event that should start thumbnail generation:

• YouTube— Watch Videos
• WordPress— Watch Posts
• Google Sheets— Watch Rows
• Shopify— Watch New Products
• RSS— Watch RSS Feed Items
• Webhook— Custom Webhook (for any source)

Connect your account and run the trigger once to load sample data. Make uses this data to populate field mappings in subsequent modules.

Step 3: Add the HTTP Module

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

Configure the module with the following settings:

Module: HTTP > Make a request

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

Headers:
  x-api-key: YOUR_API_KEY
  Content-Type: application/json

Body type: Raw
Content type: JSON (application/json)

Request content:
{
  "title": "{{1.title}}",
  "format": "youtube"
}

In the request content, use Make's mapping panel to insert dynamic values from your trigger. Click the field, then select the variable from the mapping panel on the left.

Step 4: Configure the Request Body

The request body controls what type of thumbnail ThumbAPI generates. Map the title from your trigger and set the format and style for your target platform:

{
  "title": "{{1.title}}",
  "format": "youtube"
}

The format parameter accepts youtube, instagram, x, or blogpost. Each generates platform-specific dimensions.

Two optional flags control the visual approach: omit both for a text-driven faceless design, set usePhoto: true to include a person photo, or useLogo: true for branded thumbnails. Flags can be combined. Pass category (e.g. tech-saas) to nudge the style.

Step 5: 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"
}

The image field contains your base64-encoded WebP thumbnail. Make automatically parses the JSON response, so you can map image, format, and dimensions to downstream modules directly.

Step 6: Add Downstream Modules

After the HTTP module, add modules that consume the generated thumbnail. Click “+” and choose your destination. Map the image field from the HTTP response to the file input of the next module.

Common downstream modules include Google Drive (Upload a File), WordPress (Update a Post), Slack (Send a Message), or any social media platform. Make's visual interface makes it simple to connect multiple outputs from a single trigger.

Example Make.com Scenarios With ThumbAPI

Here are three production-ready scenarios you can replicate. Each takes advantage of Make's visual flow to handle real automation needs.

Scenario 1: YouTube Video to Auto Thumbnail to Google Drive

Monitor your YouTube channel for new uploads. When a video publishes, ThumbAPI generates a matching thumbnail and saves it to Google Drive for review.

[YouTube] Watch Videos
  ↓
[HTTP] Make a request → POST /v1/generate
  Body: { title: "{{title}}", format: "youtube" }
  ↓
[Google Drive] Upload a File
  File name: thumbnail-{{videoId}}.webp
  File data: {{image}} from HTTP response
  ↓
[Slack] Send a Message (optional)
  Channel: #content
  Text: "Thumbnail ready for: {{title}}"

This scenario runs on a schedule (every 15 minutes by default). Adjust the polling interval in your scenario settings based on how frequently you publish.

Scenario 2: E-commerce Product to Multi-Platform Thumbnails

When a new product is added to Shopify, generate Instagram-optimized thumbnails and save them for both social posting and archiving. Make's Router module splits the flow into parallel paths.

[Shopify] Watch New Products
  ↓
[HTTP] Make a request → POST /v1/generate
  Body: { title: "{{product_title}}", format: "instagram", usePhoto: true }
  ↓
[Router] Split into paths
  ↓                              ↓
[Instagram] Create Post      [Google Drive] Upload File
  Image: {{image}}             Folder: Product Thumbnails
  Caption: "{{title}}"        File: {{product_title}}.webp

The Router module is what makes Make.com stand out for this use case. You can generate different formats in parallel from a single trigger, without running separate scenarios.

Scenario 3: Batch Processing From Google Sheets

Process a spreadsheet of content titles and generate thumbnails for each row. This is ideal for content calendars, batch uploads, or migrating existing content to new thumbnail designs.

[Google Sheets] Watch Rows
  ↓
[Iterator] Process each row
  ↓
[HTTP] Make a request → POST /v1/generate
  Body: { title: "{{row.title}}", format: "{{row.format}}", usePhoto: {{row.usePhoto}}, useLogo: {{row.useLogo}} }
  ↓
[Google Drive] Upload a File
  Folder: Generated Thumbnails
  File: {{row.title}}.webp

The Iterator module processes each row sequentially, calling ThumbAPI once per row. For large batches, enable “sequential processing” in your scenario settings to avoid rate limits.

Advanced: Router Module for Multi-Format Thumbnails

One of Make's most powerful features for thumbnail automation is the Router module. It lets you split a single trigger into multiple paths, each generating a different thumbnail format and sending it to a different destination.

[Trigger Module]
  ↓
[Router]
  ├── Route 1: YouTube Thumbnail
  │   └── [HTTP] POST /v1/generate { format: "youtube" }
  │       └── [Google Drive] Upload
  │
  ├── Route 2: Instagram Thumbnail
  │   └── [HTTP] POST /v1/generate { format: "instagram" }
  │       └── [Instagram] Create Post
  │
  └── Route 3: Blog Thumbnail
      └── [HTTP] POST /v1/generate { format: "blogpost" }
          └── [WordPress] Update Post Featured Image

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

Why Use Make.com for Thumbnail Automation

Make.com gives you more control over complex workflows than simpler automation platforms. The Make thumbnail generator integration is particularly effective for these reasons:

• Visual flow builder. See your entire thumbnail pipeline as a connected diagram. Debug by inspecting data at each step.
• Router and Iterator modules. Generate multiple thumbnail formats from one trigger, or batch-process hundreds of images from a spreadsheet.
• Error handling built in. Add error handler modules to retry failed generations, send alerts, or fall back to alternative actions.
• Cost-effective operations.Make's pricing is based on operations, and each HTTP request counts as one operation. Combined with ThumbAPI's free tier, you can automate thumbnails at minimal cost.
• Data transformation.Use Make's built-in functions to transform titles, extract keywords, or format strings before sending them to ThumbAPI.

Tips for Production Make.com Scenarios

• Set “Parse response” to Yes in the HTTP module. This automatically parses the JSON response so you can map individual fields to downstream modules.
• Add an error handler after the HTTP module. If ThumbAPI returns an error, the handler can retry the request or notify you via Slack or email.
• Use scenario data stores to cache API keys and configuration. Do not hardcode sensitive values in module settings.
• Enable sequential processing for batch scenarios to avoid overwhelming the API with parallel requests.
• Monitor execution history.Make's execution log shows the full request and response for each run. Use it to debug any issues with your scenarios.

Common Questions

Does ThumbAPI have a native Make.com module?

Not yet. You use Make's built-in “HTTP > Make a request” module, which works identically to a native integration. You get full control over headers, body, and response parsing.

How does Make.com handle the base64 image response?

When “Parse response” is enabled, Make extracts the imagefield as a string. You can pass this directly to file upload modules. Some modules may require you to use Make's toBinary function to convert the base64 string to a file before uploading.

What is the response time for thumbnail generation?

ThumbAPI returns generated thumbnails in 3–8 seconds. Make's HTTP module has a default timeout of 40 seconds, so this fits comfortably. You do not need to adjust timeout settings.