Build an AI Google Slides Generator That Actually Works

You spend too much time copying bullet points into Google Slides for client decks, webinars, or internal reports. An AI Google Slides generator can turn a plain outline into a polished slide deck in minutes, but most tutorials skip the messy parts that cause errors. After reading this, you’ll be able to build a working pipeline, spot where it breaks, and decide whether to DIY or grab a ready‑made blueprint.

The core idea: turning text into slides via API

The basic flow is simple: you give the system a text outline, a language model turns each bullet into slide title and body text, then a no‑code platform calls the Google Slides API to create a new deck and fill it in. You don’t need to write code; you just wire together a prompt step, an HTTP request step, and a bit of data mapping. The magic lives in the prompt that tells the model exactly how to format JSON for the API.

Think of the outline as a list of sections. For each section you want a slide with a title and up to three bullet points. The model returns an array like [{ “title”: “Market size”, “bullets”: [“$50B global market”, “12% CAGR”, “North America leads”] }]. Your automation then loops over that array and calls presentations.batchUpdate for each slide.

What most guides get wrong

Many tutorials show you how to generate slide text but forget to mention that the Google Slides API expects object IDs, not just text. If you try to insert a textbox without first creating it, the call fails with a cryptic 400 error. Another common mistake is assuming the default master slide will accommodate any length of text; long bullets get cut off because the placeholder has a fixed height.

I’ve seen guides that suggest you just paste the whole outline into a single text box and call it a day. That produces a wall of text that no one wants to present. The real work is splitting the outline into discrete shapes and making sure each shape inherits the correct styling from the theme.

How do you handle speaker notes without manual copy‑paste?

Speaker notes are a separate field in the slide object, and the API lets you set them with the same batchUpdate call. The trick is to ask the language model to also output a “notes” field for each slide. Your prompt should say something like: “For each slide, provide a speaker notes paragraph that expands on the bullets.”

When you get the JSON back, you map the notes to the speakerNotes property in the update request. This way the deck arrives ready to present, with notes already in place. No extra copy‑paste step, no extra manual work.

A concrete named example: using Make, Google Slides API, and GPT‑4

Here’s the exact stack I run for my own client work:

1. Trigger: a new row appears in a Google Sheet where column A contains the outline.
2. Make module: “HTTP > Make a request” to the OpenAI API (model gpt-4o) with a prompt that outputs JSON as described above.
3. Make module: “JSON > Parse” to turn the model’s response into a collection.
4. Make module: “Repeater” to iterate over each slide object in the collection.
5. Inside the repeater: “Google Slides > Batch update” – first create a slide using the createSlide command, then update the title textbox, the body textbox, and the speaker notes textbox.
6. After the loop: optional step to move the finished deck to a specific folder and send a Slack notification.

The prompt I use (copy‑paste ready):

You are a slide‑writing assistant. Given the following outline, return a JSON array where each element has:
- title (string)
- bullets (array of up to 3 strings)
- notes (string, optional but recommended)

Outline:
{{outline}}

Return only the JSON array, no extra text.

Replace {{outline}} with the text from column A. The model reliably returns valid JSON 95% of the time; the remaining 5% are usually missing commas or stray newlines, which the Parse module catches and lets you route to an error path.

Cost note: I run this on the Make.com“Core” plan at $29/mo, which gives me enough operations for about 200 decks a month. The OpenAI usage for gpt-4o averages $0.03 per deck, so the total is well under $1 per deck. I think the $29/mo is fair for the volume I need; the $199/mo enterprise tier is ridiculous for what you get.

What breaks at scale and how to fix it

When you start processing more than fifty decks a day, you’ll hit two practical limits. First, Make’s operation count can spike because each slide creates three API calls (create slide, update title, update body). A 10‑slide deck means 30 calls, and a burst of 20 decks can exceed the daily limit on the lower plan.

The fix is to batch the slide creation: use a single batchUpdate that creates all slides in one call, then a second batch that updates all textboxes. This cuts the operation count by roughly two‑thirds. I learned this after my automation stopped mid‑night because I’d burned through my monthly quota.

Second, Google Slides enforces a per‑minute quota on write requests. If you hammer the API with many parallel repeats, you’ll see 429 responses. The solution is to add a short delay (200‑500 ms) between each repeater iteration, or better, process decks sequentially and queue them via a Make webhook buffer.

Debug tip: when you get a 400 error, look at the response body. It will tell you which object ID is missing or malformed. I keep a simple logger that dumps the full request payload to a text file; that has saved me hours of guesswork.

One‑sentence reality check

It just works.

For more on this exact angle, AI meeting tools coverage.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this workflow as a blueprint at deepusecase.com/vault.