how to connect cloud phones to Make (formerly Integromat)
how to connect cloud phones to Make (formerly Integromat)
a cloud phone Make integration sits in the sweet spot between Zapier’s simplicity and n8n’s full-control flexibility. Make (formerly Integromat) gives you visual scenario building, native modules for 1,500+ apps, and a generous free tier that handles real cloud phone ops without a paid plan for most teams.
this guide shows you how to wire cloudf.one into Make, the JSON structure of a working scenario, and three real-world automations you can clone and adapt.
what cloudf.one and Make bring to the table
cloudf.one’s API surface for Make:
- REST endpoints for device control: lock, unlock, reboot, install APK, screenshot, screen recording
- webhook events for state changes
- ADB-over-network for shell-level access
Make’s matching capabilities:
- Webhooks module (catches incoming HTTP as scenario triggers)
- HTTP module (makes outbound API calls to cloudf.one)
- 1,500+ native app modules (Slack, Notion, Airtable, Stripe, etc.)
- Router, Filter, Aggregator modules for branching logic
- Iterator and Array Aggregator for batch processing
Make’s strength is the visual scenario editor and the data store for cross-scenario state.
for the broader case why integration matters for cloud phone ops, see cloud phone CI/CD integration.
step 1: configure cloudf.one API credentials in Make
generate a cloudf.one API token from the dashboard. in Make, open Connections, create a new HTTP connection, and store the token as a header value:
- type: API Key Auth
- header name: Authorization
- header value:
Bearer cf_live_xxxxxxxxxxxxxxxxxxxx
now any HTTP module in any scenario can reference this connection without exposing the token in the scenario JSON.
step 2: set up a webhook trigger
create a new scenario. add a Webhooks module as the first step, choose “Custom webhook,” and Make generates a URL like:
https://hook.eu2.make.com/abc123xyz789
paste this URL into cloudf.one’s webhook configuration in the dashboard. select the events you want to receive (device.locked, device.unlocked, install.completed, etc.).
step 3: send a test event
trigger a test event by manually locking a device. Make captures the payload and stores it as the webhook’s data structure:
{
"event": "device.locked",
"timestamp": "2026-05-07T08:30:00+08:00",
"device": {
"id": "dev_8a1b2c3d",
"model": "Samsung Galaxy A24",
"android_version": "14",
"region": "SG"
},
"session": {
"id": "sess_x9y8z7",
"user_id": "user_5e6f7g"
}
}
Make uses this structure to expose fields in downstream modules. you can drag fields like device.model into Slack messages, Airtable records, or further HTTP calls.
scenario 1: route critical events to ops Slack with rich formatting
a common scenario. webhook receives all events, a Router branches by event type, and Slack receives formatted messages.
scenario JSON skeleton (paste into Make’s import dialog):
{
"name": "Cloud Phone Ops Alerts",
"flow": [
{
"id": 1,
"module": "gateway:CustomWebHook",
"metadata": {"webhook": "cloudfone-events"}
},
{
"id": 2,
"module": "builtin:BasicRouter",
"routes": [
{
"filter": {"name": "Offline", "conditions": [[{"a": "{{1.event}}", "o": "text:equal", "b": "device.offline"}]]},
"flow": [
{"id": 3, "module": "slack:CreateMessage", "mapper": {"channel": "#ops-critical", "text": ":red_circle: Device {{1.device.id}} ({{1.device.model}}) went offline at {{1.timestamp}}"}}
]
},
{
"filter": {"name": "Install Failed", "conditions": [[{"a": "{{1.event}}", "o": "text:equal", "b": "install.failed"}]]},
"flow": [
{"id": 4, "module": "slack:CreateMessage", "mapper": {"channel": "#ops-warnings", "text": ":warning: APK install failed on {{1.device.id}}"}}
]
}
]
}
]
}
the Router branches by event type, sending critical events to one channel and warnings to another. the Slack messages use the device data inline.
scenario 2: bulk install APK across the fleet on a schedule
Make’s Schedule trigger fires every weekday at 02:00 SGT. an HTTP call lists devices, an Iterator processes each one, and another HTTP call installs the APK.
scenario flow:
[Schedule: 02:00 SGT weekdays]
-> [HTTP: GET /v1/devices?tag=staging]
-> [Iterator: split device list]
-> [HTTP: POST /v1/devices/{{id}}/install]
-> [Sleep: 30 seconds]
-> [Aggregator: collect results]
-> [Slack: post completion summary]
the install POST body:
{
"apk_url": "https://artifacts.your-ci.com/staging-latest.apk",
"auto_launch": true,
"wait_for_completion": true
}
each device gets the latest build. results aggregate into a summary message that goes to Slack with success/failure counts. similar pattern in cloud phone Zapier integration, but Make handles the iteration more cleanly for fleet-wide ops.
scenario 3: provision cloud phone when Stripe customer pays, log to Notion
end-to-end customer onboarding automation:
[Webhook: Stripe events]
-> [Filter: event type = customer.subscription.created]
-> [HTTP: POST /v1/devices/provision]
-> [Notion: create customer record]
-> [Email: send welcome with credentials]
-> [Slack: notify sales team]
the cloudf.one provision request:
{
"owner_email": "{{1.data.object.customer_email}}",
"plan": "{{1.data.object.items.data[0].price.lookup_key}}",
"region": "SG",
"send_credentials_email": false
}
cloudf.one returns the device credentials in the response. Make’s HTTP module exposes those as {{3.device.username}} and {{3.device.password}} for downstream modules.
the Notion module creates a record in the Customers database with the customer email, plan, device ID, and provisioning timestamp. the email module sends the welcome message. the Slack module pings the sales team channel.
error handling in Make
Make has built-in error handlers. right-click any module and add an “Error handler” route. common patterns:
- log errors to a Data Store and retry on the next scenario run
- post errors to a Slack channel for manual investigation
- fall back to a different action if the primary action fails
Make’s error handlers run inline within the same scenario, which makes debugging easier than systems where errors fire separate workflows.
scheduling, throttling, and operations limits
Make’s free tier includes 1,000 operations per month, which covers small cloud phone integrations. for production fleets with high event volume, the Pro plan ($9 per month for 10,000 ops) is usually sufficient. enterprise scenarios scale up from there.
cloudf.one’s webhook delivery includes built-in throttling, so Make never gets flooded by event spikes.
authoritative reference on Make’s HTTP module is the Make HTTP documentation.
try cloud phone Make integration on a real Singapore device
if you use Make for automation and want to integrate cloud phones, start a trial, generate an API token, and clone one of the scenarios above to get started in 10 minutes.
frequently asked questions
what’s the difference between Make and Integromat?
they’re the same product. Integromat rebranded as Make in 2022. existing scenarios still work; the API and module library are unchanged.
can I share Make scenarios with my team?
yes. Make supports team workspaces with shared scenarios, connections, and data stores. ideal for cloud phone ops where multiple team members manage automations.
how does Make handle high-volume cloud phone webhooks?
Make queues incoming webhooks and processes them as scenario operations. for very high volume (1,000+ events per minute), use the cloudf.one webhook batching feature to group events before delivery.
can I use Make to run scheduled cloud phone screen recordings?
yes. set a Schedule trigger, call the cloudf.one screen recording endpoint, and store the resulting video URL in your storage of choice (S3, Dropbox, Google Drive) via Make’s native modules.
is the cloudf.one app available in Make’s public catalog?
a native Make app is on the roadmap. the HTTP-based integration covers all common patterns and is more flexible for custom logic in the meantime.