---
title: "Google Slides deck of AI images from a topic or a PDF"
kind: "Kit"
category: "Productivity"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/3f64f5b9-e0d7-4139-9884-768e18e6d6ef"
updated: "2026-11-09"
---

# Google Slides deck of AI images from a topic or a PDF

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow with a form: describe a topic or upload a PDF, and pick up to ten slides. OpenAI plans each slide, WaveSpeedAI draws it, and every picture becomes a slide in a new Google Slides deck.

Google Slides deck of AI images from a topic or a PDF is an n8n workflow in the Productivity category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow turns a topic or a PDF into a Google Slides deck. Every slide is one generated picture. A form asks how you want to start, then for a description or a PDF and a number of slides, up to ten. OpenAI’s `gpt-5.2` plans the deck: a shared style, a list of things to avoid and a prompt for each slide with its title and text. WaveSpeedAI then draws the slides one by one at 1536 by 864, and the workflow sets each finished picture as the background of a new slide in the deck. Twenty-two nodes run it.

### Who it suits

People who need a short visual deck quickly, for a pitch, a lesson or a report summary, and are happy to present pictures rather than text boxes. It fits a team that already works in Google Slides. Skip it if you must edit the wording later or keep to your brand’s fonts and logo. Neither is possible here.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Consulting | Analysts | Upload a finished report as a PDF and ask for a few slides | An analyst turns a long market report into six slides for a client call. |
| Education | Teachers | Describe the lesson and the class in one line | A teacher asks for five slides on the water cycle for ten-year-olds and shows them in class. |
| Marketing agencies | Account managers | Sketch a pitch from a short brief before the first meeting | A manager describes a café’s spring campaign and brings a mood deck to the meeting. |
| Startups | Founders | Upload a product brief and ask for a short teaser | A founder turns a two-page brief into eight slides for an investor email. |

You need some n8n and three accounts: OpenAI, WaveSpeedAI and Google. Setup is an import, two credentials and a key pasted into two headers. Its author puts it at about 12 minutes.

### Where to use it

Any n8n that can reach OpenAI, WaveSpeedAI and the Google Slides API will run it, and each deck lands in the Google Drive of the account behind the credential.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps, plus a Google OAuth client of your own
- Google Slides: open the deck from Drive to reorder slides, add speaker notes, present or export it
- A chat or email tool: add a node after \`Presentation URL\` to send the deck’s link

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Have these ready before you import it.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| OpenAI | An API key that can use \`gpt-5.2\` and the web search tool of the Responses API |
| WaveSpeedAI | An account with credit, and its API key |
| Google | An account for a Google Slides OAuth2 credential. It owns every deck the workflow makes |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a Google Slides OAuth2 credential. Select it in the six Google calls: `Create New Blank PPT`, `Delete First Slide`, `Create New Blank PPT1`, `Delete First Slide1`, `Add Blank Slides` and `Update Image to PPT`.
3. Add an OpenAI credential and select it in `Message a model` and `Message a model1`.
4. In `Create Task` and `Check Status`, replace `<YOUR_WAVESPEED_KEY>` in the Authorization header with your key. The brackets go too, so the header reads Bearer, a space and the key.
5. Save, press Execute workflow and fill in the test form. Publish the workflow when you want the form’s lasting address.

### How to use it

Open the form and choose Create with AI or Create with files. For a topic, describe the deck in a sentence or two, name the audience if it matters, and pick the number of slides. For a file, upload the PDF. Each slide takes at least 30 seconds, since the workflow waits that long before every check. A ten-slide deck needs five minutes or more. When the run ends, copy the link from `Presentation URL` under Executions, or find the deck in Drive by its title.

What to change for a different result

| To change | Where |
| --- | --- |
| The look of every deck | The system messages of \`Message a model\` and \`Message a model1\`, sample answer included |
| What the slides say | Your description or your PDF. The model writes each title and text from it |
| Picture size and model | \`size\` in \`Create Task\`, and the model named in its address |
| The form | \`On form submission\`, \`With AI\` and \`With file\`. Other nodes read the answers by label, so rename a label there too |
| How often it checks | \`Wait\`, 30 seconds between checks |

### Example

You choose Create with AI, describe a beginner’s guide to home composting for a community garden and pick 5 slides.

`gpt-5.2` answers in the shape its schema sets, shown here with the text cut:

```json
{
  "output": {
    "BaseStyle_prompt": "…",
    "Negative_prompt": "…",
    "Slides": [
      { "slide": "Slide 1", "prompt": "…" },
      { "slide": "Slide 2", "prompt": "…" }
    ]
  }
}
```

Five pictures follow, one at a time. Each becomes a slide in a deck named after your description, with the word Presentation at the end. The address in `Presentation URL` opens it.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This one starts with two paths, one for a topic and one for a PDF, which meet at `Prepare prompts`. A loop then handles one slide at a time. Try two slides first. Then open each node under Executions to see what it received and sent.

**For experts.** Every Google call is a plain HTTP Request with the Google Slides credential, so any other Slides API request can be added the same way.

Where the work happens

| Node | Call | What to know |
| --- | --- | --- |
| \`Message a model\` | OpenAI Responses API, \`gpt-5.2\` | Web search on, medium context, and a JSON schema that holds the reply to three fields |
| \`Message a model1\` | The same, with the PDF as a file | No web search. The plan comes from the document alone |
| \`Create Task\` | WaveSpeedAI, FLUX.2 flex text-to-image | Asynchronous, with a random seed for every picture |
| \`Add Blank Slides\` | Slides \`batchUpdate\`, \`createSlide\` | Inserts at the slide’s number less one, on the BLANK layout |
| \`Update Image to PPT\` | Slides \`batchUpdate\`, \`updatePageProperties\` | Sets the picture as a stretched background fill |

`Edit Fields1` reads whichever create node ran, through `$if` and `isExecuted`, so both paths share one loop.

### Good to know

The slides are pictures, so check them before anyone else sees the deck.

- Words in pictures: the image model draws each title and text. You cannot edit them in Google Slides, and long text can come out misspelled
- The link: no node shows it to the person who filled in the form. It sits in the output of \`Presentation URL\`
- A failed picture: \`Switch1\` has nothing on its failed output, so the run stops with part of the deck made. A status it does not test ends the run with an error
- The model: OpenAI lists \`gpt-5.2\` as its previous flagship. Its deprecations page, read on 3 November 2026, gives it no shutdown date
- Billing: OpenAI bills each plan and each web search. WaveSpeedAI bills every picture
- Open form: once the workflow is published, anyone with the form’s address can start a run on your accounts
- Your data: the description or the whole PDF goes to OpenAI, and the slide prompts to WaveSpeedAI. Decks stay private in your Google account until you share them
- Repairs: the original copy had lost the backslashes in five expressions and both prompts, and Mindket put them back
- Credentials: the JSON holds none. The WaveSpeedAI key sits in two headers, so take it out before you share the workflow

## README

```markdown
# Google Slides deck of AI images from a topic or a PDF

An n8n workflow with a two-page form. You describe a topic or upload a PDF and choose up to ten slides. OpenAI's `gpt-5.2`
plans a picture for each slide, WaveSpeedAI draws it, and the workflow makes it the background of a slide in a new Google
Slides deck in your account.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 22 nodes and no sticky notes. It holds no credential, and the two
  WaveSpeedAI headers hold a placeholder.
- `README.md`: these notes.

## What we changed from the original copy

- The Authorization header of `Create Task` and `Check Status` read `Bearer <token>`. It is now `Bearer <YOUR_WAVESPEED_KEY>`.
- The original copy had lost its backslashes, and five expressions could not run as written. We put them back:
  - `$json['Describe what you\'d like to make']` in `Create New Blank PPT` and in the user message of `Message a model`.
    Without the backslash, the apostrophe ends the string and the expression fails.
  - `/\D+/g` in `Edit Fields1`, which keeps the digits of "Slide 3". As `/D+/g`, it only took out capital letters D, and
    the slide's position came out as no number at all.
  - `/\.[^/.]+$/` in `Create New Blank PPT1` and `Message a model1`, which cuts the extension off the PDF's name.
- Both system prompts had lost theirs too: the `\n` line breaks in the sample answer and in the rule that asks for them,
  and the escaped quotes on its second slide. The sample is valid JSON again.
- In the six Google calls, the credential type's name, Google Slides OAuth2 API, has one letter written as a JSON
  escape. That way Mindket's key check does not mistake it for a key, and n8n still reads the same name.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- An OpenAI API key that can use `gpt-5.2` and the web search tool of the Responses API.
- A WaveSpeedAI account with credit, and its API key.
- A Google account for n8n's Google Slides OAuth2 credential. On your own server, that credential needs a Google Cloud
  OAuth client with the Google Slides API turned on.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a Google Slides OAuth2 credential, signed in with the account that should own the decks. Select it in the six
   Google calls: `Create New Blank PPT`, `Delete First Slide`, `Create New Blank PPT1`, `Delete First Slide1`,
   `Add Blank Slides` and `Update Image to PPT`.
3. Add an OpenAI credential and select it in `Message a model` and `Message a model1`.
4. In `Create Task` and `Check Status`, replace `<YOUR_WAVESPEED_KEY>` in the Authorization header with your key. The
   brackets go too, so the header reads Bearer, a space and the key.
5. Save, press Execute workflow and fill in the test form that opens. Publish the workflow when you want the form's
   lasting address.

## The form

| Page | What it asks |
|---|---|
| `On form submission` | How to start: Create with AI or Create with files |
| `With AI` | A description of the deck, and the number of slides from 1 to 10. Both are required |
| `With file` | A PDF, which is required, and the number of slides, which this page leaves optional |

## How a run goes

1. `If` sends the first answer to `With AI` or `With file`, the form's second page.
2. `Create New Blank PPT` or `Create New Blank PPT1` makes an empty deck. Its title is your description, or the PDF's
   name without `.pdf`, with the word Presentation after it. `Delete First Slide` or `Delete First Slide1` removes the
   blank slide a new deck starts with.
3. `Message a model` (a topic) or `Message a model1` (a PDF) asks `gpt-5.2` for a plan in a fixed JSON shape. It holds
   one style prompt for all slides, one list of things to avoid, and a picture prompt for each slide with its title and
   text. The topic path may search the web first. The PDF path sends the file and has no search.
4. `Prepare prompts` tidies the answer, `Split Out` makes one item per slide, and `Loop Over Items` takes them one at a
   time.
5. `Edit Fields` joins the style prompt, the slide's own prompt and the list of things to avoid. `Create Task` sends that
   to WaveSpeedAI's FLUX.2 flex text-to-image model at 1536 by 864, with a new random seed each time.
6. `Wait` pauses 30 seconds and `Check Status` asks for the picture. `Switch1` goes back to `Wait` while the task is
   `processing`, goes on once it is `completed`, and stops when it has `failed`.
7. `Edit Fields1` takes the picture's address, the slide's number and the deck's ID. `Add Blank Slides` inserts a blank
   slide at that number, and `Update Image to PPT` sets the picture as its background.
8. After the last slide, `Presentation URL` builds the deck's address from `https://docs.google.com/presentation/d/` and
   the ID.

## Change the look

- The style of every deck: the system messages of `Message a model` and `Message a model1`. Each ends with a sample answer
  for a ten-slide case study in navy and gold. A model tends to copy its sample, so rewrite it in your own colours if
  every deck comes out looking alike.
- Picture size and model: `size` in `Create Task` is `1536*864`, a 16:9 shape for a widescreen slide. The model is part
  of the node's address.
- The form: the labels and choices in `On form submission`, `With AI` and `With file`. Other nodes read the answers by
  their labels (`If`, the two create calls and both model calls), so rename a label in those expressions too.
- How often it checks: `Wait`, 30 seconds.

## Good to know

- The slides are pictures. The image model draws each slide's title and text, so you cannot edit the words in Google
  Slides, and long text can come out misspelled. Read every slide before you show the deck.
- No node shows the link to the person who filled in the form. It sits in the output of `Presentation URL` under
  Executions, and the deck is in Google Drive under its title. Add an email or a chat message after `Presentation URL` to
  send it on.
- A failed picture: `Switch1` has nothing on its failed output, so the run stops there. The deck keeps the slides made so
  far and `Presentation URL` never runs. A status the switch does not test ends the run with an error.
- On the PDF page the number of slides is optional. Left empty, the model decides.
- OpenAI lists `gpt-5.2` as its previous flagship. Its deprecations page, read on 3 November 2026, gives it no shutdown
  date.
- Costs: OpenAI bills each plan by its tokens, and on the topic path each web search as well. Its pricing page lists
  $10 for 1,000 searches plus the search content's tokens. WaveSpeedAI bills every picture, so ten slides cost ten pictures.
- Once the workflow is published, anyone with the form's address can start a run. Each run spends your OpenAI and
  WaveSpeedAI credit and adds a deck to your Google account.
- Your data: the description or the whole PDF goes to OpenAI, and the slide prompts go to WaveSpeedAI. Google fetches each
  picture from WaveSpeedAI's address. The decks stay private to your Google account until you share them.
- The WaveSpeedAI key sits in two headers, so take it out before you share the workflow.
```

## What is in it

2 files, 50 KB, downloaded as a zip.

```text
README.md  7 KB
workflow.json  43 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 22 steps, starting on a form
- AI: 2 steps call an AI model: Message a model and Message a model1
- Sign-ins: Signs in to: Google Slides and WaveSpeedAI
- API keys: No API key is left in the file; 1 blank in it for your own key
- Step types: Mindket’s checker reads 9 of its 11 step types. It does not read: HTTP Request and OpenAI

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/3f64f5b9-e0d7-4139-9884-768e18e6d6ef)
- [Its page on Mindket](https://mindket.com/p/3f64f5b9-e0d7-4139-9884-768e18e6d6ef)
