---
title: "Web address that draws a picture from a prompt with OpenAI"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/f64db9de-b6cc-443b-bed0-58a34980be97"
updated: "2026-11-12"
---

# Web address that draws a picture from a prompt with OpenAI

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

An n8n workflow with a webhook: open its address with a prompt after ?input= and an OpenAI image model draws the picture. The image comes back in the same call, so a browser shows it on the spot.

Web address that draws a picture from a prompt with OpenAI is an n8n workflow in the Developer 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 a web address into a small image maker. It waits for a GET request, reads the `input` value from the address and sends it to an OpenAI image model as the prompt. The picture comes back in the same call as a file, so a browser shows it right away. Three nodes do the work, beside four sticky notes that explain the steps.

### Who it suits

Developers and makers who want a plain picture endpoint for a prototype, a page of their own or another tool’s HTTP step. Skip it if you need a guarded public service. As imported, anyone who has the address can start a run.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Web development | Front-end developers | Point an image tag at the address with a prompt in it | A developer fills a mockup page with pictures drawn from prompts. |
| Marketing | Content teams | Open the address by hand to try prompts for post pictures | A marketer tries five prompts for a launch post by editing the address. |
| No-code building | Makers | Call the address from another tool’s HTTP step and keep the file | A maker’s form tool fetches one picture for each new entry. |
| Education | Teachers | Draw an illustration for a handout from one line | A teacher gets a picture of the water cycle for a worksheet. |

You need a little n8n: import a file, add one OpenAI credential and paste an address into a browser.

### Where to use it

Any n8n that can reach OpenAI’s API will run it. The picture goes back to whoever opened the address.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps
- A browser: paste the address and watch the picture load
- Another app: call the address with a GET request and save the file it returns

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. One OpenAI key covers it.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| OpenAI | An API key for an OpenAI credential, with access to image generation |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add an OpenAI credential with your key and select it in `OpenAI`.
3. Open `Webhook`. If the address will be public, change its path from `image-api` to a long random string.
4. Copy the webhook’s test address and add `?input=` and your prompt, with each space written as `%20`.
5. Save, press Execute workflow and open the whole address in a browser.
6. Press Publish and use the production address the same way.

### How to use it

Take the webhook’s address, add `?input=` and a prompt, and write each space as `%20`. Open it in a browser or call it from another tool. The reply is the picture, so the browser shows it instead of a page. A missing prompt stops the run with an error.

What to change for a different result

| To change | Where |
| --- | --- |
| The model | \`modelId\` in \`OpenAI\`, \`gpt-image-2.6-flare\` in Mindket’s copy |
| The prompt’s source | \`prompt\` in \`OpenAI\`, which reads \`query.input\` from the address |
| The address | The path in \`Webhook\`, \`image-api\` in Mindket’s copy |
| The reply | \`Respond to Webhook\`, which sends back the file as it is |

### Example

A developer adds `?input=a%20red%20bicycle%20against%20a%20brick%20wall` to the production address and opens it in a browser.

The webhook passes that prompt to the image model. The model draws the picture, and `Respond to Webhook` returns it as an image file. The browser shows a red bicycle against a brick wall instead of a page of text.

### 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 is a straight line of three: the webhook, the OpenAI node and the reply. The four sticky notes on the canvas label the steps and say how to build the address. Run it once with a short prompt.

**For experts.** The prompt travels in the query string, so there is no body to parse and no path variable.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Webhook\` | Webhook 1.1 with no method set, so it listens for GET | \`responseMode\` is \`responseNode\`, so the reply comes from \`Respond to Webhook\` |
| \`OpenAI\` | OpenAI node 2.3, resource image, operation generate | The file goes out as a binary field named \`data\`, since GPT image models return base64 |
| \`Respond to Webhook\` | Sends the first binary file back | It takes the file from the field it finds, with no name to set |

### Good to know

Nothing guards the address, and the original copy’s model is gone.

- Model: the original copy left the model at the node’s default, \`dall-e-3\`, which OpenAI shut down on 12 May 2026. Mindket’s copy uses version 2.3 of the OpenAI node with \`gpt-image-2.6-flare\`. OpenAI’s deprecations page, read on 12 November 2026, names it as the newest replacement for its image models, and its model page calls it made for fast iteration
- Billing: OpenAI bills one image a request. Its model page lists image output at $30 per million tokens
- Open address: once published, anyone with the address can draw pictures on your key. A guessable path like \`image-api\` makes it easier, so use a long random one and add authentication in \`Webhook\`
- Refusals: a prompt OpenAI rejects ends the run with an error and no picture
- Your data: each prompt goes to OpenAI
- Credentials: the JSON holds none

## README

```markdown
# Web address that draws a picture from a prompt with OpenAI

An n8n workflow with a webhook. You open its address with a prompt after `?input=`, an OpenAI image model draws a
picture from that prompt, and the picture comes back in the same call. A browser shows it as an image, and another
app can save the file.

## What is inside

- `workflow.json`: the workflow as n8n exports it, seven nodes. Three do the work and four are sticky notes that label
  the steps and explain the address. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The `OpenAI` node left its model at the node's default, `dall-e-3`, which OpenAI shut down on 12 May 2026. It is now
  version 2.3 of the node, with the operation set to generate and `gpt-image-2.6-flare` typed in the model's ID field.
  Version 1.1 of the node offers only DALL·E 2, DALL·E 3 and GPT Image 1, all of them retired.
- The webhook's path was its author's own ID. It is now `image-api`, and the `webhookId` is gone.
- The `OpenAI` node was linked to a credential in its author's n8n. The link is gone, so select your own.
- Nothing else. The prompt, the reply and the sticky notes are the file's own.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- An OpenAI API key with access to image generation.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add an OpenAI credential with your key and select it in `OpenAI`.
3. Open `Webhook`. If the address will be public, change the path from `image-api` to a long random string.
4. Copy the webhook's test address. Add `?input=` and your prompt, with each space written as `%20`.
5. Save, press Execute workflow and open the whole address in a browser.
6. Press Publish and use the production address the same way.

## How a run goes

1. `Webhook` (Webhook 1.1) has no method set, so it listens for GET. It holds the answer until
   `Respond to Webhook` replies. The prompt arrives as `query.input`.
2. `OpenAI` (OpenAI node 2.3, resource image, operation generate) sends the prompt to the model. The picture comes
   back as a binary field named `data`.
3. `Respond to Webhook` replies with the binary file. It picks the file from the incoming item on its own.

## Change the look

- Model: `modelId` in `OpenAI`. It is an ID field, so any model name your account can use works there.
- Prompt source: `prompt` in `OpenAI`, which reads `{{ $json.query.input }}`. Change it to read another field.
- Address: the path in `Webhook`.
- Reply: `Respond to Webhook`. Add a node before it to resize, save or watermark the picture.
- Options: the `Options` list of `OpenAI` offers choices that depend on the model, such as size.

## Good to know

- OpenAI's deprecations page, read on 12 November 2026, shut down `dall-e-3` on 12 May 2026. Its newest named
  replacement for the image models is `gpt-image-2.6-flare`, and its model page calls that one made for fast
  iteration.
- Each request is one image. The model page lists image output at $30 per million tokens.
- An empty or missing `input` stops the node with the error "A non-empty prompt is required."
- A prompt that OpenAI rejects ends the run with an error and no picture.
- Once the workflow is published, anyone who has the address can draw pictures on your key. A path as plain as
  `image-api` is easy to guess, so use a long random one and add authentication in `Webhook`.
- Each prompt goes to OpenAI.
- The file holds no credential and no key.
```

## What is in it

3 files, 8 KB, downloaded as a zip.

```text
NOTICE.md  612 B
README.md  3 KB
workflow.json  4 KB
```

## Workflow check

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

- Steps: 3 steps, starting when its webhook is called
- AI: 1 step calls an AI model: OpenAI
- Sign-ins: No sign-in
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 3 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/f64db9de-b6cc-443b-bed0-58a34980be97)
- [Its page on Mindket](https://mindket.com/p/f64db9de-b6cc-443b-bed0-58a34980be97)
