# Make.com App & Module Catalog - Triggers & Actions (`mediocre_interest/make-app-catalog`) Actor Export every Make.com app and module your API token can see - 3,000+ apps, 42,000+ modules - with the module kind, instant vs polling trigger, transaction (ACID) support, deprecation, connection type and OAuth scopes. One row per module, one per app, plus a JSON index for linters. - **URL**: https://apify.com/mediocre\_interest/make-app-catalog.md - **Developed by:** [Mediocre\_Interest](https://apify.com/mediocre_interest) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $4.50 / 1,000 modules catalogeds This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## 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: ```json { "makeZone": "eu1", "makeApiToken": "", "apps": ["builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable"], "includeConnections": true } ``` The whole registry, with the connection columns: ```json { "makeZone": "eu1", "makeApiToken": "", "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: ```json { "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: ```json { "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: ```bash curl -X POST "https://api.apify.com/v2/acts/mediocre_interest~make-app-catalog/run-sync-get-dataset-items?token=" \ -H 'Content-Type: application/json' \ -d '{ "makeApiToken": "", "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](https://apify.com/mediocre_interest/make-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](https://apify.com/mediocre_interest/make-operations-analyzer) - shows where your Make operations actually go, scenario by scenario. - [n8n Node Catalog & Community Package Scraper](https://apify.com/mediocre_interest/n8n-node-catalog) - the same idea for n8n: every node and community package in one table. - [n8n Workflow Auditor](https://apify.com/mediocre_interest/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. # Actor input Schema ## `makeZone` (type: `string`): The zone from your Make URL: eu1, eu2, us1 or us2. A full host such as eu1.make.com or a white-label host also works. ## `makeApiToken` (type: `string`): An API token from Profile > API/MCP access with the apps:read and organizations:read scopes. Add templates:read to read public templates. Read-only: the Actor only ever sends GET requests. Leave it empty for a demo run - a handful of invented sample rows in the exact shape of the real output, marked isDemo, at no charge. ## `apps` (type: `array`): App names as they appear in a blueprint's module string, for example google-sheets in google-sheets:addRow. The prefilled list gives a few hundred rows in seconds; clear it to catalog every app (about 42,000 module rows, several minutes). A name the zone does not know is reported in the run's status message. ## `moduleKinds` (type: `array`): Keep only these kinds of module. Leave empty for every kind. ## `includeConnections` (type: `boolean`): Add each module's connection type and OAuth scopes, and pick up modules Make has deprecated but still runs. One call per app version; about five minutes for the whole registry. ## `harvestTemplates` (type: `boolean`): Read Make's public templates to add the parameter, mapper and output keys each module uses and how many templates use it. Needs the templates:read scope; about ten minutes for the whole registry. ## `maxModules` (type: `integer`): Stop after this many module rows. 0 means no limit. Apps are processed in catalog order, and the app rows and the JSON index cover only what was written. ## Actor input object example ```json { "makeZone": "eu1", "apps": [ "builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable" ], "moduleKinds": [], "includeConnections": true, "harvestTemplates": false, "maxModules": 0 } ``` # Actor output Schema ## `modules` (type: `string`): No description ## `apps` (type: `string`): No description ## `catalogIndex` (type: `string`): No description ## `runSummary` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "apps": [ "builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable" ] }; // Run the Actor and wait for it to finish const run = await client.actor("mediocre_interest/make-app-catalog").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "apps": [ "builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable", ] } # Run the Actor and wait for it to finish run = client.actor("mediocre_interest/make-app-catalog").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "apps": [ "builtin", "gateway", "http", "util", "google-sheets", "slack", "openai-gpt-3", "airtable" ] }' | apify call mediocre_interest/make-app-catalog --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mediocre_interest/make-app-catalog" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/0ysAMIJisXCgtsxRB/builds/SrB8GmXKfMsS37SGZ/openapi.json