Make.com App & Module Catalog - Triggers & Actions

Export every Make.com app and module your API token can see as a flat, filterable table - with the facts a module name never tells you: which trigger is instant and which polls, which module a Rollback can actually undo, which one is deprecated, and what connection it needs. Press Start with the token field empty and you get a small demo run in seconds, so you can see the exact columns before you create anything. Paste a Make API token and the same run reads your own account: about 2,850 apps in 3,000 app versions and 42,000 modules on eu1, in roughly 70 seconds, including your organization's own custom apps.

• 🔍 Every fact a module name hides - instant vs. polling triggers, Rollback (ACID) support, deprecation, connection type and OAuth scopes, in one row.
• 🔒 Read-only, always - only GET requests, no AI model, and nothing is ever written back to your Make account.
• 🗂️ Built for lookups - a catalog-index record keyed exactly the way a blueprint names a module (slack:CreateMessage@4), for one-call resolution.
• 📤 Export anywhere - JSON, CSV, Excel or XML, on a schedule or from the API.

What does the Make.com App & Module Catalog do?

Make's scenario editor knows things about a module that a blueprint does not. A blueprint says slack:WatchMessages with version: 4; it does not say that this is a polling trigger while slack:watchNewEvents is an instant one, that both support transactions, that Slack v4 has eight modules whose labels say deprecated, or that the module needs an account:slack2 connection with the channels:history scope. Make's own app search holds all of it, and this Actor exports it.

One run reads three sources and merges them:

• The app registry your token can see - one row per module per app major version, which is the number a blueprint stamps on the module. Old majors are kept, because old scenarios still run them.
• The connection lists - the connection type and OAuth scopes each module needs. This source also still lists modules the editor has dropped: on eu1 it recovers about 250 modules that no longer appear in app search but that existing scenarios continue to execute.
• Make's public template library (optional) - real parameter, mapper and output keys for the modules that templates actually use, plus a template count per app.

Which module facts does it export?

Column	What it tells you
kind	Make's own vocabulary: action, search, trigger, instant-trigger, universal, responder, transformer, feeder, aggregator, router, converger, directive
isInstant, instantAlternatives	Whether the trigger is webhook-fed, and which instant triggers of the same app version could replace a polling one. About 3,700 instant and 2,100 polling triggers on eu1
supportsTransactions	Whether a Rollback or Commit error handler can undo what the module did - Make's acid flag, true for about 5,900 modules across 25 apps
isDeprecated, listedIn	Whether the label says deprecated, legacy or do not use (about 590 modules, 283 of them still offered), and whether the module came from app search, the connection list or a template
connectionTypes, requiresConnection, oauthScopes	account:slack2, keychain:apikeyauth, and the scopes the module asks for
batchVariants	The bulk module that does the same job for many records, matched by Make's own label convention
consumesCredits, creditsNote	The AI modules that bill Make credits on top of the operation
isCustomApp, isMakeTool, premiumTier, isBeta	Whose app it is, and which plan tier it needs
parameterKeys, mapperKeys, outputKeys, templateCount	Filled from public templates when Read public templates is on

Why use this Make.com module catalog?

• 🧩 It answers what a module name cannot. A linter or an agent guessing from watchRows cannot know whether an instant twin exists, whether Rollback works, or whether the module was deprecated two versions ago. Every one of those is a column here.
• 📡 It is your catalog, not a snapshot. The run uses your token and reads live, so you get the apps your plan and your organization can actually use - including your own custom (SDK) apps, flagged with isCustomApp so you can filter them out before sharing a dataset.
• 🆓 Nothing to set up to try it. With no token the run writes a small set of clearly-marked sample rows (isDemo: true) in the exact output shape, in about two seconds.
• 🗂️ It is built to be looked things up in. Besides the two datasets, each run writes a catalog-index JSON record keyed exactly the way a blueprint names a module - slack:CreateMessage@4
  • so a linter can resolve a scenario module in one lookup. Against 400 of Make's most-used public templates, that index resolves 348 of 355 distinct module references exactly.
• 🔌 It is an Apify Actor. Schedule it, call it from the API, export to JSON, CSV or Excel, or drive it from the Make.com app, the n8n integration or Zapier.

How to export the Make.com app and module catalog

Without a Make account, to see the output shape:

1. Press Start with Make API token left empty.
2. Read the Modules tab: 15 sample rows from two invented apps, every one marked isDemo.

With your own Make account, for the real catalog:

1. In Make, open Profile → API/MCP access and add a token with the apps:read and organizations:read scopes. Add templates:read if you want template columns.
2. Set Make zone to the subdomain in your Make URL - eu1, eu2, us1, us2, or a white-label host. A token only works in the zone it was created in.
3. Paste the token into Make API token.
4. Leave Apps as it is for a fast first run of a few hundred rows, or clear it to export every app.
5. Press Start, then open the Modules tab, the Apps tab, or download catalog-index from the run's storage.

Input

Field	What it does
Make zone	The subdomain of your Make URL: eu1, eu2, us1, us2, or a full white-label host. Default eu1
Make API token	Your own token, sent only to that zone and never written into a row. Leave it empty for the demo run
Apps	App names as they appear in a blueprint's module string - google-sheets from google-sheets:addRow. Empty means every app
Module kinds	Keep only the kinds you need: instant triggers, polling triggers, actions, searches, universal modules, and the rest. Empty means every kind
Include connection types and scopes	One extra call per app version; adds the connection columns and the deprecated modules the editor no longer lists. On by default
Read public templates	Reads Make's public template library for parameter keys and per-module template counts. Off by default
Maximum modules	Stop after this many module rows. 0 means no limit

A fast first run over eight well-known apps:

{
    "makeZone": "eu1",
    "makeApiToken": "<your Make API token>",
    "apps": ["builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable"],
    "includeConnections": true
}

The whole registry, with the connection columns:

{
    "makeZone": "eu1",
    "makeApiToken": "<your Make API token>",
    "apps": [],
    "includeConnections": true
}

Output

Each run writes two datasets and two key-value store records: Modules (the default dataset, one row per module per app major version), Apps (one row per app version), catalog-index (the lookup record) and summary-run (what the run read and wrote). Datasets export as JSON, CSV, Excel, XML or RSS.

One row from the first input example above:

{
    "moduleType": "slack:WatchMessages",
    "appName": "slack",
    "appLabel": "Slack",
    "appVersion": 4,
    "appVersionFull": "4.13.4",
    "isLatestVersion": true,
    "moduleName": "WatchMessages",
    "moduleLabel": "Watch Public Channel Messages",
    "description": "Triggers when a new message is added to a public channel.",
    "kind": "trigger",
    "isTrigger": true,
    "isInstant": false,
    "instantAlternatives": ["slack:watchInteractivityEvents", "slack:watchNewEvents"],
    "batchVariants": [],
    "supportsTransactions": true,
    "isModulePublic": true,
    "isDeprecated": false,
    "isCustomApp": false,
    "premiumTier": 0,
    "consumesCredits": false,
    "group": "Messages",
    "connectionTypes": ["account:slack2"],
    "requiresConnection": true,
    "oauthScopes": ["channels:history", "channels:read"],
    "listedIn": "editor",
    "docsUrl": "https://apps.make.com/slack",
    "iconUrl": "https://eu1.make.com/static/img/packages/slack_64.png",
    "isDemo": false,
    "zone": "eu1",
    "collectedAt": "2026-09-23T05:04:08.449Z"
}

What does each module row contain?

Columns	Meaning
moduleType, appName, moduleName, appVersion, appVersionFull, isLatestVersion	The module as a blueprint names it. appVersion is the major version a blueprint stamps on the module
moduleLabel, description, group	What the editor shows: the label, Make's own description, and the designer group the module sits in
kind, isTrigger, isInstant, instantAlternatives, pollingAlternatives, batchVariants	What the module is, and what else in the same app version could do the job
supportsTransactions, consumesCredits, creditsNote, supportsAgent, premiumTier	What running it implies: Rollback support, Make credits, agent support, plan tier
isModulePublic, isAppPublic, isDeprecated, isBeta, isCustomApp, isMakeTool, listedIn	Whether the editor still offers it, and where this row was found
connectionTypes, requiresConnection, oauthScopes	The connection the module needs
parameterKeys, mapperKeys, outputKeys, templateCount	Real key names from public templates, when that option is on
docsUrl, iconUrl, zone, collectedAt, isDemo	Where to read more, and when and where the row was read

batchVariants and the universal (Make an API Call) classification are label heuristics - Make publishes no field for either - so the raw signals they were derived from stay on the row beside them.

What is in the Apps dataset?

One row per app version, counted from the module rows the run wrote:

{
    "appName": "slack",
    "appLabel": "Slack",
    "appVersion": 4,
    "appVersionFull": "4.13.4",
    "isLatestVersion": true,
    "appType": "native",
    "moduleCount": 58,
    "actionCount": 31,
    "searchCount": 9,
    "pollingTriggerCount": 7,
    "instantTriggerCount": 2,
    "universalCount": 1,
    "transactionalModuleCount": 9,
    "deprecatedModuleCount": 8,
    "connectionTypes": ["account:slack2", "account:slack3"],
    "templateCount": 622,
    "docsUrl": "https://apps.make.com/slack"
}

What is the catalog-index record for?

catalog-index is the machine-readable form of the same run: every module keyed app:module@major, with its kind, instant flag, transaction support, deprecation, bulk variants, instant alternatives and connection type, plus one entry per app. It is built for tools that resolve a blueprint module in one lookup - look up the exact key, then any version of the same module, then treat it as unknown. A whole-registry index is about 13 MB of JSON; a run filtered by Apps writes a partial one and records which apps it covered.

How much does it cost to export the Make.com module catalog?

The Actor is pay per event, at the price shown on this Actor's Pricing tab on the Apify Store:

Event	Charged	When
Modules Cataloged	Once per module row written	When the batch containing that row is flushed to the dataset

That is the only billed event - app rows, the catalog-index record and the run summary cost nothing extra, and neither does reading Make's public templates. A demo run (no token) never charges anything. Because the event fires only after a row is written, a run that fails before writing anything - a bad token, or a budget cap below the price of one module - is charged zero events.

For scale: the demo writes 15 free rows, eight prefilled apps with connections on write 294 module rows, and the whole registry writes about 42,300 - each one billed as one event. Filtering by Apps is what keeps a run's event count, and so its cost, down.

Make's own API is free to call, and this Actor only reads. It respects Make's rate limits and paces itself if Make ever asks it to.

How to run this Actor from the API or from Make.com

Run it and get the rows back in one request:

curl -X POST "https://api.apify.com/v2/acts/mediocre_interest~make-app-catalog/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H 'Content-Type: application/json' \
  -d '{
    "makeApiToken": "<your Make API token>",
    "apps": ["slack"],
    "moduleKinds": ["trigger"]
  }'

That returns the Slack trigger rows as JSON - the polling ones carrying their instantAlternatives. Add &format=csv for a spreadsheet, or &fields=moduleType,kind,isInstant,supportsTransactions to keep only the columns you need.

You can also drive it from the Apify app for Make.com, from n8n's Apify node or from Zapier, and schedule it in Apify to refresh the catalog on a timetable. Weekly is enough for most accounts: over the two days this Actor was measured across, Make's registry moved by about fifty modules.

Tips for better results

• Start with Apps set. A filtered run finishes in seconds and costs almost nothing; clear the field only when you want the whole registry.
• Turn off connection types for the fastest full export. It halves the runtime, at the price of the connection columns and the deprecated modules only the connection lists still know about.
• Turn on Read public templates when you need real key names. It is the only source of parameterKeys and mapperKeys, and it pays for itself when you are generating blueprints.
• Keep the old majors. A scenario built years ago still runs google-sheets:watchRows v2; filtering to the latest version only will fail to resolve it.
• Use catalog-index rather than the dataset when a tool needs to look modules up one at a time.

FAQ

Do I need a Make API token to run this Actor?

Not to try it. With the token field empty the run writes 15 clearly-marked sample rows so you can see the columns. To catalog real apps and modules you need your own token, because Make's registry is only readable by an authenticated account.

Does it change anything in my Make account?

No. Every request is a GET. The Actor reads apps, modules, connection requirements and public templates, and writes nothing back to Make.

Is this Actor free to use?

The demo run is, always - press Start with no token and you are never charged. Cataloging your own account is pay per event, billed per module row: see this Actor's Pricing tab on the Apify Store for the current rate, and How much does it cost above for what controls how many events a run charges.

Is my Make API token safe?

The token is a secret input: Apify encrypts it, it is sent only to the Make zone you named, it is never written into a row or a log line, and it is dropped rather than followed if Make ever answered with a redirect to another host.

Are my own custom apps included?

Yes. The run sees exactly what your token sees, including your organization's custom (SDK) apps, and marks their rows isCustomApp: true so you can filter them out before sharing a dataset.

Why is a module marked deprecated when Make still shows it?

Because Make marks deprecation in the label rather than in a field. A module whose label says deprecated, legacy or do not use is flagged even if the editor still offers it - about 590 modules, 283 of which are still on offer. Modules the editor has dropped entirely are flagged too, and carry listedIn: "credentials" or listedIn: "templates" to say where they were found.

What is the difference between an instant trigger and a polling one here?

isInstant is Make's own webhook flag, not a guess from the name. A polling trigger carries the instant triggers of the same app version in instantAlternatives, which is the list you want when you are looking for scenarios that could run on a webhook instead of a schedule.

How current is the data?

It is read live at run time; collectedAt on every row is the timestamp. Make's registry moves - two days of observation showed the module count change by about fifty - so schedule the Actor if you keep a copy.

Does this Actor use an AI model?

No. It reads Make's own API and classifies modules from Make's own fields and label conventions, so two runs of the same account produce the same rows.

What other Actors work with this one?

• Make.com Scenario Auditor - lints your scenarios for wasted operations, missing error handlers and risky patterns. The catalog is what tells it which polling trigger has an instant twin and which module a Rollback can undo.
• Make.com Operations Usage & Cost Analyzer - shows where your Make operations actually go, scenario by scenario.
• n8n Node Catalog & Community Package Scraper - the same idea for n8n: every node and community package in one table.
• n8n Workflow Auditor - the linter for n8n workflows.

Support

Something missing or wrong? Open an issue on the Actor's Issues tab with the run ID and the smallest input that reproduces it - an app name and a module name are usually enough. Custom columns or a different export shape can be built on request.