Integrations10 min read

MCP Integration Guide: Zapier — Connect AI Agents to 7,000+ Apps

Complete guide to integrating MCP servers with Zapier. Learn how to trigger Zaps from AI assistants, expose Zapier actions as MCP tools, and automate workflows across 7,000+ apps using natural language.

By MyMCPTools Team·

Zapier connects 7,000+ apps through a no-code automation platform trusted by millions of teams. When you pair Zapier with Model Context Protocol, your AI assistant gains access to this entire ecosystem — able to trigger any Zap, query data from connected apps, and execute multi-step automations through natural language commands.

This guide covers two approaches: using Zapier's Natural Language Actions (NLA) API as an MCP server, and building a custom MCP server that calls Zapier webhooks directly.

Approach 1: Zapier NLA MCP Server

Zapier's Natural Language Actions API is purpose-built for AI integration. It exposes your configured Zapier actions as an API endpoint designed for LLM tool use — making it the fastest path to MCP + Zapier integration.

Step 1: Enable Zapier AI Actions

  1. Go to zapier.com/l/natural-language-actions and sign in
  2. Click Add an AI Action
  3. Search for and configure actions you want available to AI (e.g., "Send Slack message", "Create Trello card", "Add row to Google Sheet")
  4. For each action, configure the default values and mark which fields should be AI-guessable
  5. Copy your NLA API Key from the Settings page

Step 2: Install and Configure the NLA MCP Server

npm install -g zapier-nla-mcp

Or use it directly with npx in your Claude Desktop config:

// claude_desktop_config.json
{
  "mcpServers": {
    "zapier-nla": {
      "command": "npx",
      "args": ["-y", "zapier-nla-mcp"],
      "env": {
        "ZAPIER_NLA_API_KEY": "your-nla-api-key"
      }
    }
  }
}

The NLA MCP server automatically discovers all actions you've enabled in the Zapier AI Actions interface and exposes them as MCP tools.

Step 3: Test Your Integration

Open Claude Desktop and try natural language commands:

  • "Send a Slack message to #general: deployment complete"
  • "Create a Trello card in the Backlog list: 'Review Q3 metrics'"
  • "Add a row to my leads spreadsheet: name=John Smith, email=john@example.com, source=website"

Claude will identify the appropriate Zapier action, fill in the parameters from your request, and execute the action through the NLA API.

Approach 2: Custom Webhook-Based MCP Server

For more control — custom error handling, input validation, or complex multi-step logic — build an MCP server that calls Zapier webhooks directly.

Step 1: Create Webhook-Triggered Zaps

In Zapier, create Zaps with Webhooks by Zapier as the trigger:

  1. New Zap → Trigger: Webhooks by Zapier → Catch Hook
  2. Copy the webhook URL
  3. Add your action steps (Slack, Gmail, HubSpot, etc.)
  4. Turn on the Zap

Step 2: Build the MCP Server

// zapier-mcp-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'

const WEBHOOKS: Record = {
  send_slack_notification: process.env.ZAPIER_WEBHOOK_SLACK!,
  create_hubspot_contact: process.env.ZAPIER_WEBHOOK_HUBSPOT!,
  send_email: process.env.ZAPIER_WEBHOOK_EMAIL!,
  create_calendar_event: process.env.ZAPIER_WEBHOOK_CALENDAR!,
}

async function triggerZap(webhookUrl: string, data: object) {
  const response = await fetch(webhookUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(data),
  })
  if (!response.ok) throw new Error(`Zapier webhook failed: ${response.status}`)
  return { success: true, status: response.status }
}

const server = new Server(
  { name: 'zapier-automations', version: '1.0.0' },
  { capabilities: { tools: {} } }
)

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'send_slack_notification',
      description: 'Send a Slack notification via Zapier',
      inputSchema: {
        type: 'object',
        properties: {
          channel: { type: 'string', description: 'Slack channel (without #)' },
          message: { type: 'string', description: 'Message to send' },
          mention: { type: 'string', description: 'Optional user to mention' }
        },
        required: ['channel', 'message']
      }
    },
    {
      name: 'create_hubspot_contact',
      description: 'Create a new contact in HubSpot CRM via Zapier',
      inputSchema: {
        type: 'object',
        properties: {
          firstname: { type: 'string' },
          lastname: { type: 'string' },
          email: { type: 'string' },
          company: { type: 'string' },
          phone: { type: 'string' },
          notes: { type: 'string' }
        },
        required: ['email']
      }
    },
    {
      name: 'send_email',
      description: 'Send an email via Zapier (Gmail/Outlook)',
      inputSchema: {
        type: 'object',
        properties: {
          to: { type: 'string', description: 'Recipient email address' },
          subject: { type: 'string' },
          body: { type: 'string', description: 'Email body (plain text or HTML)' }
        },
        required: ['to', 'subject', 'body']
      }
    },
    {
      name: 'create_calendar_event',
      description: 'Create a Google Calendar event via Zapier',
      inputSchema: {
        type: 'object',
        properties: {
          title: { type: 'string' },
          start_time: { type: 'string', description: 'ISO 8601 datetime' },
          end_time: { type: 'string', description: 'ISO 8601 datetime' },
          description: { type: 'string' },
          attendees: { type: 'string', description: 'Comma-separated email addresses' }
        },
        required: ['title', 'start_time', 'end_time']
      }
    }
  ]
}))

server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params
  const webhookUrl = WEBHOOKS[name]
  if (!webhookUrl) throw new Error(`Unknown tool: ${name}`)

  const result = await triggerZap(webhookUrl, args)
  return {
    content: [{ type: 'text', text: `Action completed: ${JSON.stringify(result)}` }]
  }
})

const transport = new StdioServerTransport()
await server.connect(transport)

Step 3: Configure Environment Variables

// claude_desktop_config.json
{
  "mcpServers": {
    "zapier-automations": {
      "command": "node",
      "args": ["/path/to/zapier-mcp-server.js"],
      "env": {
        "ZAPIER_WEBHOOK_SLACK": "https://hooks.zapier.com/hooks/catch/123/abc/",
        "ZAPIER_WEBHOOK_HUBSPOT": "https://hooks.zapier.com/hooks/catch/123/def/",
        "ZAPIER_WEBHOOK_EMAIL": "https://hooks.zapier.com/hooks/catch/123/ghi/",
        "ZAPIER_WEBHOOK_CALENDAR": "https://hooks.zapier.com/hooks/catch/123/jkl/"
      }
    }
  }
}

Comparing NLA vs. Webhooks

Zapier NLA (Natural Language Actions) is best when:

  • You want fast setup with minimal code
  • You trust Zapier's AI to infer parameters from natural language
  • You want to expose many actions without writing individual tool schemas
  • You're prototyping or building personal automations

Webhook-based MCP server is best when:

  • You need strict input validation before triggering Zaps
  • You want custom error messages and retry logic
  • You need to transform data between AI output and Zapier input
  • You're building for production or enterprise deployments

High-Value Zapier + MCP Use Cases

Sales workflow automation: Claude researches a prospect → creates HubSpot contact → schedules follow-up task → drafts and queues outreach email — all triggered by a single "research and prep outreach for john@company.com" command.

Content publishing pipeline: "Publish this blog post" triggers Zapier to create a WordPress draft, post a preview to Slack for approval, schedule social shares in Buffer, and add a row to your content tracking sheet.

Support ticket triage: New support email arrives → Zapier triggers Claude analysis via MCP → AI classifies urgency and extracts issue details → creates Zendesk ticket with proper tags → notifies on-call via PagerDuty if P0.

Meeting follow-up: "Send follow-up for today's meeting with Acme Corp" → Claude drafts personalized email → Zapier sends via Gmail → logs sent email in HubSpot → creates follow-up reminder in Asana.

Security Considerations

Webhook URL secrecy: Zapier webhook URLs are effectively shared secrets — anyone with the URL can trigger your Zap. Store them in environment variables, never in code. Rotate them if compromised.

Action scope limiting: In Zapier NLA, only enable the specific actions your AI assistant needs. Avoid enabling high-risk actions (delete operations, financial transactions) unless explicitly required.

Rate limit awareness: Zapier's free plan limits to 100 tasks/month; paid plans vary. Implement rate limiting in your MCP server to prevent AI loops from burning through your Zapier task quota.

Audit trail: Zapier's Zap history logs every execution with input data and timestamps. Review regularly for unexpected or unauthorized triggers.

Explore the Zapier MCP server and browse automation MCP servers in our directory to find tools that work alongside Zapier in your AI workflows.

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

📋

Zapier MCP Server

Zapier MCP is Zapier's official hosted Model Context Protocol server, giving AI assistants natural-language access to the 9,000+ apps in the Zapier ecosystem — Gmail, Slack, HubSpot, Salesforce, Google Sheets, Airtable, and thousands more — without writing custom API integrations for each one. Instead of installing a local binary, you create a server at mcp.zapier.com, pick the tools (Zapier calls them "actions") you want exposed, and connect over Streamable HTTP (SSE is not supported). Setup guides are published for Claude (Web, Desktop, and Code — requires an org owner), ChatGPT (Developer Mode, manual tool refresh required), Cursor, VS Code (via GitHub Copilot Agent mode), Windsurf, and Microsoft Copilot Studio, plus a generic path for any MCP client built with the Python or TypeScript SDK. Authentication is OAuth-based per client; disconnecting a client is a one-click delete of the server in the mcp.zapier.com dashboard, which immediately revokes access. Tool bundles let you group related actions (e.g. "CRM updates" or "team notifications") so the AI only sees relevant tools per context, and usage is billed against your existing Zapier plan's task quota. The official client plugin — which onboards you with guided setup inside Claude Code, Cursor, and GitHub Copilot CLI — lives in the zapier/zapier-mcp repo and ships through the Claude Code, Cursor, and Kiro plugin marketplaces. Typical use: ask Claude to "add this lead to HubSpot and notify #sales on Slack" and Zapier MCP routes both actions through your existing Zap connections.

Auth required📘
📋

Zapier NLA

Execute 50,000+ Zapier actions through natural language. Connect apps, trigger zaps, and automate workflows across the entire Zapier ecosystem using plain English commands.

Local
📋

n8n MCP Server

n8n-MCP gives an AI assistant deep knowledge of n8n rather than a remote control for it: 2,412 nodes (829 core plus 1,583 community, 1,340 of them verified) with 99% property coverage and 66.5% operation coverage, 86% documentation coverage, a library of 2,352 workflow templates, and validators that check a node config or a whole workflow before anything is deployed. Seven documentation tools always load — search_templates, get_template, search_nodes, get_node, validate_node, validate_workflow and tools_documentation — and get_node is deliberately tiered because full node detail costs 3,000-8,000 tokens. Supplying N8N_API_URL and N8N_API_KEY unlocks a further sixteen management tools that create, partially update, validate, autofix, deploy and inspect workflows on your own instance, plus executions, credentials, folders, data tables and health checks; without credentials the server cannot execute anything at all. MCP_MODE=stdio is required for stdio clients, or log output corrupts the JSON-RPC stream; WEBHOOK_SECURITY_MODE=moderate is required when N8N_API_URL points at localhost or host.docker.internal, because the default SSRF gate rejects loopback. Install with npx n8n-mcp, the ghcr.io/czlonkowski/n8n-mcp Docker image, or the maintainer's hosted instance at dashboard.n8n-mcp.com (100 tool calls/day free). This is a community project by Romuald Czlonkowski under MIT, not published by n8n, and it is distinct from n8n's own MCP Server Trigger node, which does the reverse — exposing an n8n workflow as an MCP server over SSE or Streamable HTTP. The project's own headline warning is never to let an AI edit production workflows directly.

Local📘
📋

Make (Integromat)

Turn Make (formerly Integromat) automation scenarios into callable tools for an AI assistant. The server connects to your Make account, finds every scenario set to "On-Demand" scheduling, resolves each scenario's input parameters into described tool arguments, lets the assistant invoke them, and returns the scenario output as structured JSON — so a model can trigger real automations across Make's 1,500+ app integrations and interpret the results. Two ways to run it: the original self-hosted server is the official `@makehq/mcp-server` npm package (repo integromat/make-mcp-server), installed with `npx @makehq/mcp-server` and a Make API key carrying `scenarios:read` and `scenarios:run` scopes. Make now labels that repo "legacy" and recommends its newer cloud-based Make MCP Server — a hosted, token-authenticated endpoint documented at developers.make.com/mcp-server — for most use cases. Note the generic npm package `make-mcp-server` is a separate community project (danishashko/make-mcp), not Make's first-party build; use the `@makehq` scope for the official server.

Local
🌐

Fetch

Web content fetching and conversion for efficient LLM usage. Extract readable content from any URL.

Local
💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
💬

Slack MCP Server

The Slack MCP server (built by Ivan Korotovsky) connects AI assistants like Claude, Cursor, and Windsurf directly to Slack workspaces, enabling conversational access to your team communication channels without requiring workspace admin approval for a bot install. Its standout feature is a "no permission" stealth mode — it authenticates using your own personal Slack session tokens (xoxc/xoxd, or a stored browser session) rather than requiring a Slack App with OAuth scopes, so it works even in locked-down workspaces where you cannot create bots. It also supports full OAuth Bot Token auth and Enterprise/GovSlack deployments for teams that prefer a conventional app install. Tools exposed include reading channel and DM/group-DM history with smart pagination, searching messages across the workspace, posting messages and thread replies, listing channels and users, and adding reactions. Common use cases include automating standups by posting summaries directly to team channels, searching past Slack conversations to surface decisions or context, monitoring specific channels for keywords or alerts, and drafting replies to thread discussions — all from natural-language prompts. Supports both Stdio and SSE transports plus proxy configuration for corporate networks. Install with: `npx slack-mcp-server@latest --transport stdio`. A separate official-style integration exists from Zencoder (@zencoderai/slack-mcp-server) for teams that prefer standard Bot Token OAuth over session-token auth. Compatible with Claude Desktop, Cursor, VS Code, Windsurf, and Cline.

Local📘

📚 More from the Blog