---
title: "Text to image with Flux on fal.ai saved to Google Drive"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/a2ac6171-fa16-4f48-8476-4f1a0648c9ed"
updated: "2026-11-12"
---

# Text to image with Flux on fal.ai saved to Google Drive

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

An n8n workflow that sends a prompt to the Flux dev model on fal.ai, waits until the picture is ready, downloads it and saves it in a Google Drive folder.

Text to image with Flux on fal.ai saved to Google Drive is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. 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 one line of text into a picture and files it in Google Drive. You press a button. The workflow sends your prompt to the Flux dev model on fal.ai, then asks every three seconds whether the picture is ready. When it is, the workflow downloads the image and uploads it to a Drive folder of your choice. Nobody opens fal.ai or saves a file by hand. Nine nodes sit in it, beside three sticky notes.

### Who it suits

Designers, marketers and small teams who need quick pictures for posts, slides or mock-ups and want them in a shared folder, not lost in a browser tab. It suits anyone who already lives in Google Drive. Skip it if you need hundreds of pictures from a list, because it makes one picture per press. A loop over a sheet of prompts would need extra nodes that this file does not hold. Skip it too if you want more control over style than a prompt gives.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Marketing | Social media managers | Make a picture for each post idea | A manager types the idea as a prompt and finds the picture in the team folder. |
| Design | Designers | Test visual ideas before a shoot | A designer tries ten wordings of one scene and compares the files. |
| Education | Teachers | Illustrate a slide or a worksheet | A teacher describes a scene from a lesson and drops the picture into the class folder. |
| Small business | Shop owners | Make banners and product backgrounds | An owner asks for a plain wooden table with soft light and saves it for later. |

You need an n8n, a fal.ai API key and a Google account with a Drive folder.

### Where to use it

Any n8n that can reach fal.ai and Google Drive will run it. It starts by hand, so it fits a quick session at your desk. To make it run on its own, swap the first node for a schedule, a form or a webhook.

- n8n Cloud: bring in the file, connect your accounts and run it
- Your own n8n server: the same file
- A local install: it works the same, and the picture still lands in Drive
- A team: point the Drive node at a shared folder

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Import the file, add two credentials, pick a folder and write a prompt.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| fal.ai | An account and an API key |
| Google Drive | A Google account, a folder, and an OAuth2 credential in n8n |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Create a Header Auth credential. Set its name to `Authorization` and its value to `Key <YOUR_FAL_KEY>`, with your own key in place of the placeholder. Add it to `Fal Flux`, `Check Status` and `Get Image Result URL`.
3. Add a Google Drive OAuth2 credential to `Google Drive`, then pick the folder that should receive the pictures.
4. Open `Edit Fields` and write your prompt. Change the width, height, steps and guidance if you like.
5. Select Test workflow.

### How to use it

Write what you want to see in the prompt, then run the workflow. After a short wait, the picture appears in your Drive folder. Change one word and run it again to compare. Short prompts work. Each run makes a new file.

What to change for a different result

| To change | Where |
| --- | --- |
| The picture | The prompt, width, height, steps and guidance in \`Edit Fields\` |
| The format or the number of images | The body in \`Fal Flux\` |
| How often it checks | \`Wait 3 Sec\` |
| Where it lands | The folder in \`Google Drive\` |

### Example

A shop owner needs a banner background for a spring sale. She types a prompt about pale green leaves on a white table with soft morning light, and runs the workflow.

About half a minute later a file appears in her Drive folder. The picture is 1024 by 768 pixels. She does not like the leaves, so she rewrites the prompt and runs it again. Both files stay in the folder, so she can compare them side by side.

### 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. fal.ai is a service that runs image models for you. Flux is one such model. You send a prompt, and it returns a picture. Making one takes a few seconds, so the workflow asks again and again until the picture is done.

**For experts.** fal’s queue answers at once with a request id, and the workflow polls that id in a loop.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Fal Flux\` | Posts the prompt and the settings to the Flux dev queue | The prompt goes in with \`JSON.stringify\`, so quotes and line breaks cannot break the body |
| \`Check Status\` | Asks fal for the status of the request | The address holds only the owner and the app, \`fal-ai/flux\`, as fal’s documentation asks |
| \`Completed?\` | Tests whether \`status\` equals \`COMPLETED\` | A failed request also reads \`COMPLETED\`, with an error, and the loop has no limit |
| \`Get Image Result URL\` | Fetches the finished result | The result lists the pictures and their addresses |
| \`Download Image\` | Downloads the first picture as a file | It fails when the result holds an error |
| \`Google Drive\` | Uploads the file under its own name | The folder picker starts blank |

### Good to know

The notes come from fal’s documentation and its model page, read on 12 November 2026, and nothing was run.

- Loop: the check repeats until fal says \`COMPLETED\`, with no limit. A request that stalls keeps the run waiting
- Failures: a failed request also ends as \`COMPLETED\`, with an error message, and \`Download Image\` then stops
- Addresses: the status and result addresses use only the owner and the app, \`fal-ai/flux\`. fal’s documentation says an address with \`/dev\` in it answers 405, so the file is right
- Cost: fal’s model page shows USD 0.025 per megapixel, rounded up. A 1024 by 768 picture counts as one megapixel
- Limits: fal accepts 1 to 50 steps, a guidance value from 1 to 20, and a side up to 14142 pixels
- Safety: the safety checker is on, so an image flagged as unsafe comes back black
- Licence: fal’s model page calls Flux dev suitable for personal and commercial use. Read fal’s terms for your case
- Storage: the picture’s address on fal is public and expires under your media settings, which is why the workflow downloads it at once
- Repairs: the sample prompt described a person and is now a lighthouse at sunrise. The prompt is written into the request with \`JSON.stringify\`, so a quote mark no longer breaks it. The Drive folder was blanked, and a sticky note’s key example became a placeholder
- Not run: no request went to fal and no file went to Drive. The notes come from fal’s pages
- Your data: the prompt goes to fal, and the picture goes to your Drive
- Credentials: the JSON holds none

## README

```markdown
# Text to image with Flux on fal.ai saved to Google Drive

An n8n workflow that makes one picture from a text prompt with the Flux dev model on fal.ai. It waits until the picture
is ready, downloads it and saves it in a Google Drive folder.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 9 nodes and 3 sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The sample prompt described a person. It now describes a lighthouse at sunrise, so the file starts from a neutral
  example.
- `Fal Flux` wrote the prompt into its JSON body as plain text, so a quote mark or a line break in a prompt would break
  the request. The body now writes the prompt with `JSON.stringify`.
- The Drive folder in `Google Drive` held the original author's folder. It is blank now.
- A sticky note showed the start of a real key as its example. It now reads `Key <YOUR_FAL_KEY>`.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A fal.ai account and an API key.
- A Google account that can write to a Drive folder, and a Google Drive OAuth2 credential in n8n.

## Set it up

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Create a Header Auth credential. Set its name to `Authorization` and its value to `Key <YOUR_FAL_KEY>`, with your own key
   in place of the placeholder. Add it to `Fal Flux`, `Check Status` and `Get Image Result URL`.
3. Add a Google Drive OAuth2 credential to `Google Drive`, then pick the folder that should receive the pictures.
4. Open `Edit Fields` and write your prompt. Change the width, height, steps and guidance if you like.
5. Select `When clicking ‘Test workflow’` and run the workflow.

## How a run goes

1. `When clicking ‘Test workflow’` starts the run by hand.
2. `Edit Fields` holds the settings: `Prompt`, `Width` (1024), `Height` (768), `Steps` (30) and `Guidance` (3.5).
3. `Fal Flux` posts them to `https://queue.fal.run/fal-ai/flux/dev`, asking for one image with the safety checker on.
   fal answers at once with a request id.
4. `Wait 3 Sec` pauses for three seconds. `Check Status` asks fal for that request's status. `Completed?` tests whether
   `status` equals `COMPLETED`. If it does not, the run goes back to the wait.
5. `Get Image Result URL` fetches the finished result, which lists the pictures and their addresses. `Download Image`
   downloads the first one as a file. `Google Drive` uploads it, under the file's own name, to your folder in My Drive.

## Change the look

- The picture: the prompt, width, height, steps and guidance in `Edit Fields`.
- The format or the number of images: the body in `Fal Flux`. Only the first picture is saved.
- How often it checks: `Wait 3 Sec`.
- Where it lands: the folder in `Google Drive`.

## Good to know

- The facts below come from fal's queue documentation, its OpenAPI file and its model page, read on 12 November 2026.
  Nothing was run: no request to fal and no upload to Drive.
- The status and result addresses use only the owner and the app, `fal-ai/flux`, and not the full `fal-ai/flux/dev`.
  fal's documentation says an address that includes the endpoint path answers 405, so the file is right.
- A failed request also ends as `COMPLETED`, with an error message. `Get Image Result URL` then returns that error, and
  `Download Image` stops. A request that never completes keeps the loop polling, because it has no limit.
- fal's model page shows USD 0.025 per megapixel, rounded up. A 1024 by 768 picture is under one megapixel, so it counts
  as one.
- fal accepts 1 to 50 steps and a guidance value from 1 to 20. A side may be up to 14142 pixels. The defaults are 28 steps
  and 3.5.
- With the safety checker on, an image flagged as unsafe comes back black.
- fal's model page calls Flux dev suitable for personal and commercial use. Read fal's terms for your case.
- The picture's address on fal is public and expires under your media expiration settings. This workflow downloads it at
  once for that reason.
- Your data: the prompt goes to fal, and the picture goes to your Drive.
- Credentials: the JSON holds none.
```

## What is in it

3 files, 13 KB, downloaded as a zip.

```text
NOTICE.md  633 B
README.md  4 KB
workflow.json  8 KB
```

## Workflow check

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

- Steps: 9 steps, starting by hand
- AI: No step calls an AI model
- Sign-ins: Signs in to: fal.ai and Google Drive
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 6 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/a2ac6171-fa16-4f48-8476-4f1a0648c9ed)
- [Its page on Mindket](https://mindket.com/p/a2ac6171-fa16-4f48-8476-4f1a0648c9ed)
