---
title: "Make integration via webhooks · mobilerun"
description: "Start mobilerun tasks on real phones from Make with the HTTP module, and receive signed task events with a custom webhook. Exact module settings."
url: "https://mobilerun.ai/integrations/make/"
---

# Make integration (via webhooks)

Start a task on a real phone from any Make scenario, and get the result back into Make when it finishes.

There is no mobilerun app in Make yet. Make's built-in HTTP and Webhooks modules do the job.

## Before you start

- A Make account.
- A mobilerun API key from [cloud.mobilerun.ai](https://cloud.mobilerun.ai/api-keys). It starts with `dr_sk_`.
- A phone in your mobilerun account. Step 1 shows how to find its id.

## 1. Find your phone's id

Add an **HTTP > Make a request** module with these settings and run it once. Each entry in `items` is one of your phones; copy its `id`.

- Authentication type: No authentication
- URL: https://api.mobilerun.ai/v1/devices
- Method: GET
- Headers: Name `Authorization`, value `Bearer dr_sk_YOUR_API_KEY`
- Parse response: Yes

## 2. Start a task

Add another **HTTP > Make a request** module where your scenario should start the task.

- Authentication type: No authentication
- URL: https://api.mobilerun.ai/v1/tasks
- Method: POST
- Headers: Name `Authorization`, value `Bearer dr_sk_YOUR_API_KEY`
- Body content type: application/JSON
- Body input method: JSON string
- Body content: The JSON below
- Parse response: Yes

Body content:

```json
{
  "deviceId": "YOUR_DEVICE_ID",
  "task": "Open the Settings app and read the Android version"
}
```

Map `deviceId` and `task` from earlier modules if you like. The response holds the task `id` and its `status` (queued or created). To make retries safe, add an `Idempotency-Key` header with a value that is unique to each run, so a retry does not start the same task twice.

## 3. Catch the result with a webhook

Start a second scenario with **Webhooks > Custom webhook**. Click **Add**, give the webhook a name, save it, and copy its URL.

## 4. Send task events to that URL

In the mobilerun dashboard open **Webhooks**, click **Add Webhook**, paste the Make URL and pick `task.run.completed` and `task.run.failed`. Save, and store the signing secret: it is shown only once. Or register the webhook over the API:

terminal:

```bash
curl https://api.mobilerun.ai/v1/webhooks \
  -H "Authorization: Bearer $MOBILERUN_CLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "YOUR_MAKE_WEBHOOK_URL",
    "eventTypes": ["task.run.completed", "task.run.failed"],
    "description": "Make scenario"
  }'
```

## 5. Map the event

Run the scenario once and start one task, so Make learns the event's structure from a real delivery. Every event has `id`, `type` (for example `task.run.completed`), `occurredAt` and a `data` object. Add a filter on `type`, then map what you need from `data`.

Need the final output? Call `GET https://api.mobilerun.ai/v1/tasks/{taskId}/status` with the same header. It returns `status`, `succeeded`, `output` and `message`.

Checked 25 Sep 2026: both request bodies match the mobilerun API spec, and the device lookup ran against the live API. Module names follow Make's HTTP and Webhooks docs.

## What Make can reach

The same REST API every integration uses, called from Make's HTTP module, plus signed events into a custom webhook.

- **Start tasks**: One request per task. Pick the model with llmModel, cap the run with maxSteps, or ask for structured output with outputSchema. (POST /v1/tasks)
- **Check tasks**: Status, success, output and message for any task, plus screenshots and the step trajectory. (GET /v1/tasks/{taskId}/status, GET /v1/tasks/{taskId}/trajectory)
- **Find phones**: List your phones with their state, so a scenario can pick one that is ready. (GET /v1/devices)
- **Receive events**: Signed webhook events for tasks, workflows, the Assistant, inbound SMS and mailboxes, with up to three delivery attempts. (task.run.completed, task.run.failed, workflow.run.completed, sms.received)

## Notes

**Are the webhook calls signed?** Yes. Each delivery carries `X-Mobilerun-Signature`, an HMAC-SHA256 over the timestamp and the raw body. Make's custom webhook does not check it for you, so keep the webhook URL private, or verify the signature in your own receiver first ([docs](https://docs.mobilerun.ai/webhooks)).

**What if Make is slow or down?** mobilerun makes up to three attempts per delivery, with backoff, and drops events older than 24 hours. A retry reuses the same event `id`, so deduplicate on it.

**Is there a native Make app?** Not today. This page uses Make's built-in HTTP and Webhooks modules instead.

mobilerun webhook docs: https://docs.mobilerun.ai/webhooks
Get an API key: https://cloud.mobilerun.ai/api-keys

---

Source: https://mobilerun.ai/integrations/make/