How to Automatically Generate Images with Make

To automatically generate images with Make, build a scenario that starts with a trigger, sends mapped prompt text to an image-generation module such as OpenAI or Stability AI, and passes the returned image to a storage or publishing step. Test the scenario and its field mappings before scheduling it.

This guide walks through that workflow, including provider choice, prompt mapping, delivery, testing, troubleshooting, and a runnable API example. Make’s module fields and supported models can change, so use the current module interface as the authority for the inputs available in your account.

1. Understand the workflow

A Make scenario connects apps and services through modules. A trigger starts a run; action modules perform work and pass data to later modules. For image generation, the essential chain is:

1. Trigger: a new record, form submission, or scheduled run.
2. Prepare the prompt: map source fields into text that describes the desired image.
3. Generate: call an image-generation action in a provider module.
4. Deliver: pass the generated output into a connected storage, publishing, or review app.
5. Test and schedule: inspect real module output and mappings, then enable recurring runs when the result is correct.

Make’s getting-started guidance covers connections, triggers, module configuration, mapping, testing, and scheduling. Its OpenAI integration supports image creation, and its OpenAI modules documentation has an image-generation section. Make also lists image generation and image-processing actions for Stability AI. [Make Help Center]

2. Choose a trigger and prepare the prompt

Start with the event that should produce an image. A new database row works for a content pipeline; a form submission works when a person supplies a brief; a scheduled trigger works for recurring batches. The right choice depends on where the source information already lives and how quickly the image is needed.

1. Create a scenario and choose the trigger app and event.
2. Create or select the connection requested by the trigger module.
3. Run the trigger once so Make can load a representative bundle of sample data.
4. Identify the source fields that should shape the image, such as topic, audience, subject, or style.
5. Write a prompt template that combines those fields with any fixed instructions.

For example, if a record contains a topic and a visual style, the mapped prompt might be: “Create an editorial illustration about [topic], in [style]. Compose it for a square social post. Do not include visible text.” Replace bracketed phrases with mapped tokens from the bundle in Make’s editor; do not type placeholder syntax unless your source literally contains those characters.

Keep variable data bounded. If a free-text field can contain arbitrary instructions, decide whether it should be trusted as part of the image brief. For predictable results, separate the stable requirements from user-provided subject matter and review unusual input before publishing.

3. Add an image-generation module

OpenAI route

Add the OpenAI app’s image-generation action and create the connection it requests. Make documents image creation through its OpenAI app and has dedicated module guidance for image generation. Select the current action and inspect its fields in the scenario editor; model names, availability, and supported settings can change. OpenAI’s API reference is useful when you need to understand the provider’s underlying image-generation capabilities, but the Make module may expose only a subset of API controls. [Make OpenAI integration] [Make OpenAI modules] [OpenAI image generation reference]

Stability AI route

Add the Stability AI app and inspect its currently available image-generation action and inputs. Make’s integration page also lists image editing and upscaling actions, which may fit a workflow that transforms an existing image rather than generating from text alone. The Stability AI app documentation says its public module documentation is incomplete. Verify field names and support in Make itself, and avoid choosing modules that Make explicitly marks deprecated as the recommended path. [Make Stability AI integration] [Make Stability AI app documentation]

Question	How to decide
Do you need text-to-image only?	Choose the provider action that exposes the prompt and output controls your workflow requires.
Do you need image editing or upscaling?	Check the current Stability AI actions in Make and confirm the chosen module is supported, not deprecated.
Do you need a particular model or setting?	Inspect the current Make fields and provider reference. Do not assume every API setting is available in the connector.
Is provider documentation important to your team?	Make’s OpenAI modules have dedicated image-generation guidance; its Stability AI public module documentation notes a completeness caveat.

The dossier supports the existence of these integration paths, not a ranking of their image quality, speed, or price. Choose based on the current controls and actions your scenario needs.

4. Map the prompt and route the generated image

1. In the generation module’s prompt field, insert the prompt template and map the source fields from the trigger bundle.
2. Set any available generation controls using the current module fields. The exact options vary by provider, model, and module version.
3. Run the generation module once and inspect its output bundle. Determine whether the result is represented as a file, binary data, or a URL before configuring the next module.
4. Add a connected destination, such as a storage or publishing app, and map the generated output into the destination field it expects.
5. Map useful context alongside the image when supported: source record identifier, prompt, destination, or status. This makes later review and recovery easier.

Do not assume the image output field has a particular name or lifetime. Use the output from the actual module run: downstream apps may expect a file object, while others may accept a URL. If the destination requires a file and the provider returns a URL, add a step that retrieves the file using a suitable connected app or supported module.

5. Test before scheduling

Test in stages so a mapping error is easy to locate:

1. Run the trigger and confirm the sample record has the fields you expect.
2. Run the prompt preparation and inspect the final text, including mapped values and punctuation.
3. Run the provider module and inspect its output and any reported error.
4. Run the destination step and confirm it received the intended file or URL.
5. Run the entire scenario with a representative input, then test an edge case such as an empty optional field or unusually long prompt.
6. Only after the end-to-end result is right, configure the scenario schedule or leave it ready for its event trigger.

Make’s setup guidance includes module and scenario testing and scheduling. A successful module test alone does not prove the whole workflow works: the destination may reject the image representation, or a mapped field may be empty in a real trigger bundle. [Make scenario setup, testing, and scheduling]

6. Runnable API examples for a direct generation step

A Make provider module is usually the simplest route when it exposes the controls you need. If you are implementing the provider request outside Make, use the provider’s current official API reference for the endpoint, authentication, request fields, and response format. The following Python example shows the general request structure only; replace the endpoint and payload with the provider’s current documented values. It is not a ready-to-run OpenAI or Stability AI request.

Python request structure

import os
import requests

# Replace with the endpoint and payload from your provider's current API docs.
endpoint = os.environ["IMAGE_API_ENDPOINT"]
api_key = os.environ["IMAGE_API_KEY"]
prompt = "Editorial illustration of a greenhouse on Mars at sunrise"

response = requests.post(
    endpoint,
    headers={"Authorization": f"Bearer {api_key}"},
    json={"prompt": prompt},
    timeout=90,
)
response.raise_for_status()

# Provider response formats differ. Inspect the documented response and
# adapt this section to retrieve or decode its image output.
print(response.headers.get("Content-Type"))
print(response.text[:500])

To run it, install the HTTP client with python -m pip install requests, set IMAGE_API_ENDPOINT and IMAGE_API_KEY from the provider’s current documentation, and execute the script. Keep credentials in environment variables or a secret manager, never in a shared scenario field or source repository. The example intentionally stops at inspecting the response because the provider’s response shape and image delivery method must be taken from its current API docs. [OpenAI API reference]

cURL request structure

curl -X POST "$IMAGE_API_ENDPOINT" \
  -H "Authorization: Bearer $IMAGE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Editorial illustration of a greenhouse on Mars at sunrise"}'

As above, this is a request template, not a provider-specific runnable call: confirm the current endpoint, authentication scheme, and required fields before using it. For Node.js, the equivalent pattern is fetch(endpoint, { method: 'POST', headers, body: JSON.stringify(payload) }), but the payload and response parsing must match the provider documentation. In Make, a direct HTTP-module route requires current provider-specific details; the reviewed official material does not establish a complete current tutorial for that route.

7. Common errors and fixes

Symptom	Likely cause	What to check
Connection or authorization error	The provider connection is missing, expired, or has insufficient access.	Reconnect through the module’s connection flow and confirm the credential is valid for the selected provider action.
Prompt is blank or has literal mapping tokens	The trigger has no sample bundle, a source field is empty, or text was typed instead of mapped.	Run the trigger, inspect the bundle, and insert the field using Make’s mapping picker.
Generation action or fields differ from a tutorial	The provider or Make module has changed, or the selected action/model differs.	Use the current module editor and official provider reference; do not copy stale field names.
Provider returns an error for the input	A required field is missing or the prompt/input is unsupported by the current action.	Inspect the module’s error details and current field requirements; test with a short, simple prompt.
Destination cannot accept the generated result	The next app expects a file but received a URL, or the reverse.	Inspect the provider output bundle and match its representation to the destination’s expected input.
Scenario works once but fails on scheduled/event runs	The test bundle differs from live records, or optional fields are absent in some runs.	Test representative records, add handling for empty fields, and inspect the actual failed bundle and module.
Stability AI module instructions do not explain a field	Make’s public module documentation is incomplete.	Inspect the current module in Make and verify the corresponding provider behavior in current documentation.

8. Reliability, performance, and cost

Reliability: keep each stage observable by testing its output and retaining an identifier or status alongside the result where your connected apps support it. For recurring workflows, account for missing source values and destination failures rather than assuming every trigger bundle is complete. Re-run only the failed stage when the scenario design and provider behavior make that safe; duplicate generation may create another image or incur another provider charge.

Performance: each provider call and downstream upload adds work to the scenario. Avoid generating an image before required source data is present, and keep prompts focused. For batches, validate one representative item and confirm the provider and Make module’s current limits before scaling. No speed or throughput figures are established by the sources for this guide.

Cost: image-generation charges depend on the provider, model, and current terms; Make usage and plan constraints also depend on the account. The official sources reviewed here do not establish a current cost per image, free-credit amount, operation limit, or success rate, so check the live provider and Make plan details before budgeting. Add review or approval steps when generated assets should not publish automatically.

9. Or skip the browser setup

If your workflow also needs a screenshot of a generated image on a webpage, or another page in the same scenario, ScreenshotNeo can return a screenshot or PDF from one API request. See the ScreenshotNeo website and API documentation for the request options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Cookie banners, popups, and chat widgets are removed before the shot. Bot checks, blank pages, and failed loads are never billed. An MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.

10. Frequently asked questions

Can a Make scenario generate an image from a new spreadsheet or form entry?

Yes, if the source app has a suitable trigger and the connected provider module accepts a mapped prompt. Test with a real sample bundle from that source.

Can I make an image from an existing image?

That depends on the provider action and current module fields. Make lists image editing actions for Stability AI; inspect the live module to verify its inputs and availability.

Can Make publish every generated image automatically?

You can route output to a connected publishing destination, but whether auto-publishing is appropriate depends on your review requirements. Add an approval step when images need human review.

Should I use Make’s provider module or call an API directly?

Use the module if it exposes the controls and output you need. A direct API call can offer a different set of controls, but requires you to follow the provider’s current API documentation and handle its response format.