How to use this glossary
Make names things differently from Zapier and Pabbly Connect, and several of its terms describe billing as well as structure. The tables below group about 30 terms by where you meet them: building a scenario, moving data through it, branching it, running it, and keeping it reliable. Each row says where the term shows up in the editor, whether it uses credits, and the closest name in Zapier or Pabbly Connect.
The credits column follows Make's own rules. Make says credits are the billing unit and that by default 1 operation equals 1 credit, with some AI modules charging more. [1] A trigger runs once per check regardless of how many bundles it returns, and other modules run once per bundle they receive. [2] Make's pricing FAQ lists only two exceptions where no credits are counted: the Router module and the error handler modules Rollback, Break, Resume, Commit and Ignore. [3] Make Academy adds that filters consume no credits. [4]
The equivalents column is a translation aid, not a claim that the features behave the same. Where the cited Zapier or Pabbly pages do not name a matching feature, the cell says so.
Building blocks: scenario, modules and triggers
A scenario is the whole automation. Inside it, modules do the work. Make sorts modules by what they do: triggers bring changes from a service into Make, searches return records (Search filters them, List returns all), actions get, create, update or delete data, and universal modules, usually called Make an API Call, reach endpoints that have no ready-made module. [5] A trigger can only be the first module, and a scenario has one. [5]
Triggers come in two kinds. A polling trigger checks for new data since the last run on a schedule; its name often starts with Watch, and a run that finds nothing is a check run. An instant trigger is a webhook: the service tells Make when data arrives, the schedule switches to Immediately as data arrives, and the module carries a lightning icon and an instant tag. [5] Make Academy says a trigger uses one credit regardless of how many results it returns. [4]
| Make term | Where you see it | Uses credits? | Zapier | Pabbly Connect |
|---|---|---|---|---|
| Scenario | The canvas you build in, listed under Scenarios | The sum of its module runs | Zap [6] | Workflow [7] |
| Module | Each circle on the canvas | Usually 1 per bundle processed [2] | Trigger or action step | Trigger or action step |
| Polling trigger (Watch...) | First module, runs on the schedule [5] | 1 per check, even with no data [4] [22] | Trigger checked at the polling interval [6]; triggers are not tasks [8] | Trigger; free task [7] |
| Instant trigger | Lightning icon and instant tag [5] | 1 per run (trigger rule) [2] | Instant trigger [6] | Instant webhook [7] |
| Check run | Scenario history, a run with no new data [5] | Yes, the trigger's 1 credit [22] | No equivalent cost; triggers never use tasks [8] | No equivalent cost [7] |
| Action module | Any module after the trigger that gets, creates, updates or deletes [5] | 1 per bundle [4] | Action; a task when it succeeds [6] | Action; a task [7] |
| Search module | Search or List modules; most return up to 3,200 objects or 5 MB per run [5] | 1 per bundle it receives [2] | Not named in cited pages | Not named on the cited page |
| Universal module (Make an API Call) | Inside an app's module list [5] | 1 per bundle | Not covered in cited pages | Not named on the cited page |
Data words: bundles, mapping, collections and data stores
Make describes a bundle as a single package of data that moves through a scenario: one email, one spreadsheet row, one form response. [9] Mapping is how you tell a module which item from an earlier module to use; you click into a field and pick from the earlier module's output. [10] Inside a bundle, a collection holds different kinds of information together, and an array holds many values of one kind. [10]
After a run, the numbered bubble next to each module is the quickest way to see bundles. Clicking it shows the input and output of each operation. [9] [11] To check one module without running the rest, right-click it and choose Run this module only. [10]
| Make term | Where you see it | Uses credits? | Zapier | Pabbly Connect |
|---|---|---|---|---|
| Bundle | The numbered bubble after a run [9] | No by itself; each module that processes it does | Not named in cited pages | Not named on the cited page |
| Input / output bundle | Inside the bubble: what Make sent and what came back [10] | No | Not named in cited pages | Not named on the cited page |
| Mapping | Click into a module field to open the mapping panel [10] | No | Not named in cited pages | Not named on the cited page |
| Collection | Expandable item in a bundle [10] | No | Not named in cited pages | Not named on the cited page |
| Array | An item holding several values of one kind [10] | No | Line items (Looping input) [12] | The input to an Iterator [7] |
| Data structure | Left sidebar, Data structures; also set when creating a data store [13] | No | Not named in cited pages | Not named on the cited page |
| Data store | Left sidebar, Data stores; Data store modules in a scenario [14] [15] | Each Data store module run, 1 credit by default [1] | Storage by Zapier; Storage steps do not count as tasks [16] [8] | Closest: Custom Variables [7] |
Flow control: routers, filters, iterators and aggregators
A router splits a scenario into routes that run one after another, not in parallel; you set their order by right-clicking the router and choosing Order routes. [17] A fallback route catches bundles that match no other route and runs last. [17] A filter sits on the line between two modules; bundles that fail its conditions stop there. [18]
An iterator turns an array into a series of bundles, one per item, and an array aggregator merges several bundles back into one. [19] A repeater outputs a set number of bundles, each with a counter called i. [19] These change how many bundles later modules receive, which is where most surprise credit bills come from.
| Make term | Where you see it | Uses credits? | Zapier | Pabbly Connect |
|---|---|---|---|---|
| Router | Tools, Flow control; or right-click a line and Add a router [17] [20] | No [3] | Paths; Paths steps do not count as tasks [6] [8] | Router; internal step [7] |
| Route | Each branch leaving a router [17] | No; the modules on it do | A path | A route |
| Fallback route | Route settings, set Fallback to Yes; shown with a special arrow [17] | No | Not named in cited pages | Not named on the cited page |
| Filter | Click the line between two modules [18] | No [4] | Filter; does not count as a task [8] | Filter; internal step [7] |
| Iterator | Tools, Flow control [19] | Runs once per bundle it receives; the bundles it outputs drive later modules [2] | Looping by Zapier; does not count as a task [12] [8] | Iterator [7] |
| Array aggregator | Tools, Flow control [19] | Runs per bundle under Make's operations rule; fewer bundles afterwards | Not named in cited pages | Not named on the cited page |
| Repeater | Tools, Flow control [19] | Its output bundles each run later modules | Looping: Create Loop From Numbers [12] | Not named on the cited page |
Running a scenario: schedules, runs, cycles and replays
A new scenario runs every 15 minutes by default; you change that by clicking Every 15 minutes on the scenario toolbar. [21] A scenario that is not activated does not run on its schedule. [22] Run once executes the whole scenario on demand, which is how you test before activating. [23] [24]
Make processes each bundle through phases it calls initialization, operation, commit or rollback, and finalization. [11] Commit trigger last is on by default, and by default Make commits data only when the entire scenario finishes successfully. [25] Cycles per run caps the number of cycles in one execution; a manual Run once uses only one cycle. [25] Scenario run replay reruns the current version of a scenario with trigger data from an earlier run, on all plans, and costs credits like a normal run. [26]
| Make term | Where you see it | Uses credits? | Zapier | Pabbly Connect |
|---|---|---|---|---|
| Schedule | Every 15 minutes button on the toolbar [21] | Each scheduled check costs the trigger credit | Polling interval [6] | Schedule Workflows [7] |
| Run once | Bottom of the Scenario Builder [11] | Yes, like any run [23] | Not named in cited pages | Not named on the cited page |
| Activation (ON/OFF) | Toggle, purple when active [24] | No | Not named in cited pages | Not named on the cited page |
| Scenario run / history | Scenario history | The run's modules do | Zap run, Zap history [6] | Not named on the cited page |
| Operation | First number in the bubble above a module [2] | 1 credit by default [1] | Roughly a task [6] | Roughly a task [7] |
| Credit | Toggle credits on next to the scenario name to see the second number [2] | It is the billing unit [1] | Task (billing unit) | Task (billing unit) [7] |
| Cycle | Scenario settings, Cycles per run [25] | Each cycle's module runs do | Not named in cited pages | Not named on the cited page |
| Scenario run replay | Run with existing data; Replay run in Run details [26] | Yes, like a normal run [26] | Not covered in cited pages | Not named on the cited page |
Reliability and access: webhooks, connections and incomplete executions
A webhook creates a URL that an outside app or another scenario can call; webhooks are instant triggers. [27] Each webhook has its own queue, sized at up to 667 items per 10,000 credits licensed per month and capped at 10,000 items. [27] A connection is the saved authorization between Make and another service, and every user in your team can use and manage connections created in that team. [28]
An incomplete execution is a failed run that Make saves so it can be finished later, if Store incomplete executions is turned on in scenario settings. [25] Keep data confidential stops Make from keeping run payloads in its logs. [25] Error handler modules, Rollback, Break, Resume, Commit and Ignore, are free of credits. [3]
| Make term | Where you see it | Uses credits? | Zapier | Pabbly Connect |
|---|---|---|---|---|
| Webhook | Webhooks app; Custom webhook trigger [27] | The run it starts does | Instant trigger [6] | Instant webhook [7] |
| Webhook queue | Holds requests until the scenario runs [27] | No; processing it does | Not named in cited pages | Not named on the cited page |
| Webhook response | A module that sets the reply to the caller [27] | 1 per run (module rule) | Not named in cited pages | Not named on the cited page |
| Connection | Credentials, Connections; or Add next to Connection in a module [28] | No | Not named in cited pages | App connections [7] |
| Incomplete execution | Incomplete executions tab, when storing is enabled [25] | Retries are new module runs | Not named in cited pages | Not named on the cited page |
| Error handler | On an error handler route attached to a module | No for Rollback, Break, Resume, Commit, Ignore [3] | Not named in cited pages | Not named on the cited page |
| Process data in order | Scenario settings [25] | No | Not named in cited pages | Not named on the cited page |
| Keep data confidential | Scenario settings [25] | No | Not named in cited pages | Not named on the cited page |
The three translations that change your bill
First, trigger checks. Zapier says trigger steps never count toward tasks, and Pabbly Connect calls triggers and internal steps free tasks. [8] [7] Make charges 1 credit per trigger check even when nothing new arrives. [4] [22] A scenario polling every 15 minutes makes 96 checks a day before it processes a single record.
Second, internal steps. Zapier excludes Filter, Paths, Formatter, Delay, Looping and Storage steps from task counts. [8] Make excludes routers, filters and error handlers, [3] [4] but a data store lookup or an iterator is a module run. Moving a Storage-by-Zapier lookup into a Make data store adds a credit per lookup.
Third, per-bundle billing. In Make's own example, a Google Forms scenario with 10 new responses and three action modules uses 31 operations: 1 for the trigger plus 10 for each action. [2] Counting the bundles that reach each module is the fastest way to forecast a Make bill from a Zapier task history.
- Count trigger checks per month from the schedule, then add them to your Zapier task count.
- Subtract Zapier Filter, Paths, Formatter, Delay, Looping and Storage steps, then add back any Make data store or iterator modules that replace them.
- Multiply each Make action module by the bundles that reach it, not by the number of runs.
Watch demos / Official walkthroughs
See how the tools work.
Videos load from YouTube only when you press play. These are provider videos, not our own product tests.
Make / Official video
Make—Building Your First Automated Workflow from Scratch
What to look for: Follow how modules connect and how data moves through the first workflow.
Watch on YouTubeQuestions before you decide
Is a Make operation the same thing as a Zapier task?
Close, but not identical. Make counts an operation each time a module processes a bundle, including every trigger check, and by default bills 1 credit per operation. Zapier says a task is an action a Zap successfully completes, and trigger steps never count. The same workflow therefore usually shows more Make operations than Zapier tasks.
Do routers and filters use Make credits?
No. Make's pricing FAQ lists the Router module as having no credits counted, and Make Academy says a bundle passing through a filter does not consume credits. A filter can still lower your bill, because bundles it stops never reach the paid modules after it.
What is the difference between a bundle and an operation?
A bundle is one package of data, such as one form response or one spreadsheet row. An operation is a module doing its work. Most modules run once per bundle, so five bundles reaching a Slack module mean five operations, while a trigger runs once per check no matter how many bundles it returns.
What is the Make equivalent of a Pabbly Connect workflow?
A scenario. Pabbly Connect describes a workflow as a trigger plus one or more action steps, which maps directly onto a Make scenario with a trigger module followed by action modules. Billing differs: Pabbly treats triggers and internal steps as free tasks, while Make charges for trigger checks.
Sources & verification
Product details and prices can change. Check the linked provider before buying.
- Make Help Center: Credits Accessed 30 Oct 2026
- Make Help Center: Operations Accessed 30 Oct 2026
- Make pricing and credits FAQ Accessed 30 Oct 2026
- Make Academy: Credit consumption in Make Accessed 30 Oct 2026
- Make Help Center: Types of modules Accessed 30 Oct 2026
- Zapier Help: Learn key concepts in Zapier Accessed 30 Oct 2026
- Pabbly Connect product page Accessed 30 Oct 2026
- Zapier Help: How is task usage measured in Zapier Accessed 30 Oct 2026
- Make Academy: Introduction to bundles Accessed 30 Oct 2026
- Make Help Center: Mapping Accessed 30 Oct 2026
- Make Help Center: Scenario execution flow Accessed 30 Oct 2026
- Zapier: Looping by Zapier integrations Accessed 30 Oct 2026
- Make Help Center: Data structures Accessed 30 Oct 2026
- Make Help Center: Data stores Accessed 30 Oct 2026
- Make integrations: Data store modules Accessed 30 Oct 2026
- Zapier: Storage by Zapier integrations Accessed 30 Oct 2026
- Make Help Center: Router Accessed 30 Oct 2026
- Make Help Center: Filtering Accessed 30 Oct 2026
- Make Help Center: Flow control Accessed 30 Oct 2026
- Make Academy: Adding a router Accessed 30 Oct 2026
- Make Help Center: Schedule a scenario Accessed 30 Oct 2026
- Make Help Center: Step 10, schedule your scenario Accessed 30 Oct 2026
- Make Academy: Run once Accessed 30 Oct 2026
- Make Academy: Overview of scheduling Accessed 30 Oct 2026
- Make Help Center: Scenario settings Accessed 30 Oct 2026
- Make Help Center: Scenario run replay Accessed 30 Oct 2026
- Make Help Center: Webhooks Accessed 30 Oct 2026
- Make Help Center: Connect an application Accessed 30 Oct 2026
Sources link directly to providers. Product buttons may use separately labeled affiliate links. Read our disclosure.