# Auto-Generate Instagram Carousels & Reels from Google Sheets
> Turn Google Sheet rows into branded Instagram carousels β images, animated reels, and one combined video β auto-posted. No-code, 2 Make modules, free template.
- **Author**: Rishi Mohan
- **Published**: 2026-06-04
- **Tags**: Instagram, Carousels, Google Sheets, Make, Automation, Tutorials
- **Read time**: 11 min read
- **URL**: https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets
---
**TL;DR:** Most carousel "automation" guides stop at static PNGs glued together from four or five tools β and the AI-image ones can't even render your headline without typos. This one goes end-to-end with two tools: a Google Sheet holds your content calendar, Make watches for new rows, and **one Orshot API call** renders all four branded slides, optional animated reels, or one combined video β and publishes the carousel straight to Instagram. No design tool, no Cloudinary, no separate scheduler.
**Grab the working files:**
- **[π¨ Open the carousel template](https://orshot.com/templates/shared/muzkxu0y/preview?view=play "target=_blank")** β the exact 4-page animated template used below; preview it, play with the parameters, and use it in your workspace
- **[π Copy the Google Sheet template](https://docs.google.com/spreadsheets/d/1pPkRAaL9csCZfLBSLuN7eH0aZxrThr1MZEWb3n16SRA/copy "target=_blank nofollow")** β the exact content calendar used below
- **[π₯ Download the Make blueprint (JSON)](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets/make-blueprint-sheet-to-instagram-carousel.json "target=_blank")** β import, paste your API key, done
- **[π₯ Download the n8n workflow (JSON)](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets/n8n-sheet-to-instagram-carousel.json "target=_blank")** β same flow in two n8n nodes
## What we're building
Picture a creator who posts a weekly "notes to my younger self" carousel β a hook cover, three pinned-note slides, a follow CTA. The content changes every week; the design never does. That's the exact situation where you should stop opening a design tool.
Instead, the words live in a Google Sheet β one row per carousel. When a new row appears, Make sends it to Orshot, which drops each cell into a designed multi-page template, renders all four slides, and posts them to Instagram as a carousel with the caption from the same row:
The same row can also come out as **four animated reels** or **one combined video of all slides** β we'll cover all three output modes below, from the same template and the same API call.
## The output: one Sheet row, four branded slides
Here's the real rendered output from row 2 of the demo sheet β a 4-page carousel, 1080Γ1350, with the photos, handwriting, and pinned-note design fully intact (no AI-generated text glitches, because nothing here is AI-imaged β it's a designed template):
And because the template has layer animations built in, the **same render request with `format: "mp4"`** returns each slide as a short animated reel β here's the cover and the closing slide as videos:
_Same template, same Sheet row β PNG slides for the carousel, MP4s for reels. No video editor involved._
## Why a render API beats AI image generators (and Canva)
If you've searched for "create instagram carousel automatically", you've seen the other approaches. Here's the honest comparison:
The structural difference: AI-image workflows _generate_ every slide from scratch (so brand and text drift), and schedulers only _post_ what you've already designed. A template render sits in the middle β pixel-exact design, dynamic content, and [native publishing](https://orshot.com/docs/publish/publish-from-api) from the same call.
## What you'll need
- A Google account (for the Sheet) and a free [Make](https://www.make.com "target=_blank nofollow") account β the whole flow fits in Make's free tier
- An [Orshot account](https://orshot.com/pricing "target=_blank") with an API key β the free tier's 60 renders are plenty to build and test this end to end
- An Instagram account connected to Orshot (Workspace β **Social Accounts**) for the publishing step
## Step 1 β The carousel template (design once, reuse forever)
Everything starts with a multi-page template in [Orshot Studio](https://orshot.com/features/orshot-studio). Ours is a 4-page, 1080Γ1350 "pinned notes" design β full-bleed photos, handwritten type, a note card pinned with a pearl tack:
The pages panel shows the whole carousel β cover, two note slides, and the CTA page:
Two things make a template automation-ready:
**1. Dynamic parameters.** Any layer can be marked parameterizable with a clean ID β `note_text`, `bg_image`, `subtitle`. For multi-page templates, the API addresses them with a page prefix: `page1@hook_line1`, `page2@note_text`, `page4@bg_image`. The fixed stuff (your handle, the design, the decorations) never appears in the spreadsheet at all β defaults fill anything you don't send.
**2. Layer animations.** Every layer in this template has an entrance β the arrows drop in, the note card springs up, the pin presses in, sparks pop last. Configure it once in the **Animate** tab and it's what makes the same template render as video:
You don't have to design this yourself: **[open the exact template from this tutorial](https://orshot.com/templates/shared/muzkxu0y/preview?view=play "target=_blank")** β animations, parameters and all β try the parameters live, and use it in your own workspace. Or start from one of the 1,000+ designs in the [template library](https://orshot.com/templates), or [import an existing design](https://orshot.com/docs/importing-templates) and add parameters to it.
## Step 2 β Set up the Google Sheet content calendar
The Sheet is the entire editorial workflow: one row = one carousel. Our demo calendar has 14 columns β the words for each slide, a photo URL per page, and the Instagram caption:
| Columns | What they fill |
| ------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| `hook_line1`, `hook_circled`, `strip_text`, `cover_image` | The cover slide (the circled word gets the hand-drawn scribble) |
| `note1`β`note3`, `note1_subtitle`β`note3_subtitle`, `note1_image`β`note3_image` | One pinned-note slide each |
| `caption` | The Instagram caption for the whole post |
**[Copy this exact Sheet](https://docs.google.com/spreadsheets/d/1pPkRAaL9csCZfLBSLuN7eH0aZxrThr1MZEWb3n16SRA/copy "target=_blank nofollow")** β it comes pre-filled with three demo rows so you can test before writing your own content. Batch-write a month of rows on a Sunday and the rest of this pipeline turns them into posts.
## Step 3 β Grab your Orshot API key
In your Orshot workspace, go to **Workspace β API Keys** and create a key. You'll paste it into exactly one place in Make (the `Authorization` header). Treat it like a password β anyone with it can render on your account.
## Step 4 β Build the Make scenario (just 2 modules)
This is the part other guides turn into a six-module maze. It's two:
The fastest path is to **[import the blueprint](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets/make-blueprint-sheet-to-instagram-carousel.json "target=_blank")** (Make β scenario menu β _Import blueprint_), connect your Google account, point the trigger at your copy of the Sheet, and paste your API key. If you'd rather build it by hand:
**Module 1 β Google Sheets β Watch New Rows.** Pick your spreadsheet and `Sheet1`, keep _Table contains headers_ on, and set the limit to 1. When Make asks where to start, choose _All_ so your existing demo rows count as new on the first run:
**Module 2 β HTTP β Make a request.** This is the single call that does everything. Method `POST`, URL `https://api.orshot.com/v1/studio/render`, two headers:
Then set _Body content type_ to `application/json`, _Body input method_ to **JSON string**, and paste the request body β mapping each field to its Sheet column (type the `}` tokens or click the green pills from the mapping panel):
```json
{
"templateId": 12372,
"modifications": {
"page1@hook_line1": "{{hook_line1}}",
"page1@hook_circled": "{{hook_circled}}",
"page1@strip_text": "{{strip_text}}",
"page1@bg_image": "{{cover_image}}",
"page2@note_text": "{{note1}}",
"page2@subtitle": "{{note1_subtitle}}",
"page2@bg_image": "{{note1_image}}",
"page3@note_text": "{{note2}}",
"page3@subtitle": "{{note2_subtitle}}",
"page3@bg_image": "{{note2_image}}",
"page4@note_text": "{{note3}}",
"page4@subtitle": "{{note3_subtitle}}",
"page4@bg_image": "{{note3_image}}"
},
"response": { "type": "url", "format": "png" },
"publish": {
"accounts": [0],
"content": "{{caption}}"
}
}
```Two values to make your own: `templateId` β `12372` is our demo template, and yours is shown in the studio URL and at the top of its playground β and the `0` in `publish.accounts`, which you'll swap for your Instagram account ID in Step 6 (until then, `0` safely renders without posting anything).
That's the whole automation. No image-hosting module, no iterator, no array aggregator β the things that derail most Make carousel attempts simply aren't needed, because Orshot treats the multi-page render _and_ the carousel upload as one operation.
## Step 5 β One API call, three output modes
The `response.format` field decides what comes back. Same template, same modifications β three different deliverables.
### Static carousel images (PNG)
With `"format": "png"`, a multi-page template returns one image per page:```json
{
"data": [
{
"page": 1,
"pageId": "page-1",
"content": "https://storage.orshot.com/.../slide1.png"
},
{
"page": 2,
"pageId": "page-2",
"content": "https://storage.orshot.com/.../slide2.png"
},
{
"page": 3,
"pageId": "page-3",
"content": "https://storage.orshot.com/.../slide3.png"
},
{
"page": 4,
"pageId": "page-4",
"content": "https://storage.orshot.com/.../slide4.png"
}
],
"format": "png",
"totalPages": 4
}
```These are the four slides you saw at the top of this post.
### Render each carousel page as an animated reel (MP4)
Switch to `"format": "mp4"` and every page renders as its own video, with the template's layer animations playing out frame-perfectly β the cover runs 3.3 seconds, the note slides about 2.5 each:```json
{
"data": [
{
"page": 1,
"content": "https://storage.orshot.com/.../page1.mp4",
"videoDuration": 3.3
},
{
"page": 2,
"content": "https://storage.orshot.com/.../page2.mp4",
"videoDuration": 2.5
}
],
"format": "mp4",
"totalVideoDuration": 11.25
}
```Use these as standalone reels, Stories, or video slides inside a mixed carousel (Instagram allows mixing photos and videos in one carousel post).
### Combine all slides into one Instagram video
This is the one no other carousel workflow offers: add [`videoOptions.combinePages`](https://orshot.com/docs/video-generation/video-options) and the API stitches every page into **a single video**, with an optional transition between pages:```json
{
"templateId": 12372,
"modifications": { "...same as above..." },
"response": { "type": "url", "format": "mp4" },
"videoOptions": {
"combinePages": true,
"pageTransition": "fade",
"pageTransitionDuration": 0.4
}
}
```Unlike the per-page render, the response comes back with a **single video URL** instead of an array:```json
{
"data": {
"content": "https://storage.orshot.com/.../combined.mp4",
"type": "url",
"format": "mp4",
"videoDuration": 10.05
}
}
```**[βΆ Watch the real combined render (10s MP4)](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets/carousel-combined.mp4 "target=_blank")** β all four slides in one video: each page plays its animations, then fades to the next. That's a ready-to-post reel summarizing the whole carousel, from the same Sheet row.
Transitions include `fade`, `slideleft`, `circleopen`, `dissolve` and more β or omit it for hard cuts. (`combinePages` works for `mp4` and `webm`; GIFs always come back per-page.)
You can try all three modes without touching Make: the template's [API playground](https://orshot.com/docs/orshot-studio/embedding-playground) lets you fire test renders from the browser:
## Step 6 β Auto-publish to Instagram as a carousel
Here's the part every render-API competitor leaves you to figure out alone: getting slides _posted_. With Orshot, the `publish` object inside the render request handles it β for multi-page templates, **all pages are automatically uploaded and posted as a carousel**. No extra calls, no Graph API setup, no image host.
First connect Instagram under **Social Accounts** and copy the numeric account ID:
Then the `publish` block from Step 4 does the rest:```json
"publish": {
"accounts": [19],
"content": "Three notes I'm keeping pinned this week π Save the one you need."
}
```The response tells you exactly what happened per account β `published`, `scheduled`, or `failed` β and you can pass `schedule.scheduledFor` to queue the post for a specific time instead of publishing immediately. The same block works for LinkedIn, X, Pinterest and the rest of the [supported platforms](https://orshot.com/docs/publish/publish-from-api); video formats publish as reels.
> **Test safely:** while you're experimenting, leave `publish` out entirely (you'll get render URLs back, nothing is posted) β or keep `accounts: [0]`, which fails harmlessly. Add your real account ID only when the renders look right.
## Make it run on its own
Flip the scenario's scheduling toggle on and Make checks the Sheet on an interval (every 15 minutes on the free plan). From then on the workflow is: write a row β carousel appears on Instagram. Your "posting tool" is a spreadsheet.
Writing rows is also automatable β anything that can add a Google Sheets row can now post carousels: a form tool, an automation from your CMS, or an LLM that drafts next week's notes straight into the sheet.
## Bulk-create a month of carousels
Because the trigger processes rows in order, batching is just⦠pasting rows. Drop in 30 rows, set the limit to 1 per cycle, and the scenario drips one carousel per run; or temporarily raise the limit and schedule posts at specific times with `schedule.scheduledFor` per row (add a `post_at` column and map it).
For one-off bulk runs without Make at all, the same render endpoint accepts the rows from any script β see [bulk image generation](https://orshot.com/blog/canva-bulk-create-alternative) for the spreadsheet-only version of this pattern.
## What it costs
Honest math: Make's free tier (1,000 operations/month) is far more than this needs β a daily carousel uses ~60 operations a month. On the Orshot side, each rendered page counts toward your plan's render quota, and the [free tier's 60 renders](https://orshot.com/pricing) are enough to build, test, and post your first week of carousels before paying anything. No other tools, hosts, or per-seat design licenses are involved β that's the point.
## What this can't do (yet)
- **Instant triggers.** Google Sheets polling means minutes, not seconds, between row and post. For real-time, swap the trigger for a webhook.
- **Per-slide captions or alt text.** The caption applies to the whole carousel post, not individual slides.
- **Design changes from the Sheet.** The spreadsheet changes _content_, not layout. New look = edit the template (once).
- **Engagement.** This posts; it doesn't reply to comments or analyze performance. Pair it with your analytics tool of choice.
## Prefer n8n? Same flow, two nodes
If your automations live in n8n, the identical pipeline is a Google Sheets Trigger plus one HTTP Request node β **[download the workflow JSON](https://orshot.com/blog/auto-generate-instagram-carousels-google-sheets/n8n-sheet-to-instagram-carousel.json "target=_blank")** and import it. It ships with a third, **deactivated** node that renders the combined video, so nothing fires until you enable it:
For a deeper n8n walkthrough (including rendering image + video variants and posting to LinkedIn), see the full [n8n marketing automation tutorial](https://orshot.com/blog/n8n-marketing-automation-tutorial).
## FAQ
**Q: Can you fully automate Instagram carousels end to end?**
Yes β that's exactly what this setup does: a Google Sheet row triggers Make, Orshot renders all slides from a designed template, and the publish object posts them to Instagram as a carousel with your caption. After setup, writing a row is the entire workflow.
**Q: How many slides can an Instagram carousel have?**
Instagram supports up to 20 slides per carousel post. This tutorial's template uses 4 pages, but Orshot templates can have as many pages as your carousel needs.
**Q: Can an Instagram carousel mix images and videos?**
Yes. Instagram lets you mix photos and videos in one carousel. Render some pages as PNG and some as MP4 (each page renders as its own video), and publish the combination.
**Q: Do all carousel slides need the same aspect ratio?**
Yes β Instagram applies the first slide's ratio to the whole carousel. Multi-page Orshot templates share one canvas size (1080Γ1350 here), so this is handled automatically.
**Q: Should I use Make or n8n for this?**
Both work with the same single API call. Make is friendlier if you've never automated anything (visual modules, generous free tier). n8n suits self-hosters and technical teams. Downloads for both are at the top of this post.
**Q: Why use a template render API instead of an AI image generator?**
Text accuracy and brand control. AI image models routinely misspell headline text and re-interpret your brand every generation. A template renders your actual fonts, colors, and layout with the exact words from your spreadsheet, every time.
**Q: Can I schedule carousels instead of posting immediately?**
Yes β add schedule.scheduledFor (an ISO date) to the publish object, optionally with a timezone. Add a column for it in your Sheet and every row can carry its own posting time.
**Q: Do I need a Facebook/Meta developer app to auto-post?**
No. Connecting Instagram to Orshot in Social Accounts handles authentication β there's no Graph API app to create, verify, or maintain, which is the most painful step in DIY carousel automations.
**Q: How do I turn the carousel into a single video or reel?**
Set format to mp4 and add videoOptions.combinePages: true with an optional pageTransition. The API returns one video where each slide plays its animations and transitions to the next β ready to publish as a reel.
**Q: What happens if a render or post fails?**
The API response includes a status per publish account (published, scheduled, drafted, or failed), so your scenario can branch on failures β for example, alerting you in Slack or retrying the row.
## The bottom line
A carousel-a-day habit is one of the highest-leverage formats on Instagram β and the actual bottleneck was never ideas, it was production. With a designed template, a Sheet, and two Make modules, production rounds to zero: the same row becomes branded slides, animated reels, or one combined video, posted without you touching a design tool.
Design your carousel template once, connect your sheet, and let the calendar post itself β **[start free with 60 renders](https://orshot.com/pricing)**.
