Make
Make is a platform that allows users to automate workflows by connecting various apps and services.
Verdict
Common use cases
- Discover which Make operations exist before building
- Populate language dropdowns in workflow specs
- Reference timezone codes when scheduling scenarios
- Audit available operations across team workspaces
- Validate operation names during integration planning
Integration
- Vendor
- Make
- Category
- other
- Auth
- API_KEY
- Tools
- 3
- Composio slug
make
Tools
- Get Operations
Tool to retrieve all operations. use when you need to discover available operations after authentication.
- List Enums Languages
Tool to retrieve a list of language codes and names. use when you need to populate language selectors after authentication.
- List Enums Timezones
Tool to retrieve a list of timezone codes and names. use when populating timezone selectors after authentication.
Setup
Setup guide
- 11. Open your Switchy workspace and navigate to Settings > Integrations > MCP Servers. 2. Click 'Add MCP Server' and select Make from the list. 3. You'll be prompted to enter a Make API key — generate one by logging into your Make account, going to Profile > API, and creating a new token with read access to operations and metadata. 4. Paste the key into Switchy and click 'Connect'. 5. Once connected, open any Space and type '@Make get operations' to test the connection. 6. If the tool returns a list of available operations, the integration is live and ready to use in any conversation.
What teammates see: by default, memories from Make are scoped to the Space (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Spaces have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
List All Operations
@Make retrieve all operations and format them as a table with operation name and categoryOpen in a Space →
Find Language Codes
@Make list all language codes and show me the top ten most common ones with their full namesOpen in a Space →
Check Timezone Options
@Make get all timezone codes and filter for US and European zones onlyOpen in a Space →
Compare Operation Sets
@Make retrieve all operations and highlight any that include the word 'webhook' or 'HTTP'Open in a Space →
Validate Operation Names
@Make list all operations containing 'Google' and show their exact names for API callsOpen in a Space →
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@make what operations can I run through you? I want to see what automation actions are available.
Here are the operations available through the Make MCP: Get Operations (retrieve all available operations), List Enums Languages (fetch language codes and names for localization), and List Enums Timezones (retrieve timezone identifiers for scheduling). These operations let you discover what automation capabilities are accessible through this integration. Each operation returns structured data you can use to build or configure Make scenarios programmatically.
This example shows the discovery workflow — essential first step after connecting Make. The MCP exposes Make's metadata layer, not scenario execution itself. You'll need valid API credentials to retrieve this list, and the actual operations available may vary based on your Make plan tier.
@make fetch all supported languages so I can set up a multi-region workflow with proper locale handling.
Retrieved 184 language options from Make, including: en-US (English - United States), es-ES (Spanish - Spain), fr-FR (French - France), de-DE (German - Germany), ja-JP (Japanese - Japan), zh-CN (Chinese - Simplified), pt-BR (Portuguese - Brazil), and 177 others. Each entry includes the ISO language code and display name. You can use these codes when configuring Make scenarios that need to handle content in specific languages or route data based on user locale.
Demonstrates read-only enumeration — useful when building internationalized automations. This is static reference data, not dynamic scenario state. The language list is comprehensive but won't reflect custom locale configurations in your Make organization. Requires API key authentication to access.
@make I'm scheduling automated reports across global teams — give me all timezone options so I can set accurate trigger times.
Fetched 425 timezone identifiers from Make, including: America/New_York, Europe/London, Asia/Tokyo, Australia/Sydney, UTC, America/Los_Angeles, Europe/Paris, Asia/Singapore, and 417 others. Each timezone includes its IANA identifier (e.g., 'America/Chicago') and human-readable name. Use these when configuring Make scenario schedules to ensure your automations fire at the correct local time for each region.
Shows how the MCP supports time-sensitive automation setup. This retrieves Make's full timezone catalog — critical for avoiding scheduling errors in distributed workflows. The list is static reference data; it won't show which timezones are currently in use by your scenarios. Requires authenticated API access.
Use-case deep-dives
When Make MCP helps map existing workflow integrations
A 5-person operations team inherits a Make account with 40+ scenarios built by a contractor who left no documentation. They need to audit what's running before migrating to a new automation platform. The Make MCP's Get Operations tool pulls the full scenario list into Switchy, where the team can tag, categorize, and assign ownership in a shared workspace. This works if you're doing discovery or light auditing. If you need to actually build or modify scenarios, the MCP doesn't expose those controls—you'll still open the Make UI. The buying call: use this MCP when you need to inventory or reference existing Make workflows in team conversations, not when you're actively building automations.
When timezone and language lookups matter for setup
A 3-person customer success team onboards SaaS clients across 12 countries, each requiring timezone and language settings synced into Make scenarios that send localized notifications. The List Enums Timezones and List Enums Languages tools let the team pull canonical codes into Switchy during onboarding calls, ensuring the correct values get passed to Make without opening a second tab or guessing ISO codes. This is a narrow win: if your onboarding process doesn't involve configuring automation parameters in real time, these tools add no value. If you're just running pre-built scenarios, skip the MCP. The buying call: adopt this when your team configures Make workflows live with customers and needs instant access to timezone or language reference data.
When support needs to verify Make scenario context
A 6-person support team fields tickets about failed automation runs. Customers reference scenario names or operation IDs, but the support reps don't have Make admin access. The Get Operations tool lets them pull the scenario list into Switchy to confirm which workflow the customer is talking about, then route the ticket to the right engineer without escalating to an admin for a screenshot. This works only if your support volume is low enough that manual lookups make sense—if you're triaging 50+ tickets a day, you need a proper Make logging integration, not an MCP. The buying call: use this when support needs occasional read-only visibility into Make scenarios without granting full platform access.
Frequently asked
What does the Make MCP do in Switchy?
The Make MCP lets AI agents query Make's metadata — available operations, language codes, and timezone lists. It's designed for discovery and setup tasks, not for building or running scenarios. Think of it as a reference layer that helps agents understand what's possible in Make before you configure actual automations.
Do I need a paid Make account to use this MCP?
You need any Make account that can generate an API key. Make's free tier includes API access, so you don't need a paid plan just to connect the MCP. The key goes into Switchy's auth field, and the MCP uses it to fetch operation lists and enum data from Make's API.
Can this MCP create or trigger Make scenarios?
No. The three tools only retrieve metadata — operation names, language codes, timezone identifiers. You can't build scenarios, run them, or read execution logs through this MCP. For workflow automation, use Make's native UI or webhook triggers that call your Switchy agents when scenarios complete.
Why use this instead of just opening Make's documentation?
An agent can pull the exact list of operations your Make account supports in real time, then reference that data in a conversation without you switching tabs. It's faster for exploratory questions like "Does Make have a Shopify module?" when you're scoping a new automation idea with your team.
Who should connect the Make MCP in our workspace?
Whoever owns your Make automations and has an API key. The MCP doesn't write data, so the risk is low, but the person connecting it should understand which operations your Make org uses. One connection covers the whole Switchy workspace; you don't need separate keys per teammate.