# Make MCP

> Make (Workflow Automation) MCP Server connects your AI client directly to your Make account. You use it to audit complex workflows, check execution logs for failures, and inspect underlying data stores without opening a browser. It turns difficult-to-access automation infrastructure into natural conversation.

## Overview
- **Category:** growth-engine
- **Price:** Free
- **Tags:** workflow-orchestration, api-integration, execution-logs, data-mapping, automation-debugging

## Description

Listen up. This MCP Server connects your AI client directly to your Make account, letting you treat your whole automation setup—the triggers, the data flows, the connections—like one big database you can talk to. You don't gotta open a browser and click through menus just to check if something broke or what data got lost.

It’s built for auditors and debuggers. You can audit complex workflows and inspect infrastructure details using plain language chat. It turns difficult-to-access automation architecture into natural conversation.

### Mapping Your Entire Scope

You've gotta know your playing field first. If you need to see what parts of your business are connected, you use `list_connections()` to get a list of every single active API link tied to the account—whether it’s Google Sheets or Slack. For security audits, this is key because you can verify who's connected and how deep those permissions go. If your company manages multiple departments, you first call `list_organizations()` to pull all distinct workspaces associated with your credentials. From there, you can pinpoint the exact organizational scope you need by calling `list_teams()`, which returns a list of teams belonging to a specific organization ID.

### Tracking and Inspecting Scenarios

Want to know what workflows exist? You call `list_scenarios()` to get a manifest of every single managed scenario currently running in that scope. If you need the full deep dive on one specific workflow, you pass it an ID to `get_scenario(id)`. This function pulls the complete structural details of that scenario, showing module mappings and trigger settings—it’s like seeing the blueprint for how the whole thing is supposed to run.

When a flow fails, you don't wanna guess. You use `list_scenario_logs(id)` to pull detailed execution logs for any specific Make scenario run. This lets you pinpoint exactly when an automation broke, what data it was trying to process right before the failure, and the raw error payload. It’s your primary tool for figuring out *why* something went wrong.

### Data Visibility and Infrastructure Checks

The workflows rely on stored information, too. You can use `list_data_stores()` to see a list of internal Make key-value data tables available in the workspace. These are the persistent data stores that multiple workflows pull from or write to, so you can inspect what historical operational info is sitting there.

This server lets your AI client handle all the heavy lifting: listing every scenario, checking team memberships by organization ID, getting structural details for one workflow, finding out which connections exist, and pulling the specific logs needed to fix it. You don't gotta jump through multiple dashboards; you just ask your agent what you need, and it pulls the data directly.

## Tools

### get_scenario
Retrieves the full structure and details of a specific Make scenario by ID.

### list_connections
Lists all active API connections tied to your organization's account.

### list_data_stores
Provides a list of internal Make data stores available in your workspace for inspection.

### list_organizations
Lists all distinct organizations or workspaces associated with your Make account credentials.

### list_scenario_logs
Pulls detailed execution logs for a scenario, helping you pinpoint exactly where an automation failed.

### list_scenarios
Lists all managed scenarios within the current organizational scope.

### list_teams
Retrieves a list of teams belonging to a specified organization ID.

## Prompt Examples

**Prompt:** 
```
List all organizations in my Make account
```

**Response:** 
```
I've retrieved your Make organizations: 'Personal Workspace' (ID: 12345) and 'Corporate Ops' (ID: 67890). Which one would you like to list scenarios for?
```

**Prompt:** 
```
Show me the execution logs for scenario ID 'scen-98765'
```

**Response:** 
```
Retrieving logs for 'Shopify-to-Slack-Sync'… The last run was 5 minutes ago and completed successfully. However, 2 hours ago there was a '401 Unauthorized' error on the Slack module. Would you like to see the detailed error payload?
```

**Prompt:** 
```
List all active connections in organization '12345'
```

**Response:** 
```
I've identified 5 active connections in organization 12345: Google Sheets (Verified), Slack (Verified), Airtable (Expired), HubSpot (Verified), and Mailchimp (Verified). You might want to re-authenticate your Airtable connection.
```

## Capabilities

### Audit all workflows
List every scenario in an organization or retrieve the specific structural details of a single workflow.

### Track execution history and errors
Pull detailed logs for any Make scenario run to find out why it failed, what data was processed, and when the error occurred.

### Map organizational connections
List all active API connections (like Google Sheets or Slack) linked to your organization for a security audit.

### Inspect persistent data stores
View and list the internal key-value data tables that store information used across multiple workflows.

### Identify required IDs
Retrieve necessary organization or team identifiers needed for complex API calls or deep audits.

## Use Cases

### The Ops Manager needs to check reliability
A critical lead-to-CRM workflow broke overnight. Instead of logging into the Make dashboard, you ask your agent: 'Show me the logs for the Lead Sync scenario.' Your agent runs `list_scenario_logs`, pulling up an error message indicating a required field was missing from the source data, solving the issue in seconds.

### The Developer needs to debug persistent state
A reporting workflow keeps failing because it's using stale user IDs. You ask your agent to list all data stores. The agent runs `list_data_stores`, and you find the key-value table containing the correct, up-to-date ID needed for debugging.

### The Architect needs a full inventory
You need to know every external system connected to your company's automation. You ask: 'List all connections.' The agent runs `list_connections`, providing a clean, categorized list of active and expired integrations for security review.

### The Onboarding Specialist needs scope mapping
You need to understand the organizational structure before building anything. You ask your agent to run `list_organizations` followed by `list_teams`. This gives you a complete, verifiable map of all available teams and departments in Make.

## Benefits

- Stop hunting for errors. Use `list_scenario_logs` to pull detailed run history instantly, showing the error payload and exact failure module. You don't have to guess where the break happened.
- Get a full picture of your infrastructure with one prompt. `list_organizations` shows you every workspace you own, while `list_teams` maps out who owns what within those workspaces.
- Audit data integrity easily. Running `list_data_stores` lets you inspect key-value tables that keep persistent data—the kind of data developers live and die by—without touching a database client.
- Verify connections fast. `list_connections` checks your API integrations (like HubSpot or Slack) across the whole account, telling you immediately which ones might be expired or need re-authentication.
- Understand complex workflows deeply. Using `get_scenario` lets you retrieve the full design structure of a scenario—seeing all module mappings and trigger settings in plain text.

## How It Works

The bottom line is that you manage complex Make automation infrastructure using chat commands, not dashboard clicks.

1. Subscribe to the server and input your Make API Token and Zone.
2. Ask your AI agent a question about your automation (e.g., 'List all scenarios in my corporate workspace').
3. The server calls the relevant tool, retrieves structured data, and formats it back for your client.

## Frequently Asked Questions

**How do I check my Make data stores using list_data_stores?**
The agent runs `list_data_stores` to give you a full inventory of persistent key-value tables. This lets you see what historical or shared data your workflows are pulling from.

**What is the difference between list_scenarios and get_scenario?**
`list_scenarios` gives you a simple index—a list of every scenario name. `get_scenario` provides deep details on one specific workflow, including its entire internal design structure.

**Can I use list_connections to check my API credentials?**
Yes. Running `list_connections` is your primary audit tool for external services. It shows if your Google Sheets or Slack connections are verified, expired, or active.

**How do I find out which teams exist in my Make account?**
You first use `list_organizations` to select the right workspace ID, and then you run `list_teams` with that ID. This maps your organizational scope.

**If my automation fails, how do I use `list_scenario_logs` to debug errors?**
It retrieves a full history of runs, allowing you to pinpoint exactly when and why the workflow failed. You'll see successful completion times right alongside detailed error messages from specific modules.

**I need to know which workspaces I have access to; how do I use `list_organizations`?**
Running `list_organizations` gives you a definitive list of every organization ID and name linked to your account. This helps your agent determine the correct scope before running any other operations.

**How can I check my API credentials or see which services are connected using `list_connections`?**
This tool lists all external connections tied to your organization, showing their current status. It's critical for checking if a connection is verified, expired, or needs re-authentication.

**What's the difference between `list_scenarios` and using `get_scenario`?**
`list_scenarios` gives you names and IDs for all workflows. However, `get_scenario` pulls the complete design structure, including every module mapping and trigger setting for deep inspection.

**Can I see the modules and filters used in a Make scenario through my agent?**
Yes. Use the `get_scenario` tool with a specific Scenario ID. Your agent will retrieve the complete design structure, exposing the modules, mapping variables, and any logic filters configured in the flow.

**How do I find out why a Make scenario failed recently?**
The `list_scenario_logs` tool allows your agent to extract the execution history for a given scenario. You'll be able to see exactly when the failure occurred and retrieve the error message to assist with debugging.

**Can my agent list all active connections in my Make organization?**
Absolutely. Use the `list_connections` tool with your Organization ID. Your agent will report all configured auth hooks, helping you audit which services are currently linked to your Make account.