Resources · Make integration

PiAPI/Luma (unofficial) Make integrationAutomate PiAPI/Luma (unofficial) with Make.

Turn a line of text or a still image into a video, straight from a Make scenario. The PiAPI/Luma (unofficial) Make integration brings 5 action modules and no trigger. This guide shows how to link your API key and build a first scenario that starts in another app.

Try the PiAPI/Luma (unofficial) integration on MakeSee the 5 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the PiAPI/Luma (unofficial) Make integration do?

It links your PiAPI account to Make, the no-code tool where you build a scenario: the automation itself, a chain of modules that each do one job. All 5 modules of this app are actions. They ask PiAPI/Luma for a video from text or images, lengthen an existing clip, or call the API directly.

Product clips for an online shop. A store keeps its product photos in a storage app. Each new photo can go through Generate a Video based on an Image, so a still picture becomes a video without a new shoot.

Scenes written by a content team. A marketer types one idea per form answer. Generate a Video based on Text turns that sentence into a video, and Extend a Video adds footage when the first result stops too early.

Before and after, in motion. Generate a Video from Start and End Image takes an opening picture and a closing picture and builds the movement between them.

What Make will not do here: the app has no trigger, so another app or a schedule has to start the scenario. Make's own page for this app is also flagged as AI-generated and may contain mistakes, so double-check anything important with PiAPI. When the listed modules fall short, Make an API Call reaches the rest of the API. Still choosing your tool? Read n8n vs Make, the Make review and Make pricing.

Connect

How do you connect PiAPI/Luma (unofficial) to Make?

  1. 01

    Generate your API key in PiAPI

    Log in to PiAPI and open the workspace dashboard. Go to the API key section, click the button that generates a new key, then copy the key shown on screen. Make needs it to act on your account.

  2. 02

    Add a module and create the connection

    In your scenario, add any PiAPI/Luma (unofficial) module and click Create a connection. A connection is your PiAPI account linked to Make once; every module of the app reuses it afterwards.

  3. 03

    Name it and paste the key

    The Connection name field is optional, but a clear name helps when you handle several accounts. Paste the API key you copied, or follow the on-screen instructions, and save. The module can now reach PiAPI.

First scenario

Build your first scenario with PiAPI/Luma (unofficial)

GoalWhen a new video idea lands in another app, Make asks PiAPI/Luma (unofficial) to generate a video from it.

  1. 01

    Create the scenario

    Open the Scenarios page, create a new scenario and click the +. This first slot starts everything, since PiAPI/Luma (unofficial) has no trigger of its own.

  2. 02

    Pick the app that holds your ideas

    Search for the app where ideas arrive, a form or a spreadsheet, and choose one of its triggers. Each new idea then travels as a bundle, one item passed from a module to the next.

  3. 03

    Add the video module

    Click the + on the right, search PiAPI/Luma (unofficial) and pick Generate a Video based on Text. Select your connection, then map the idea text from the first module into the fields Make shows.

  4. 04

    Test with Run once

    Add one test idea in the source app, then click Run once. Make executes the scenario a single time, and you can read the bundles each module received to check the request left.

  5. 05

    Schedule and switch it on

    Open the clock on the first module. A new scenario runs every 15 minutes by default, and the Free plan cannot go lower. Save, then switch the scenario on.

Modules

What each PiAPI/Luma (unofficial) module does

PiAPI/Luma (unofficial) gives you 5 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

PiAPI/Luma (unofficial)1

Extend a Video

ActionIn the docs only

Give a clip you already generated more footage, so a scene that ends too soon keeps going instead of being produced again from scratch. It works on a video that exists, not on a new idea.

When to use it
right after a text or image step, when the first result looks right but stops before the moment you need.
Watch out
the Make documentation describes no fields for this module, so open it and check which earlier video it expects before you map anything.
PiAPI/Luma (unofficial)2

Generate a Video based on Text

ActionIn the docs only

Write a sentence and get a video back: this module sends your description to PiAPI/Luma and asks for a clip that matches it. It is the natural pick when your ideas already live as words, in a form answer or a spreadsheet row.

When to use it
a shared sheet where each new row describes one scene to produce.
Watch out
every run counts as an operation, one module execution that Make counts on your plan, so test on a single row first.
PiAPI/Luma (unofficial)3

Generate a Video based on an Image

ActionIn the docs only

Start from a picture you already own and receive a video built on it. Product shots, illustrations or photos get motion without a camera or an editor, and the source image stays the anchor of the result.

When to use it
a new product photo lands in your storage app and the shop wants a moving version for its listing.
Watch out
the Free plan handles files up to 5 MB, so a heavy image passed through the scenario can block the run.
PiAPI/Luma (unofficial)4

Generate a Video from Start and End Image

ActionIn the docs only

Two images in, one transition out: you choose the opening frame and the closing frame, and PiAPI/Luma builds the movement between them. Next to the single-image module, you control where the clip ends, not only where it begins.

When to use it
a before-and-after for a renovation, a makeover or a product being assembled.
Watch out
both pictures have to come from earlier modules, so plan a step that fetches each of them first.
PiAPI/Luma (unofficial)5

Make an API Call

ActionIn the docs only

Reach any endpoint of the PiAPI/Luma API with the connection you already set up, with no second key. This module covers whatever the four video modules above leave out.

When to use it
the PiAPI documentation describes an action you need and none of the listed modules offers it.
Watch out
here you write the request yourself, so keep the PiAPI documentation open while you build it and test with Run once.
Need help

Need help automating PiAPI/Luma (unofficial) with Make?

A person reads every message.

FAQ

PiAPI/Luma (unofficial) and Make: common questions

01Is the PiAPI/Luma (unofficial) Make integration free?
Yes, on the Make side. PiAPI/Luma (unofficial) is a standard app, so it works from the Free plan. That plan has limits: 2 active scenarios, at least 15 minutes between two scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Each module execution counts as an operation on your plan. The PiAPI side is separate: you need an active PiAPI account, and its subscription follows the PiAPI pricing page, not Make's.
02What do you need to connect PiAPI/Luma (unofficial) to Make?
An active PiAPI account and an API key. You generate the key in the API key section of your PiAPI workspace dashboard, then copy it. In Make, add any module of the app, click Create a connection, name it if you like and paste the key. That single connection then serves all 5 modules, Make an API Call included, so you go through these steps once per account. No webhook is involved, because none of the modules is an instant trigger.
03Does PiAPI/Luma (unofficial) trigger Make scenarios in real time?
No, because the app has no trigger at all. Its 5 modules are actions, so the scenario has to start somewhere else. The usual route is a trigger from the app where requests appear, such as a form or a spreadsheet. If that trigger is instant, the app calls Make as soon as something happens; if it is scheduled, Make checks on the scenario's schedule, every 15 minutes by default. You can also start the scenario on a schedule alone and let the PiAPI module run each time.
04What if a PiAPI/Luma (unofficial) module is missing in Make?
Use Make an API Call. It sends a request to any endpoint of the PiAPI/Luma API with the connection you already created, so an action missing from the four video modules stays within reach. You write the request yourself, following the PiAPI documentation. Keep one warning in mind: Make's page for this app is marked as AI-generated and may contain mistakes, so when something looks off, check the vendor documentation or contact PiAPI directly. On the Free plan, a run also cannot last more than 5 minutes.
05Should you use Make or n8n for PiAPI/Luma (unofficial)?
It depends on the tool your team already works in. On Make, PiAPI/Luma (unofficial) offers 5 action modules including a universal API call, available from the Free plan, and this page walks through the connection and a first scenario. n8n is another automation tool, and many apps also have an n8n node, so check its catalog for this one before deciding. Compare the two on what matters for your case: the modules each offers for this app, how you connect your key and where your other scenarios already run.
Same platform

Other docs you might need on this stack.

Browse all integrations