Skip to main content
This guide demonstrates how to build a no-code video creation pipeline using Make.com (formerly Integromat) and Google Sheets. The integration uses two separate Make.com scenarios to render videos from spreadsheet data and receive completion notifications via webhook.

​
Why Two Scenarios?

Make.com scenarios have a maximum execution time of 40 minutes on paid plans and 5 minutes on the free plan. Since video rendering can take several minutes, a single scenario that submits a render request and waits for completion could exceed these limits. By splitting the workflow into two scenarios, each scenario completes quickly and well within the free plan’s 5-minute execution limit:
  1. Scenario 1 submits the render request and writes the job ID to the spreadsheet (completes in seconds)
  2. Scenario 2 receives a webhook callback when rendering finishes and updates the spreadsheet with the video URL (completes in seconds)
This two-scenario design is ideal for free plan users and ensures reliable execution regardless of how long the video takes to render.

​
Architecture Overview

​
Before You Begin

Ensure you have the following:
  • A Pictory API key (get one here)
  • A Make.com account (free or paid)
  • A Google account with access to Google Sheets
  • A Google Sheets spreadsheet set up with the required structure (described below)

​
Google Sheets Setup

Create a Google Sheets spreadsheet with two sheets: Videos and Video Trigger.

​
Sheet 1: “Videos”

This is the primary data sheet that stores video entries and their rendering results. Set up the following column headers in row 1:
Column AColumn BColumn CColumn DColumn E
Video NameStoryJob IdVideo UrlReview Status
For each video entry, populate the following columns:
  • Video Name: A descriptive name for the video
  • Story: The full story text that Pictory will convert into video scenes
  • Review Status: Set to approved when the row is ready for rendering
Leave the Job Id and Video Url columns empty — these are populated automatically by the scenarios during execution.
Google Sheets Videos sheet with video data ready for rendering

​
Sheet 2: “Video Trigger”

This sheet controls when Scenario 1 runs. It contains a single column:
Column A
Trigger DateTime
Each time you add a new datetime value to this sheet, Scenario 1 detects the new row and initiates a rendering cycle. Add the current date and time to trigger a new execution.
Google Sheets Video Trigger sheet with datetime entries

​
Spreadsheet Data Flow

As the two scenarios execute, the Videos sheet progresses through the following states:

​
State 1: Ready for Rendering

The row contains the video name, story text, and review status set to approved. The Job Id and Video Url columns are empty.
Spreadsheet state before rendering

​
State 2: Render Submitted (After Scenario 1)

After Scenario 1 executes, it submits the render request to Pictory and writes the returned jobId into the Job Id column. The review status remains approved while the video is being rendered in the Pictory cloud.
Spreadsheet state after render submission with job ID

​
State 3: Rendering Complete (After Scenario 2)

When Pictory finishes rendering the video, it sends a webhook callback to Scenario 2. The scenario locates the row by matching the job ID, writes the rendered Video Url, and updates the Review Status from approved to done.
Spreadsheet state after rendering complete with video URL and done status

​
Scenario 1: Render Text to Video from Google Spreadsheet

This scenario watches for new rows in the trigger sheet, finds approved video entries, submits them to the Pictory Render API, and writes the job ID back to the spreadsheet.
Make.com scenario for rendering video from Google Spreadsheet

​
Module Breakdown

​
1. Trigger Video Render (Google Sheets: Watch New Rows)

PropertyValue
Modulegoogle-sheets:watchRows
SheetVideo Trigger
ScheduleEvery 5 minutes
PurposeDetects new rows added to the trigger sheet
This module monitors the “Video Trigger” sheet for new rows. When a new datetime value is added to a row, the module detects it and triggers the scenario execution. The polling interval can be adjusted based on your requirements.

​
2. Search for Approved Rows (Google Sheets: Search Rows)

PropertyValue
Modulegoogle-sheets:filterRows
SheetVideos
FilterColumn E (Review Status) equals approved
PurposeFinds video entries that are approved for rendering
This module searches the “Videos” sheet for rows where the Review Status column contains approved. Only approved entries proceed to the rendering step.

​
3. Pictory Render Storyboard Video (HTTP: Make a Request)

PropertyValue
Modulehttp:MakeRequest
MethodPOST
URLhttps://api.pictory.ai/pictoryapis/v2/video/storyboard/render
PurposeSubmits the video rendering request to Pictory
This module sends a POST request to the Pictory Render Storyboard Video API with the following configuration: Headers:
  • Content-Type: application/json
  • Authorization: Your Pictory API key
Request Body: 
{
    "videoName": "demo_text_to_video",
    "webhook": "YOUR_MAKE_WEBHOOK_URL",
    "smartLayoutName": "Wanderlust",
    "voiceOver": {
        "enabled": true,
        "aiVoices": [
            {
                "speaker": "Brian"
            }
        ]
    },
    "backgroundMusic": {
        "enabled": true,
        "volume": 0.1,
        "autoMusic": true
    },
    "scenes": [
        {
            "story": "{{story_from_spreadsheet}}",
            "createSceneOnNewLine": true,
            "createSceneOnEndOfSentence": true
        }
    ]
}
Key fields:
FieldDescription
videoNameName assigned to the generated video
webhookThe URL of your Scenario 2 webhook (Pictory sends a callback here when rendering completes)
smartLayoutNameVisual layout theme applied to the video
voiceOverAI voice configuration with the selected speaker
backgroundMusicAuto-selected background music at 10% volume
scenes[].storyThe story text pulled from the spreadsheet’s Story column
Replace YOUR_MAKE_WEBHOOK_URL with the actual webhook URL from Scenario 2. This URL is generated after creating the webhook trigger in Scenario 2.
Response: Returns a jobId that uniquely identifies the rendering job. 
{
    "data": {
        "jobId": "abc123-def456-..."
    }
}

​
4. Write Job Id (Google Sheets: Update a Cell)

PropertyValue
Modulegoogle-sheets:updateCell
SheetVideos
CellColumn C (Job Id) at the matching row
Value{{data.data.jobId}} from the API response
PurposeRecords the job ID for tracking and webhook correlation
This module writes the jobId returned by the Pictory API into the Job Id column of the corresponding row. This value is used by Scenario 2 to locate the correct row when the webhook fires.

​
Scenario 2: Video Rendered Webhook

This scenario listens for webhook callbacks from Pictory when a video finishes rendering, then updates the spreadsheet with the video URL and marks the row as completed.
Make.com scenario for video rendered webhook

​
Module Breakdown

​
1. Video Rendered Webhook (Custom Webhook)

PropertyValue
Modulegateway:CustomWebHook
TriggerImmediately as data arrives
PurposeReceives the callback from Pictory when video rendering completes
This module creates a custom webhook endpoint in Make.com. When Pictory finishes rendering a video, it sends a POST request to this webhook URL with the following payload: 
{
    "job_id": "abc123-def456-...",
    "success": true,
    "data": {
        "status": "completed",
        "progress": 100,
        "videoURL": "https://...",
        "videoShareURL": "https://...",
        "videoEmbedURL": "https://...",
        "audioURL": "https://...",
        "thumbnail": "https://...",
        "srtFile": "https://...",
        "txtFile": "https://...",
        "vttFile": "https://...",
        "videoDuration": 45.2,
        "encodingDuration": 30.5
    },
    "userId": "user-id"
}
Copy the webhook URL generated by this module and paste it into the webhook field of the Pictory API request body in Scenario 1.

​
2. Search for Rendered Job Row (Google Sheets: Search Rows)

PropertyValue
Modulegoogle-sheets:filterRows
SheetVideos
FilterColumn C (Job Id) equals {{webhook.job_id}}
PurposeFinds the spreadsheet row that matches the completed job
This module searches the “Videos” sheet for the row where the Job Id column matches the job_id received from the webhook. This correlates the webhook callback with the correct video entry.

​
3. Update Rendered Video Url (Google Sheets: Update a Cell)

PropertyValue
Modulegoogle-sheets:updateCell
SheetVideos
CellColumn D (Video Url) at the matching row
Value{{webhook.data.videoURL}}
PurposeWrites the rendered video URL to the spreadsheet
Once the matching row is found, this module updates the Video Url column with the download URL of the rendered video.

​
4. Update Review Status (Google Sheets: Update a Cell)

PropertyValue
Modulegoogle-sheets:updateCell
SheetVideos
CellColumn E (Review Status) at the matching row
Valuedone
PurposeMarks the video entry as completed
This module updates the Review Status column from approved to done, indicating that the video has been successfully rendered and the URL is available.

​
Import the Blueprints

Both scenarios are available as pre-configured blueprint JSON files that can be imported directly into your Make.com account. Blueprints are Make.com’s format for sharing scenario configurations — they contain the complete module setup, connections, and data mappings, eliminating the need to configure each module manually. Download the blueprint files before proceeding:
Never share blueprint files containing your actual API key. Always use placeholder values like YOUR_PICTORY_API_KEY in shared blueprints and set the real key only in your private Make.com account.

​
Step-by-Step Import and Configuration

Follow this order to ensure the webhook URL is available when configuring Scenario 1. Scenario 2 must be created first because it generates the webhook URL that Scenario 1 needs.
1

Prepare your Google Spreadsheet

Create a new Google Sheets spreadsheet with two sheets named Videos and Video Trigger, using the column structure described in the Google Sheets Setup section above. Add at least one video entry to the “Videos” sheet with a video name, story text, and set the Review Status to approved.
2

Import Scenario 2 (Video Rendered Webhook)

  1. Log in to your Make.com account
  2. Click Scenarios in the left sidebar, then click Create a new scenario
  3. In the scenario editor, click the three-dot menu (⋮) at the bottom of the screen
  4. Select Import Blueprint from the menu
  5. Choose the downloaded Video Rendered Webhook.blueprint.json file and click Save
  6. The scenario modules will appear in the editor, matching the layout shown in the Scenario 2 screenshot above
3

Configure Google Sheets connection in Scenario 2

Each Google Sheets module in the scenario requires a connection to your Google account:
  1. Click on the Search for Rendered Job Row module
  2. Under Connection, click Add and sign in with your Google account to authorize Make.com
  3. Select your spreadsheet under Spreadsheet Name and choose the Videos sheet
  4. Repeat for the Update Rendered Video Url and Update Review Status modules, using the same Google connection
4

Copy the webhook URL

  1. Click on the Video Rendered Webhook module (the first module in the scenario)
  2. Under Webhook, click Add to create a new webhook
  3. Assign a descriptive name (e.g., “Pictory Video Rendered Webhook”) and click Save
  4. Make.com generates a unique webhook URL. Copy this URL — it is required when configuring Scenario 1.
5

Activate Scenario 2

Turn on Scenario 2 by toggling the Scheduling switch at the bottom of the editor. The scenario is set to trigger Immediately as data arrives, so it will automatically run whenever Pictory sends a webhook callback.
6

Import Scenario 1 (Render Text to Video from Google Spreadsheet)

  1. Go back to Scenarios and click Create a new scenario
  2. Click the three-dot menu (⋮) at the bottom and select Import Blueprint
  3. Choose the downloaded Render Text To Video From Google Sheet.blueprint.json file and click Save
7

Configure Google Sheets connection in Scenario 1

  1. Click on the Trigger Video Render module
  2. Under Connection, add your Google account (or reuse the connection created in Scenario 2)
  3. Select your spreadsheet and choose the Video Trigger sheet
  4. Repeat for the Search for Approved Rows module (select the Videos sheet) and the Write Job Id module (select the Videos sheet)
8

Configure the Pictory API key

  1. Click on the Pictory Render Storyboard Video module (the HTTP request module)
  2. In the Headers section, locate the Authorization header
  3. Replace YOUR_PICTORY_API_KEY with your actual Pictory API key (e.g., pictai_xxxx...)
9

Set the webhook URL in the request body

  1. Still in the Pictory Render Storyboard Video module, scroll down to the Request content (JSON body)
  2. Locate the webhook field in the JSON body
  3. Replace YOUR_MAKE_WEBHOOK_URL with the webhook URL you copied from Scenario 2 in Step 4
10

Activate Scenario 1 and trigger a run

  1. Turn on Scenario 1 by toggling the Scheduling switch. The default schedule is set to run Every 5 minutes.
  2. To initiate your first video render, add a datetime value (e.g., the current date and time) to a new row in the Video Trigger sheet
  3. During the next polling cycle, Scenario 1 detects the new row, identifies approved entries in the Videos sheet, submits the render request, and writes the job ID back to the spreadsheet
  4. Upon rendering completion, Pictory sends a webhook callback to Scenario 2, which updates the video URL and sets the review status to done
After importing, click Run once at the bottom of the scenario editor to test each scenario before activating the automatic schedule. This verifies that all connections, spreadsheet references, and API credentials are configured correctly.

​
Best Practices

Store your Pictory API key securely. In Make.com, you can use the HTTP module’s built-in authentication options or store keys in a data store. Avoid hardcoding API keys directly in shared blueprints.
Use the Webhooks section in Make.com’s left sidebar to monitor incoming webhook data. If a webhook fails to arrive, verify that the webhook URL in Scenario 1’s request body matches the URL shown in Scenario 2’s webhook module.
The webhook payload includes a success field. You can add a Router module after the webhook trigger to handle failed renders separately, such as sending a notification or updating the spreadsheet with an error status.
Scenario 1 processes one row per trigger execution. To render multiple videos, add multiple rows to the “Video Trigger” sheet. Each trigger cycle processes new rows and submits them for rendering.
On the Make.com free plan, you are limited to two active scenarios and 1,000 operations per month. This two-scenario architecture fits within the free plan’s scenario limit. Monitor your operation usage in the Make.com dashboard.

​
Troubleshooting

Verify your API key is correct in the HTTP request module’s Authorization header. The value should be your complete API key (e.g., pictai_xxxx...). Do not add a Bearer prefix.
Verify that Scenario 2 is active and the webhook URL in Scenario 1’s request body exactly matches the URL generated in Scenario 2. Test by running Scenario 1 manually and reviewing Scenario 2’s execution history.
Confirm that all Google Sheets modules have a valid connection. Verify that the spreadsheet ID and sheet names match your Google Sheets document, and that column references (C, D, E) align with your spreadsheet structure.
The two-scenario design prevents timeouts since each scenario completes in seconds. If timeouts persist, verify that large spreadsheets are not slowing the Search Rows module. Add filters to limit the number of rows processed.

​
Next Steps

Render Storyboard Video API

Full API reference for the render endpoint used in Scenario 1

Get Job Status API

API reference for checking video rendering progress

Text to Video Guide

Learn about storyboard payload options and scene configuration

n8n Integration

Alternative workflow automation using n8n with polling-based approach