Resources · Make integration

PiAPI/Flux.1 Make integrationAutomate PiAPI/Flux.1 with Make.

What if every image request in your tools came back as a finished visual on its own? The PiAPI/Flux.1 Make integration gives you 10 action modules for generating and fixing images. This guide shows how to link your API key and build a first scenario step by step.

Try the PiAPI/Flux.1 integration on MakeSee the 10 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the PiAPI/Flux.1 Make integration do for you?

The PiAPI/Flux.1 Make integration connects your PiAPI account to Make, a no-code tool where you build a scenario: an automation made of modules, each one a small brick that does one job. Here the bricks create, change and repair images, and the data that starts them comes from your other apps.

Product shots with a clean backdrop. A shop team drops a photo into its usual tool, Make passes it to Remove the Background from an Image, and the cut-out goes wherever the catalog lives. If the frame is too tight, Extend an Image adds room around the subject first.

Visuals written from a sentence. A content writer types a short description in a form or a sheet. Generate an Image from Text turns it into a picture, and Generate a Variation of an Image offers alternatives from the result, so the editor picks instead of starting over.

Old pictures brought back. A local newspaper digging into its photo archive sends worn scans to Restore an Image, and Make files each repaired copy next to its original.

What Make does not give you: PiAPI/Flux.1 has no trigger, so something else has to start the scenario, and the Make documentation for this app is marked as AI-generated and may contain mistakes, so check anything important with PiAPI. For an overview of the tool, read the Make review. PiAPI may also exist as an n8n node; the n8n vs Make comparison helps you choose, and Make pricing explains how operations are counted.

Connect

How do you connect PiAPI/Flux.1 to Make?

  1. 01

    Generate your API key in PiAPI

    Log in to PiAPI, click your profile or workspace in the top navigation, open the API key section and press Generate. Copy the key shown on screen. You need an active PiAPI account for this step.

  2. 02

    Add a module and create the connection

    In your Make scenario, add any PiAPI/Flux.1 module and click Create a connection. A connection is your PiAPI account linked to Make once, then reused by every PiAPI/Flux.1 module you add later.

  3. 03

    Name it and paste the key

    The Connection name field is optional, but a clear name helps when you run several accounts. Paste the API key you copied from PiAPI, save, and the module is ready to fill.

First scenario

Your first scenario with PiAPI/Flux.1

GoalWhen a new image request arrives in another app, Make generates the picture with PiAPI/Flux.1 and removes its background.

  1. 01

    Create the scenario

    Open the Scenarios page in Make, create a new scenario and click the +. Pick the trigger of the app where your requests land, such as a form or a sheet, and connect it.

  2. 02

    Add Generate an Image from Text

    Click the + on the right of that first module, search PiAPI/Flux.1 and choose Generate an Image from Text. Select your connection, then map the request text from the previous module into the module fields.

  3. 03

    Chain Remove the Background

    Add Remove the Background from an Image after it and map the image produced by the previous module. Each item passing between modules is a bundle, here one request and then one image.

  4. 04

    Test with Run once

    Create a test request in your source app, then click Run once. Make runs the scenario one time and shows the bundles each module received, so you can check the picture before going further.

  5. 05

    Schedule and switch on

    Set the schedule on the first module with the clock, every 15 minutes by default, and switch the scenario on. Every module run on one bundle is one operation counted on your Make plan.

Modules

What each PiAPI/Flux.1 module does in Make

PiAPI/Flux.1 gives you 10 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

PiAPI/Flux.11

Extend an Image

ActionIn the docs only

Extend an Image gives a picture more room, a useful fix when a subject sits too close to the edge of the frame for the format you publish in.

When to use it
before resizing a product photo for a banner, place it ahead of the module that sends the file to your site.
Watch out
the doc for this app is AI-generated, so read the module fields in Make rather than guessing what each option does.
PiAPI/Flux.12

Generate a Variation of an Image

ActionIn the docs only

Alternatives to a picture you already like come out of Generate a Variation of an Image, so a reviewer gets several takes on one idea instead of a blank page.

When to use it
right after a generation step, when a marketer wants options to choose from before a campaign goes out.
Watch out
each extra version is another run of the module, and every run counts as one operation on your plan.
PiAPI/Flux.13

Generate an Image from Text

ActionIn the docs only

A written description becomes a picture with Generate an Image from Text, the simplest entry point of this app and the module most first scenarios start from.

When to use it
when requests arrive as text, from a form, a support ticket or a row in a sheet, and nobody has a source image.
Watch out
map the text from the previous module instead of typing it, otherwise every run produces the same picture.
PiAPI/Flux.14

Generate an Image from Text with LoRA

ActionIn the docs only

Pick this text-to-image version when you work with a LoRA, as the module name says, and want the results to follow it instead of the plain model output.

When to use it
a brand team that already set up a LoRA on the PiAPI side and needs every visual to stay in the same look.
Watch out
the LoRA settings show up in the fields Make lists once the connection exists, so read them there and in the PiAPI documentation.
PiAPI/Flux.15

Generate an Image from an Image

ActionIn the docs only

Starting from an existing picture rather than words, Generate an Image from an Image produces a new visual based on that source, handy when a sketch or a photo already shows the idea.

When to use it
a designer drops a rough draft in a shared folder and wants a finished version back in the same place.
Watch out
the source image has to come from an earlier module, so map it rather than leaving the field empty.
PiAPI/Flux.16

Generate an Image from an Image with LoRA

ActionIn the docs only

This module combines the two previous ideas: it starts from a source picture and, as its name indicates, applies a LoRA to the result, for work that must match a set style.

When to use it
turning supplier photos into visuals that look like the rest of your catalog.
Watch out
test it with Run once on one file before switching the scenario on, since each image costs an operation.
PiAPI/Flux.17

Generate an Image with ControlNet and LoRA

ActionIn the docs only

The most specialized generator of the list, Generate an Image with ControlNet and LoRA, relies on both techniques named in its title, which suits teams who already know them from Flux.1 work.

When to use it
when the plain text or image generators give results that drift too far from what the brief asked.
Watch out
the Make doc is AI-generated for this app, so confirm how each option behaves with PiAPI before relying on it.
PiAPI/Flux.18

Make an API Call

ActionIn the docs only

Make an API Call lets you reach any endpoint of the PiAPI API from your scenario, reusing the same connection, so you are not stuck when a listed module does not cover your case.

When to use it
a feature PiAPI offers that none of the nine other modules exposes.
Watch out
you write the request yourself here, so keep the PiAPI API documentation open while you set it up.
PiAPI/Flux.19

Remove the Background from an Image

ActionIn the docs only

Remove the Background from an Image isolates the subject of a photo so you can drop it on any backdrop, the classic step for product pages and ads.

When to use it
as soon as a new product photo is added to your storage, before it reaches your online shop.
Watch out
on the Make Free plan, files are limited to 5 MB, so large originals may need resizing earlier in the scenario.
PiAPI/Flux.110

Restore an Image

ActionIn the docs only

Worn, blurry or damaged pictures get a second life with Restore an Image, which returns a repaired version you can store or publish next to the original.

When to use it
an archive, a museum or a family photo service that receives scans and wants them cleaned without manual retouching.
Watch out
keep the original file in the scenario output as well, in case the repaired version is not the one you want.
Need help

Need help automating PiAPI/Flux.1 with Make?

A person reads every message.

FAQ

PiAPI/Flux.1 and Make: common questions

01Is the PiAPI/Flux.1 Make integration free?
Yes, on the Make side. PiAPI/Flux.1 is a standard app, available from the Free plan, which allows 2 active scenarios, a minimum of 15 minutes between scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute and remove the cap on active scenarios. PiAPI itself needs an active account with an API key, and its subscription is set on the PiAPI pricing page, not in Make.
02What do you need to connect PiAPI/Flux.1 to Make?
An active PiAPI account and an API key. In PiAPI, open your profile or workspace, go to the API key section, click Generate and copy the key. In Make, add any PiAPI/Flux.1 module, click Create a connection, give it a name if you like and paste the key. That connection is then reused by every PiAPI/Flux.1 module of your scenarios, so you only set it up once per account, and every module you add later picks it from a list.
03Does PiAPI/Flux.1 trigger scenarios in real time in Make?
No, because PiAPI/Flux.1 has no trigger module in Make: all 10 modules are actions. The scenario has to start elsewhere. You can open it with the trigger of another app, for example a new form entry or a new file, and if that trigger is instant, the other app calls Make as soon as something happens. Or you can run it on a schedule, set with the clock on the first module, every 15 minutes by default and down to 1 minute on paid plans.
04What if a PiAPI/Flux.1 module is missing in Make?
Use Make an API Call. It is part of this app and lets your scenario reach any endpoint of the PiAPI API with the same connection, so a feature without a dedicated module is still within reach. You write the request yourself, so keep the PiAPI documentation at hand. Also note that the Make documentation for this app is marked as AI-generated and may contain mistakes: for anything important, check with PiAPI directly before building on it.
05Should you use Make or n8n for PiAPI/Flux.1?
It depends on your criteria. On Make, PiAPI/Flux.1 comes with 10 ready modules, from text-to-image generation to background removal and restoration, plus Make an API Call for the rest, and it is available on every plan including Free. The same app often has an n8n node too, so check which modules it offers before deciding. Compare what each tool gives you for the images you actually need to produce, and pick the one your team is more at ease building in.
Same platform

Other docs you might need on this stack.

Browse all integrations