# Make

Nimbata's Make integration sends your calls and form submissions to [Make](https://www.make.com/), where a scenario can pass them on to thousands of other apps. In Make, Nimbata's **Watch Calls** and **Watch Form Submissions** triggers start your scenario each time Nimbata sends them an event, and a workflow in Nimbata decides which calls and forms are sent. The integration works one way: Make receives events from Nimbata, and cannot change anything in Nimbata.

**Before you start**

- Permissions: Make, under Integrations, in your Nimbata role
- A Make account, with access to the scenarios you want to start.
- The **Make** tile on your Nimbata Integrations page. Make comes with the same plans as Zapier: on a plan that does not include it, **Go to integration** offers an upgrade instead.
- The Nimbata project whose calls and forms you want to send: each project has its own API Key and API Secret.

## Connect Make

There is no Connect button in Nimbata: you connect from inside Make, with the API Key and API Secret that Nimbata shows for your project.

1. **Open the Make integration**

   In Nimbata, go to **Integrations**, check that the right project is open, and click **Go to integration** on the **Make** tile (1).

   [The Make tile on the Integrations page, with Go to integration marked 1]

   *Open the Make tile (1).*

2. **Copy the API Key and API Secret**

   The page says **Not connected.** until a Make scenario subscribes. Copy the **API Key** with its copy button (1), then the **API Secret** with its own (2). The secret stays hidden: the padlock beside it shows it, and copying works without showing it.

   [The Make integration page before it is connected: the Not connected notice with the three steps to connect from Make, then the API Key field with its copy button marked 1, and the hidden API Secret with its copy button marked 2 and the padlock]

   *Copy the API Key (1) and the API Secret (2). You paste both into Make.*

3. **Add Nimbata's trigger in Make**

   In Make, create a scenario, or open the one you want to start. Add Nimbata as its first module and choose **Watch Calls**. To start the scenario on form submissions instead, choose **Watch Form Submissions**.

4. **Create the Nimbata connection**

   Make asks for a webhook for the module, and a connection for the webhook. Add a connection and paste the **API Key** and **API Secret** you copied. Make checks them with Nimbata and shows the name of your Nimbata project on the connection.

5. **Save the webhook and turn the scenario on**

   Save the webhook. It subscribes to Nimbata straight away, even while the scenario is off, and the Make page in Nimbata now shows it. Then turn the scenario on: while it is off, Make only queues what arrives.

Each connection watches one project. To send another project's calls to Make, open the Make integration with that project selected, and create a second connection in Make with that project's API Key and API Secret.

## Send calls with a workflow

Saving the webhook subscribes your scenario, but it does not send anything by itself. Nimbata sends a call to Make when a workflow with a **Make** action runs for it. A workflow that runs when a call ends, with no filter, sends every call, and its filters (for example call outcome or tracking number) narrow it down. Make is available in workflows for inbound calls, outbound calls and form submissions, not for text messages.

> **Warning:** Nothing reaches Make until a workflow has a Make action. Connecting in Make only tells Nimbata where to send; the workflow decides what is sent.

1. **Create a workflow**

   Go to **Workflows**, click **Create** and choose **From Scratch**. Keep the **Inbound Call** trigger with **Call Ends**, and add any filters you need. For form submissions, pick the **Form Submission** trigger instead, and for calls you place from Nimbata, **Outbound Call**.

2. **Add the Make action**

   Click the **+** plus sign, select **Perform action**, and choose **Make** under **Integrations** (1). Make has no configuration to pick: it is added to the workflow straight away, and sends to every scenario that watches this kind of event.

   [The Select task panel of the workflow builder, with Make in the Integrations list marked 1]

   *Choose Make under Integrations (1).*

3. **Enable the workflow**

   Click **Enable** (1).

   [A workflow firing on Inbound Call, Call Ends, with a Make action, and the Enable button marked 1]

   *The workflow sends every inbound call to Make when it ends. Click Enable (1).*

> **Tip:** To send the call's **Transcription** and **Summary** to Make, add **Transcribe Call** (and **Summarize Call** for the summary) before the Make action. Without a Transcribe Call step, the builder marks the Make action with a yellow warning that it may require the Call Transcription action. See [Turn on transcriptions and summaries](https://help.nimbata.com/workflows/transcriptions#turn-on-transcriptions-and-summaries).

Detailed guide: [Create a workflow](https://help.nimbata.com/workflows/workflows#create-a-workflow)

## What Make receives

Make reads the list of fields from Nimbata when you set up the module, so you can map them in the next modules of your scenario. Until the first real event arrives, Make shows sample values.

- **Watch Calls** receives the call's details: among them **Unique Call ID**, **Start Time**, **Caller ID (formatted)**, **Caller Name**, **Tracking Number**, **Tracking Number Friendly Name**, **Destination Number**, **Source Type**, **Call Outcome**, **Call Duration**, **Talk Duration**, **UTM Source**, **UTM Medium**, **UTM Campaign**, **Google Ads Click ID**, **Tags**, **Value**, **Rating**, **Notes**, **Rec Link**, **Transcription**, **Summary** and **Workflow Name**. Your project's own fields come in four groups: **URL Parameters**, **Custom Call Properties**, **Tracking Cookies** and **Local Storage Values**, each field under the name you gave it.
- **Watch Form Submissions** receives the submission: among them **Submission ID**, **Submitted on**, **Form name**, **Form data (all fields)**, **UTM Source**, **UTM Medium**, **UTM Campaign**, **Landing Page**, **Tags** and **Value**.

**Start Time** is a date, which Make can format and compare. The fields marked "(local timezone)" and the separate date and time fields are plain text, so Make does not shift them into another time zone. **Tags** is one text: the tag names, separated by commas.

## Test the integration

Nimbata has no Send Test button for Make: you test with a real call.

1. **Get the scenario ready**

   In Make, turn the scenario on, or click **Run once** to wait for one event.

2. **Place a test call**

   Call one of your tracking numbers. For a **Watch Form Submissions** scenario, submit a tracked form on your website instead.

3. **Check the bundle in Make**

   Once the call ends and the workflow runs, the call arrives in Make as a bundle with its fields. Check the values, then map them in the next modules of your scenario.

## Check it worked

The Make page now says **Connected.**, lists the webhook address of each scenario under **Calls** or **Forms**, and shows the workflow that sends to Make.

[The connected Make integration, used in 1 workflow, with the Connected notice listing one Make webhook address under Calls]

*The page shows Used in 1 workflow, and the scenarios Nimbata sends to.*

## Stop sending to Make

- **One scenario:** delete its webhook under **Webhooks** in Make. Make tells Nimbata, and the address leaves the Make page. If it is still listed, Nimbata removes it the first time Make answers that the webhook no longer exists.
- **Some calls:** turn off the workflow that sends them, or change its filters.
- **Everything, with new credentials:** **Remove setup**, in the three-dot menu at the top of the Make page, deletes the project's Make webhooks with its API Key and API Secret. The next time you open the page, Nimbata shows a new pair, and your Make connections stop working until you paste it in. Use it if the secret was shared by mistake. It is greyed out while workflows use Make.

## Limitations

- A project can have up to 25 Make webhooks for calls, and 25 for forms. Each one receives every event its workflows send.
- Nimbata sends each event once, and does not retry. If Make is unavailable or returns an error, the event is not delivered.
- Text messages cannot be sent to Make.
- Make cannot act on Nimbata: Nimbata's Make app has the two triggers and no actions.

## Troubleshooting

### You don't see Make on the Integrations page

Make comes with the same plans as Zapier. If your plan doesn't include it, **Go to integration** on the tile offers an upgrade instead of opening the page. If you see the tile but cannot open the page, ask an admin for **Make**, under **Integrations**, in your role.

### Make says your API key or secret is not valid

Make shows "Your Nimbata API key or secret is not valid." when the connection's credentials do not match a Nimbata project. Copy both again from **Integrations › Make**, with the right project open, and paste them into the connection. If someone used **Remove setup**, the old pair no longer works: paste the new one.

### Make could not subscribe the webhook

| Message                                                                                     | What to do                                                                                                       |
| ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| Nimbata accepts only https webhook addresses on a Make domain (make.com or integromat.com). | Create the webhook from Nimbata's **Watch Calls** or **Watch Form Submissions** module, not as a custom webhook. |
| This Nimbata project already has 25 Make webhooks for this trigger, the most it allows.     | Delete the Nimbata webhooks you no longer use under **Webhooks** in Make, then save the webhook again.           |

### Make shows Missing configuration in the workflow builder

Make is listed under **Missing configuration** until a scenario has subscribed for the workflow's kind of event: a **Watch Calls** webhook for a call workflow, a **Watch Form Submissions** webhook for a form workflow. Save the right module's webhook in Make, then open the workflow again.

[The Select task panel of the workflow builder, with Make in the Integrations list marked Missing configuration]

*Make reads Missing configuration until a scenario watches this kind of event.*

### Calls are not reaching Make

- Check that a workflow with a **Make** action is enabled, and that its filters let the call through. A **Call Ends** workflow sends the call after it ends, not during it.
- Check that the Make page lists your scenario's webhook under **Calls**, or under **Forms** for a form workflow.
- Check that the scenario is on in Make. While it is off, Make only queues what arrives.
- Open **Workspace › Integration Events** to see each delivery attempt to Make, with the request Nimbata sent and Make's response.

### Can Make change anything in Nimbata?

No. Nimbata's Make app has two triggers, Watch Calls and Watch Form Submissions, and no actions. Make receives your calls and forms, and cannot read or change anything else in Nimbata.

### Can several scenarios receive the same calls?

Yes. Every scenario whose webhook watches calls receives each call a workflow sends to Make, up to 25 webhooks for calls and 25 for forms per project.