Connect LaunchList to Make

Get the LaunchList app on Make

The LaunchList app on Make works in both directions. Ten triggers start a scenario when something happens on your waitlist, such as a new signup, a credited referral or a redeemed invite. Eleven actions, a search and Make an API Call let any app Make connects add, change, tag, move or invite your contacts.

What you need#

• A workspace on the Launch plan or the Grow plan. On the Free plan and the Collect plan, use a webhook instead.
• The owner or admin role in the workspace, to create the key.
• A Make account.

Create a key for Make#

The app connects with a key made for Make. It is separate from the keys your own code uses, so you can cut Make off without touching anything else, and it gets exactly the access the app needs.

1. Open Embed & API → Overview. Under Connectors, find Make and press Connect.
2. LaunchList makes the key straight away and shows it once. Press Copy key and open Make, which copies the key and opens Make in a new tab. LaunchList keeps only a hash of the key.

The key is named Make. It covers every project in the workspace, including ones you create later (each module picks one), and it does not expire. It can read your projects and segments, read and write contacts, issue and revoke invites, and start or stop the triggers your scenarios use. It cannot send a broadcast to your list.

The key lives on the Make row only, never in the API keys list, which holds the keys for your own code. The row's settings button makes a new key or disconnects Make.

Connect LaunchList in Make#

1. Open the LaunchList app on Make and install it in your Make organization. You do this once; Copy key and open Make opens the same page.
2. In Make, open a scenario, add a module and search for LaunchList.
3. Press Create a connection, paste the key into API key and save.
4. Make names the connection after your workspace. Back in LaunchList, the Make row reads Connected.

If Make refuses the key, the message says why:

Triggers#

Every trigger is instant: LaunchList sends the event to Make within seconds. When you add a LaunchList trigger, Make asks you to create a webhook for it: name it, choose your connection and the project, and save. Every trigger about a contact or a form response also has Include test signups, off by default.

An event that does not pass the trigger's options does not start the scenario. The project, the options and Include test signups are settings of the webhook: to change them, create a new webhook in the trigger.

A contact trigger gives the scenario fields ready to map, including Email, Name, Stage key, Referral link, Referral code, Referrals and Position, plus Form answers with the answers from your form. Every bundle also has an Event ID.

Make lists these fields as soon as you add the trigger, so you can map them before the first event arrives. To see real values, press Run once in Make and wait for the next event.

Actions#

Most actions take a Contact ID. Map it from a LaunchList trigger, or find the person first with Find Contact.

Add Contact needs an email, a phone number or an identifier. Leave Form empty to use the project's first active waitlist form, or pick a form to fill in its questions under Form answers. Referral code credits the person who referred the signup, when the code is valid.

Mark Invite as Redeemed takes the person's word from your app: LaunchList does not check who they are, so only send people your own app has already verified. More on invites in Early access.

Find Contact, and Find or Create Contact#

Find Contact looks a person up by Email, Identifier or External ID, and returns each contact that matches, up to the Limit you set, with their stage, status, position, referral code, referral link and referral count. When nobody matches, it returns nothing, so the modules after it do not run for that person.

To add the person instead, use Find or Create Contact. It finds them the same way, and when nobody matches it adds them with the details you map, as Add Contact does. Either way the scenario carries on with one contact, and New contact says whether they were added just now.

Make an API Call#

Make an API Call sends a request of your own to the LaunchList API with the connection's key, for anything the other modules do not cover, such as reading your segments. Enter a path such as /v1/workspace. The connection adds the key, and the key's access still applies, so it cannot send a broadcast.

Test signups#

Signups made in your project's test mode never start a scenario unless the trigger's webhook has Include test signups turned on. Turn it on while you build, so your own test runs the scenario. Each bundle also carries Test signup, so a filter after the trigger can leave test signups out once the scenario is live.

Contacts past your plan's size#

When your list passes your plan's size, the newest contacts are kept in LaunchList but hidden, and nothing about them reaches Make. That covers every trigger, including referrals and invites that name them. Those events are not sent later either: once you move up a size, only new events about those contacts come through. Plans, billing and contact limits explains the hold.

Avoiding duplicates and loops#

• New Signup or New Form Submission. Both fire when someone joins. Use New Signup for "a new person is on my list" and New Form Submission for "someone answered a form". Using both for the same job sends each signup twice.
• Add Contact also fires triggers. It goes through a form, so it fires New Form Submission each time it runs, and New Signup when the person is new. A scenario that starts from New Form Submission and runs Add Contact on the same project starts itself again. Point it at another project, or add a filter.
• Spotting a repeat. Every bundle has an Event ID that stays the same if LaunchList sends it again, so a filter or a lookup on it can skip a repeat.
• Fields are a snapshot. Each bundle describes the contact when it was sent, seconds after the event. A delivery that is retried hours later can show newer values, such as a later stage.

When a scenario stops getting events#

• You disconnect Make, or press Make new key. The old key stops working, and LaunchList stops sending events to the triggers that used it and removes them. Make has no way for LaunchList to pause a scenario, so your scenarios simply stop getting events, and a LaunchList step with the old key fails with "LaunchList did not accept this API key". To start again, create a new connection in Make with the new key, and create each LaunchList trigger's webhook again.
• You delete the webhook in Make. Make tells LaunchList, which removes that trigger.
• The webhook is in no scenario for 5 days. Make switches the webhook off and refuses what is sent to it, so LaunchList removes the trigger. Adding that webhook to a scenario later does not bring it back: create a new webhook in the LaunchList trigger.
• The scenario is switched off. Make keeps the events in the webhook's queue and runs them when you switch the scenario on again. Deleting the webhook is what stops them.
• Make refuses deliveries. When a webhook's queue is full, or too many events arrive at once, Make refuses them. LaunchList tries each one again over about two days, and after 50 failed attempts in a row it stops sending to that trigger and tells you. Once the scenario can take events again, open the trigger on Embed & API → Developers → Webhooks and choose Enable.
• You delete a scenario's trigger in LaunchList. Each trigger shows on Embed & API → Developers → Webhooks as an endpoint marked Managed by Make. You cannot edit it there, because its settings belong to the scenario. Delete trigger asks first, then stops sending events to it. Its delivery history is kept.
• Your workspace moves to a plan without the app. LaunchList stops sending events to your scenarios but keeps their triggers and history, and LaunchList steps fail with "The official Make app is on the Launch plan and the Grow plan." Move back and the triggers start again. Events from the time in between are not sent later.
• Too many requests. If a scenario sends more requests than your plan's API rate allows, the step fails with "LaunchList is limiting requests right now."

On any plan: a custom webhook#

The API and webhooks work on every plan, so you can reach Make without the official app. It takes a little more setup.

To start a scenario from LaunchList:

1. In Make, start a scenario with the Webhooks app and its Custom webhook trigger. Add a webhook and copy its address.
2. In LaunchList, open Embed & API → Developers → Webhooks, press New endpoint, paste the address and choose the events, such as signup.created.
3. While Make waits for data, press Send test on the endpoint, so Make learns the event's fields. Then map them into the next module and turn the scenario on.

Each event arrives as JSON with the contact under data.object, which Make shows as nested fields. The webhook guide lists every event and shows how to check the signature.

To add people from Make: use Make's HTTP module to call the create contact endpoint, with an API key from New API key in the Authorization header. The signup goes through the same duplicate check and referral credit as your own form.