# Generate and Publish YouTube Shorts in Bulk

You want to post one YouTube Short per day. Or ten per week. Each Short needs a vertical video, a title, a description, the right privacy settings, and optionally a custom thumbnail and playlist assignment. Doing this manually takes 15-20 minutes per video. At scale, it becomes a full-time job.

On the [Make.com forum](https://community.make.com), users ask about generating 1,000+ YouTube Shorts with tools like InVideo and bulk-uploading them. On the [n8n forum](https://community.n8n.io), users build short-form video pipelines that create content with AI and push it to YouTube, TikTok, and Instagram in parallel. The bottleneck is always the same: generating videos at scale and handling YouTube's metadata requirements (titles, descriptions, playlists, thumbnails, privacy status) for each upload.

Here is a workflow that generates AI videos and publishes them to YouTube with full metadata control.

## What YouTube Shorts requires

A YouTube Short is a vertical video (9:16 aspect ratio) under 60 seconds. YouTube classifies videos as Shorts automatically based on these properties. You do not need a separate API or upload flow -- publish through the standard YouTube Data API and YouTube handles the categorization.

When publishing through the Blotato API, these are the YouTube-specific fields:

| Field                     | Required | Description                                            |
| ------------------------- | -------- | ------------------------------------------------------ |
| `title`                   | Yes      | Video title. Appears on the Shorts player.             |
| `privacyStatus`           | Yes      | `public`, `private`, or `unlisted`                     |
| `shouldNotifySubscribers` | Yes      | Send a notification to subscribers                     |
| `isMadeForKids`           | No       | Defaults to `false`                                    |
| `containsSyntheticMedia`  | No       | Flag AI-generated content                              |
| `playlistIds`             | No       | Add the video to one or more playlists                 |
| `thumbnailUrl`            | No       | Custom thumbnail (requires a verified YouTube account) |

The video description comes from the `content.text` field. YouTube does not support tags through the API -- YouTube recommends against relying on tags for discovery.

## The three-step pipeline

### Step 1: Generate a batch of video topics

Use the [Create Source](/api/create-source.md) endpoint with `sourceType: "perplexity-query"` to research topics in your niche:

```json
{
  "source": {
    "sourceType": "perplexity-query",
    "text": "What are the 10 most-searched questions about personal finance on YouTube this month?"
  },
  "customInstructions": "For each question, write a one-sentence video premise. Format as a numbered list."
}
```

Poll `GET /v2/source-resolutions-v3/{id}` until status is `completed`. The response contains 10 video topics ready to feed into the next step.

For a content library approach, store topics in a Google Sheet or Airtable. Each row contains a topic, a target title, and a description. Your workflow reads one row at a time and creates a video from it.

### Step 2: Generate each video

Use the [Create Visual](/api/create-video.md) endpoint with the "AI Video with AI Voice" template. This template generates a script, AI images, AI voiceover, and captions, then renders the final video:

```json
{
  "templateId": "5903fe43-514d-40ee-a060-0d6628c5f8fd",
  "inputs": {},
  "prompt": "Create a 45-second video answering: How much should you save from each paycheck? Use a calm, friendly female voice. Include specific percentages and a simple rule of thumb."
}
```

Poll `GET /v2/videos/{id}` until status is `done`. The response includes `mediaUrl` with the rendered video.

For bulk generation, loop through your topic list and create one video per topic. Each Create Visual call is independent -- you run them in parallel or sequentially depending on your plan's rate limits (30 requests per minute).

### Step 3: Publish to YouTube with full metadata

Pass the rendered video URL to the [Publish Post](/api/publish-post.md) endpoint with YouTube-specific fields:

```json
{
  "post": {
    "accountId": "your-youtube-account-id",
    "content": {
      "text": "The 50/30/20 rule: 50% needs, 30% wants, 20% savings. Here is how to apply it to your next paycheck.\n\n#shorts #personalfinance #money",
      "mediaUrls": ["https://blotato-media.s3.amazonaws.com/your-rendered-video.mp4"],
      "platform": "youtube"
    },
    "target": {
      "targetType": "youtube",
      "title": "How Much Should You Save From Each Paycheck?",
      "privacyStatus": "public",
      "shouldNotifySubscribers": true,
      "containsSyntheticMedia": true,
      "playlistIds": ["PLxxxxxxxxxxxxxxxx"]
    }
  },
  "useNextFreeSlot": true
}
```

Key details:

* `containsSyntheticMedia: true` flags the video as AI-generated, which YouTube requires for transparency.
* `playlistIds` assigns the Short to a playlist. Fetch playlist IDs from `GET /v2/users/me/accounts/{accountId}/subaccounts` ([docs](/api/accounts.md#list-subaccounts-pages)).
* `useNextFreeSlot: true` schedules the Short at the next open slot in your content calendar instead of publishing immediately. This spaces out your uploads so YouTube does not flag bulk posting.
* The `content.text` field becomes the YouTube description. Include hashtags here -- `#shorts` is optional (YouTube auto-detects Shorts by video dimensions).

### Adding a custom thumbnail

If your YouTube account supports custom thumbnails, pass a public image URL in the `thumbnailUrl` field:

```json
{
  "post": {
    "accountId": "your-youtube-account-id",
    "content": {
      "text": "How much should you save?",
      "mediaUrls": ["https://blotato-media.s3.amazonaws.com/your-video.mp4"],
      "platform": "youtube"
    },
    "target": {
      "targetType": "youtube",
      "title": "How Much Should You Save From Each Paycheck?",
      "privacyStatus": "public",
      "shouldNotifySubscribers": true,
      "thumbnailUrl": "https://example.com/thumbnail.jpg"
    }
  }
}
```

Generate thumbnails with the [Create Visual](/api/create-video.md) endpoint using an image template (such as the Quote Card or Image Slideshow template) and pass the resulting `imageUrls[0]` as the `thumbnailUrl`.

## Step-by-step: n8n workflow for daily Shorts

1. Install the [Blotato community node](https://help.blotato.com/api/n8n/n8n-blotato-node) in n8n.
2. Add a **Schedule Trigger** node. Set it to run once per day.
3. Add a **Google Sheets** node (or Airtable node) to read the next topic from your content spreadsheet.
4. Add a Blotato **Create Visual** node. Select the "AI Video with AI Voice" template. Pass the topic from the spreadsheet into the `prompt` field.
5. Add a Blotato **Get Visual Status** node. Enable polling until status is `done`.
6. Add a Blotato **Publish Post** node. Set the platform to `youtube`. Map the fields:
   * `mediaUrls`: the `mediaUrl` from the Get Visual Status response
   * `text`: your YouTube description (from the spreadsheet or generated by an LLM node)
   * `title`: your Short's title
   * `target.privacyStatus`: `public`
   * `target.shouldNotifySubscribers`: `true`
   * `target.containsSyntheticMedia`: `true`
   * `target.playlistIds`: your playlist ID
7. Set `useNextFreeSlot: true` on the Publish node.
8. Add a **Google Sheets Update** node to mark the row as "published" so the next run picks the next topic.
9. Activate the workflow.

One video per day. No manual work.

## Step-by-step: Make.com scenario for bulk Shorts

1. Add a **Schedule** trigger module.
2. Add a **Google Sheets** module to get the next row from your topic spreadsheet.
3. Add an HTTP module to call `POST https://backend.blotato.com/v2/videos/from-templates` with the "AI Video with AI Voice" template ID and the topic as `prompt`.
4. Add a polling loop (Repeater + HTTP GET) to check `GET https://backend.blotato.com/v2/videos/{id}` until status is `done`.
5. Add an HTTP module to call `POST https://backend.blotato.com/v2/posts` with the YouTube-specific request body (title, privacyStatus, playlistIds, etc.).
6. Add a **Google Sheets** module to update the row status to "published."
7. Activate the scenario.

## Scaling: 10 Shorts per week

To generate multiple Shorts per run:

1. Read 10 rows from your spreadsheet at once using a Google Sheets "Search Rows" query.
2. Use a **SplitInBatches** node (n8n) or **Iterator** module (Make) to process each row.
3. Create one video per row and publish each with `useNextFreeSlot: true`.

Blotato's scheduling system spaces out the posts across your configured calendar slots. If you have one YouTube slot per day, 10 videos get spread across the next 10 days.

Rate limits: the Create Visual and Publish Post endpoints allow 30 requests per minute. For 10 videos, the create step takes 10-30 minutes total (1-3 minutes per video for rendering). Run the workflow during off-hours to avoid interfering with other Blotato API usage.

## Cross-posting Shorts to TikTok and Instagram Reels

A YouTube Short is the same format as a TikTok video and an Instagram Reel (vertical, under 60 seconds). After generating the video, add parallel Publish Post calls for each platform:

```json
{
  "post": {
    "accountId": "your-tiktok-account-id",
    "content": {
      "text": "How much should you save from each paycheck? #personalfinance",
      "mediaUrls": ["https://blotato-media.s3.amazonaws.com/your-video.mp4"],
      "platform": "tiktok"
    },
    "target": {
      "targetType": "tiktok",
      "privacyLevel": "PUBLIC_TO_EVERYONE",
      "disabledComments": false,
      "disabledDuet": false,
      "disabledStitch": false,
      "isBrandedContent": false,
      "isYourBrand": false,
      "isAiGenerated": true
    }
  },
  "useNextFreeSlot": true
}
```

One generated video. Three platforms. See [Post Videos to TikTok, Reels, and YouTube Shorts from One Workflow](/blog/post-videos-tiktok-reels-shorts-one-workflow.md) for the full cross-posting setup.

## Forum threads referenced

These are the community discussions that prompted this post:

* [Generate 1000+ YouTube Shorts using InVideo and bulk upload](https://community.make.com/t/generate-1000-youtube-shorts-using-invideo-and-bulk-upload-using-url-in-youtube/45089) (Make)
* [Upload Bulk Videos to YouTube Channels](https://community.make.com/t/upload-bulk-videos-to-youtube-channels-youtube-automation-in-one-click/21186) (Make)
* [Automation Short-Form Videos Creation](https://community.n8n.io/t/automation-short-form-videos-creation/239063) (n8n)
* [AI Video Automation: Script to Instagram Reel Publish](https://community.n8n.io/t/ai-video-automation-script-to-instagram-reel-publish-n8n-gemini-blotato/207883) (n8n)
* [Auto Publish Videos to 9 Social Media Platforms](https://community.n8n.io/t/auto-publish-videos-to-9-social-media-platforms/252654) (n8n)
* [Custom Content Calendar with Automated Posting](https://community.n8n.io/t/custom-content-calendar-with-automated-posting/252931) (n8n)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://help.blotato.com/blog/generate-youtube-shorts-bulk-n8n-make.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.