Skip to main content
Platform security guideReviewed

Make.com security: where scenario data persists, and who can replay it

A Make scenario can keep copies of what passes through it: in a webhook queue and log, in run history, in incomplete executions and in data stores.

This guide maps where Make's own documentation says each copy lives, which team roles can read, replay or edit it, and the settings that change that, with a review sheet for your own account.

Make scenario review sheet

A review sheet for one Make scenario at a time. Part A is a worked example for an invented enquiry scenario: it traces an invented payload to each place Make's documentation says it is stored and lists which roles can read, replay or edit it.

How to use it

Part B is the blank sheet. Every step reads a screen and records names, never secrets; nothing is run, replayed or sent. Locations and plan conditions are as Make's help pages stated them on 14 November 2026.

make.txt

Introduction9 lines

MAKE SCENARIO REVIEW SHEET One sheet per scenario. Read-only: no step changes a setting, runs or replays a scenario, retries an incomplete execution or sends a request to a webhook. RULES FOR FILLING IT IN 1. Never write a webhook address, API key, token, password or connection credential on this sheet. Write the name of the webhook, connection, key or variable, what it can reach and who can see it. 2. Where a step says "open one entry", record which parts or fields are shown, never their values. 3. Work as an organisation Owner or Admin if you can. Make's organisations page says both roles have implicit Team Admin access in all standard teams. If you hold a narrower role, list the screens you could not open. 4. Plan conditions are as Make's own pages state them. Where a feature is not on your plan, write "not on plan". 5. Where a screen offers Edit, Retry, Replay, Run once or Delete, look and close it. Do not save or click through.

What Make is, and how a scenario reaches your data

In Make, an automation is a scenario.

Make's blueprint page says a blueprint, a reusable version of a scenario, includes the scenario's modules, their settings and the mapped values. Make's organisations page says each organisation chooses the data centre location where its data is stored and processed, from the locations the page lists as the United States and the European Union, and that the location cannot be changed after the organisation is created.

A run starts from a trigger.

Make's webhooks page describes webhooks, which create a URL that an external app, a service or another scenario can call over HTTPS, and polling triggers, which periodically ask a service for new data.

To act in other services, a scenario uses connections. Make's connection guide says that for some apps you log in to the service and grant Make permission to access your profile and data, while other apps may require credentials such as a username and password, an API key, or a client ID and client secret.

Take one example set-up. A quote form on a business website posts each enquiry to a Make webhook. The scenario saves the enquiry in a Make data store, creates a contact in the CRM through one connection, and posts a summary to a chat channel through another.

In that position Make sits in the middle of the customer's data: it receives the enquiry, holds access to every app downstream and, as the following sections show from Make's own pages, can keep copies of the enquiry in several places after the run has finished.

That gives a Make account two halves. One is how Make runs its platform, which this guide does not assess and makes no claims about. The other is how your organisation is set up inside it: who belongs to which team, whose accounts the connections use, which settings keep or discard run data, and where a failed record goes.

The second half is on screens you can read in your own account, and it is what the scenario review sheet on this page records.

Several features below depend on the plan. Make's custom variables page names three plans, Pro, Teams and a third it lists after Teams. This guide calls that third one the plan after Teams.

What Make's documentation says it does, and what stays with you

Make's help pages describe some behaviour as the platform's own.

It is worth knowing because it marks where Make's part of the arrangement ends:

  • A webhook that has not been connected to any scenario for more than 5 days (120 hours) is deactivated automatically and answers 410 Gone, according to Make's webhooks page.
  • The same page says Make can process up to 300 incoming webhook requests per 10 second interval and returns status 429 for anything beyond that.
  • Make's Webhooks app page says a webhook API key cannot be viewed after it is created, and that the x-make-apikey header is sanitised automatically, so a scenario does not receive its value.
  • Make's connection guide says editing a connection replaces the original data, and that the full set of credentials has to be entered again because Make does not keep the original connection data.
  • The data centre location chosen for an organisation cannot be changed after the organisation is created, according to Make's organisations page.

What someone in your organisation chose

Everything else in this guide is configuration that someone in your organisation chose, or left as it was when the scenario was built:

  • Team membership and roles, which decide who reaches a team's scenarios, connections, webhooks, keys and data stores.
  • Whose accounts the connections sign in with, given that Make's connection guide says every user in a team can use and manage any connection created in it.
  • Which checks a custom webhook applies to its callers. API keys, IP restrictions and a data structure are each optional in Make's Webhooks app.
  • Whether a scenario keeps run data, through its Keep data confidential and Store incomplete executions settings.
  • Where a failed record goes, since an error handling route can hold ordinary modules, such as one that posts a message to Slack.
  • What sits in custom variables, data stores and module settings, which other people in the team can read, depending on their roles.

Where a payload persists inside Make

One request to a webhook can leave copies in several places, each with its own lifetime and its own readers.

Make documents them on separate pages. This section follows an enquiry through them in the order it meets them, and the review sheet keeps the same order.

The webhook queue and the webhook log

Make's webhooks page says that when a webhook receives a request, the request is stored in that webhook's own queue, and that incoming webhook data is always stored there regardless of the scenario's confidentiality setting. 1 min read

Execution logs and run details

Make's scenario settings page says Make stores the data processed during each run in the execution logs, so that runs can be inspected and troubleshot. 1 min read

Replay data

Make's scenario run replay page says replay is available on all plans and runs the current version of a scenario with the trigger data of an earlier run. 1 min read

Incomplete executions

Make's incomplete executions page says they are disabled by default and switched on per scenario with Store incomplete executions. 1 min read

Data stores

Data stores are where a payload is kept on purpose. 1 min read

Variables, module settings and shared copies

Some places hold values rather than payloads, and each is a place a secret could end up. 1 min read

Who can see, replay or edit it: teams and roles

Make's access model has two levels.

Its teams page says members of a team have access only to the scenarios and data that belong to their team, and lists those items: scenarios, templates, connections, webhooks, keys, devices, data stores, data structures, custom functions and credential requests. Each belongs to exactly one team and cannot be moved to another.

Above the teams sit organisation roles, and Make's organisations page says the Owner and Admin roles include access to all standard teams, which gives them implicit Team Admin access there.

Team structure depends on the plan. The teams page says that on a plan lower than Teams, an organisation can have only one team and cannot manage roles within it. Custom roles, built from a list of permissions, are limited by Make's custom roles page to the plan after Teams.

That page also says team permissions are all-or-nothing per resource type, so a role that may manage scenarios may manage every scenario in the team, and it points to a separate team as the way to limit access to specific resources.

The default team roles, as Make's teams page summarises them:

  • Team Admin: full access to team resources and settings, including member management and audit logs.
  • Team Member: full access to team-owned resources, but no management of members, team settings or the team audit logs.
  • Team Operator: read-only access to general team resources, and can activate, deactivate and schedule scenarios.
  • Team Monitoring: read-only access to selected team information, including scenarios and execution logs, and cannot edit resources or operate scenarios.
  • Team Restricted Member: a deprecated legacy role with broad editing access, which the page says not to use for new assignments.
  • Team Guest: access only to credential requests addressed to that user.

What the roles mean for payloads

Two conclusions follow, and both are this guide's reading rather than Make's words. Execution logs hold run data unless a scenario keeps data confidential, so Team Monitoring, which changes nothing, still reads payloads. And because a replay runs the current version of a scenario on stored trigger data, and resolving an incomplete execution means editing the failing module and running it again on its original input, every role that can edit and run a scenario can choose where stored input goes next.

Make's pages add two specifics. The Webhooks app page says webhook settings can be edited by Team Admin, Team Member and Team Restricted Member. The custom variables page gives a permission table in which Team Admin, Team Member, Team Operator and Team Restricted Member can read team variables and Team Monitoring cannot. For the complete permission set of any role, Make's organisations page points to Org > User roles.

Connections are shared by the team

Make's connection guide says every user in a team can use and manage any connection created in that team, and warns to use personal third-party accounts and credentials carefully, especially when the team has other users. On the Teams plan or higher, it suggests a separate team in which you are the only member for connections made with your personal accounts.

Under Credentials, then Connections, the guide says each connection shows the scenarios that use it and the permissions it was granted, and a filter separates your own connections from everyone's.

Private spaces and sign-in

Make's private spaces page says private spaces are available on all plans and, once an admin enables them, give every member except guests their own workspace for scenarios and connections they do not want teammates to access. On the plan after Teams, the organisation owner can turn on Admin visibility, which lets admins open a member's private space read-only and see scenario names, modules used and credit usage, but not module settings, run history, run details, data stores or connections.

Sign-in controls depend on the plan too. Make's single sign-on page says SSO is available to customers on the plan after Teams and supports OIDC and SAML 2, and its set-up steps include choosing which teams a new user signing in through SSO joins. The two-factor enforcement page gives the same plan condition and says enforcement covers only users who sign in with Make's own email and password; for anyone signing in through Google or an identity provider, two-factor authentication has to be configured and enforced within that provider.

Settings worth reading in each scenario

Each line gives what Make's page says, then this guide's suggestion, which is yours to weigh against how the scenario is used.

  • Keep data confidential. Make's scenario settings page says that with it off, run data is stored in the execution logs, and with it on, the logs show a run happened without the payload. Suggestion: record the setting and the reason for every scenario that carries personal data.
  • Store incomplete executions. Disabled by default, according to Make's incomplete executions page. Suggestion: where it is on for a scenario that carries personal data, name a person who clears the Incomplete executions tab, and record the oldest unresolved date at each review.
  • Discard data if storage is full. The scenario settings page says that with a full incomplete executions folder, Make discards the failed data and keeps the scenario running, and that discarded data cannot be recovered. Make's error handling overview describes an enable data loss setting, and says that with data loss disabled and that storage full, Make disables the scenario. Suggestion: record which way your scenario settings show it, so that the choice between losing a record and stopping the scenario is one someone made.
  • Custom webhook checks. Among a custom webhook's settings, Make's Webhooks app page describes three optional checks: API keys sent in the x-make-apikey header; IP restrictions, which when left empty allow requests from all IPs; and a data structure, without which Make accepts all incoming data without validation. With a data structure selected for the webhook, requests that fail validation are rejected with HTTP status 400, but the page says one made by calling the webhook is stored with it and not used to validate incoming data. Suggestion: record which of the three each webhook uses, and check the calling system's own documentation for whether it can send a fixed header or calls from fixed addresses.
  • Get request headers. The same page says that with this set to Yes, headers from the request are extracted and made available for mapping in the scenario. Suggestion: where a caller sends its own credentials in a header, record whether any later module maps the headers onward.
  • Error handling routes. Make's error handling overview says a route does not need an error handler at all; its example route holds only a Slack > Create a message module that sends a notification when an error occurs. Suggestion: list every module on every error route and the fields it maps, because a notification built from the failed bundle copies that record into another app, where Make's settings no longer apply.
  • Skip and Resume handlers. The overview says Skip removes the affected bundle and marks the run as successful even if an error occurs, and Resume substitutes a predefined output and continues with a Success status. Suggestion: record which modules carry them, since those runs will not show as errors in the history.
  • Errors on the first module. The overview says Make does not store an incomplete execution when the first module fails, unless a Retry error handler is attached to it, and that it disables an instantly triggered scenario immediately if an error happens. Suggestion: on webhook-triggered scenarios, record what the first module does on an error.
  • Public scenario pages. Make's scenario sharing page says a blue Shared label next to the scenario name shows that the public page is on. Suggestion: record the label for every scenario, and for any that is shared, list the module settings a copy made from the link would include.

How to use the scenario review sheet

The sheet takes one scenario at a time and follows its data from the moment a request arrives to the last place a copy is kept.

Part A is a worked example for an invented business and an invented enquiry. Part B is the same sheet blank. Every step reads a screen. None changes a setting, runs a scenario, replays a run, retries an incomplete execution or sends a request to a webhook.

Three rules keep the sheet itself from becoming a leak. Never copy a webhook address, API key, token, password or connection credential onto it: write the name of the webhook or connection, what it can reach and who can see it.

Where a step asks you to open a log or a record, write down which fields appear, not their values. And keep the finished sheet where you keep the scenario's own documentation, because it describes where your customers' data sits.

Work through it as someone who can see the whole team, such as an organisation Owner or Admin, so that what you record is complete. If you hold a narrower role, note which screens you could not open; that gap is a finding about who can see what. Where a row depends on a feature your plan does not include, such as single sign-on or custom variables, write "not on plan" and move on.

Each row names the Make page that says where to look, so you can check the location yourself if a screen has moved.

The summary at the end of Part A is the part to show the business owner. It lists each place the enquiry persists, how long Make's pages say it stays there, who can read it, and who can send it on again, followed by the decisions the review leaves with the owner.

Limits of the scenario review sheet

The sheet is a snapshot of configuration on the date written at its top.

It has edges, and they are worth stating before anyone treats a tidy sheet as a clean bill of health.

  • How Make runs its platform. The sheet reads your settings and says nothing about Make's own infrastructure or operations, which are matters for Make's published material and your agreement with Make.
  • What already left Make. An enquiry the scenario sent to a CRM, a spreadsheet or a chat channel is governed by that app's settings. The sheet records where copies went, not who can see them there.
  • Anything older than the retention windows. Make's history page ties how long run history is kept to the plan, and its webhooks page says webhook logs are kept for 3 days, or 30 days on the plan after Teams. A review cannot show runs or requests older than that.
  • Who changed what. Make's audit logs page limits audit logs to the plan after Teams and keeps them for 12 months. It lists scenario events as created, updated, deleted, activated, deactivated, settings updated and restored, and says data store record events cover the Make interface and API, not changes made through the data store modules.
  • Whether a webhook address has leaked. The sheet records which checks a webhook applies to its callers. It cannot show who else holds the address.
  • How the scenario behaves when someone sends it crafted input. Reading a setting shows how it is configured, not what happens under attack. That is testing, and it belongs with the application that sends data to Make or receives it.
  • Your own application's records of what it sends to Make and what Make sends back. The security logging and monitoring guide in this library covers which events an application should record.

Where Clever Ops comes in

This guide is informational and describes no Clever Ops service.

Make's platform belongs to another business, so under the Clever Ops methodology it stays outside any test's scope without Make's agreement. Whether a customer may test Make itself is a matter for Make's own terms, which this page does not summarise; read them before any testing that would touch Make.

What Clever Ops tests is the application around a scenario. A web application and API penetration test is a signed-in test of a custom application and its API, called directly rather than only through the screens.

A secure code review follows each entry point in scope that reads or writes data, webhook handlers among them, from the incoming request through to the database query. If your application has an API that a Make scenario calls, or webhook handlers that receive Make's requests, those are among the ways in that either piece of work can cover once they are in the agreed scope.

Clever Ops offers neither round-the-clock monitoring nor emergency incident response. If a scenario has sent data where it should not have, or a connection is being used by someone it should not be, call an incident response specialist first.

The report sets out what was tested and what it found. It is not a certificate, and the decision it informs, such as a customer's or an auditor's, belongs to someone else. An application that Clever Ops built or hosts gets a security review instead of an independent test, with the builder and the host named in the report.

Frequently asked questions

Unless the scenario keeps data confidential, yes. Make's scenario settings page says Make stores the data processed during each run in the execution logs so that runs can be inspected, and that with Keep data confidential on, the logs show a run happened without the payload. That setting does not cover the webhook queue: Make's webhooks page says incoming webhook data is always stored in the queue regardless of it, and deleted once a scenario has processed it. Incomplete executions and data stores keep data under their own rules.

Make's Webhooks app page describes three optional checks on a custom webhook: API keys, which callers send in the x-make-apikey header; IP restrictions, which when left empty allow requests from all IPs; and a data structure selected for the webhook, which rejects requests that fail validation with HTTP status 400. Without a data structure, the page says Make accepts all incoming data without validation, and one made by calling the webhook URL is not used to validate incoming data either. Which of the three a webhook uses can be read from its settings under Webhooks, and the review sheet on this page records it.

Make's connection guide says all users in a team can use and manage any connection created in that team, and warns to use personal third-party accounts and credentials carefully when the team has other users. On the Teams plan or higher, it suggests a separate team in which you are the only member for connections made with personal accounts. Under Credentials, then Connections, each connection shows the scenarios using it and the permissions it was granted.

A failed run is listed in the scenario history like any other run, for the number of days the plan stores history, and Make's scenario settings page says its data is stored in the execution logs unless Keep data confidential is on. It is kept as an incomplete execution only if Store incomplete executions is switched on, which Make's incomplete executions page says it is not by default. When it is, a failed run is kept in the scenario's Incomplete executions tab with the data the failing module was processing, though Make's error handling overview says an error on the first module stores no incomplete execution unless that module has a Retry error handler. Make's page on managing them says resolved ones are deleted automatically after 30 days and that a deleted one cannot be put back. Make's scenario settings page adds that the stored data counts towards the plan's storage limits, and with Discard data if storage is full on, failed data that does not fit is discarded and cannot be recovered.

Yes, as Make describes replay. Its scenario run replay page says replay, available on all plans, runs the current version of a scenario with the trigger data of an earlier run, and its own example adds an Airtable module and replays a past week's run to backfill Airtable. A run can be replayed while it is in the scenario history, and replayed runs appear in that history and consume credits. Who can edit and run a scenario therefore decides where its old trigger data can go.

Make's own pages limit both to the plan after Teams. The single sign-on page lists OIDC and SAML 2, and its set-up steps include choosing which teams new SSO users join. The two-factor enforcement page says enforcement covers only users who sign in with Make's own email and password; for people signing in through Google or an identity provider, two-factor authentication has to be configured and enforced within that provider.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.