Make.com Guide 2025: Visual AI Automation with 2000+ Integrations

What Is Make.com?

Make.com is a no-code/low-code automation platform built around a visual scenario canvas. Where tools like Zapier present a linear list of steps, Make shows you the entire flow as a diagram — modules (app actions) connected by lines, with routers splitting the flow into branches and iterators looping over arrays. This visual approach makes complex logic far easier to build and debug.

Key concepts: a scenario is a workflow (equivalent to a Zap in Zapier or a flow in Power Automate). Each scenario has a trigger module — the event that starts the run — followed by one or more action modules. Every module execution consumes one operation from your monthly quota.

• 2000+ app integrations — Google Workspace, Slack, Notion, Shopify, Airtable, HubSpot, Stripe, and all major AI providers
• Native branching and loops — Router, Iterator, Aggregator are first-class modules, not hacks
• Error handling — dedicated error handler routes, retry logic, and rollback actions
• Data transformation — built-in functions for string manipulation, date parsing, math, JSON parsing, and array operations
• Free tier — 1000 operations/month, unlimited scenarios, 15-minute minimum scheduling interval

Make vs Zapier

Both platforms connect apps without code, but they target different complexity levels. Make handles branching, loops, and data transformation natively; Zapier optimizes for quick two-step automations with a gentler learning curve.

For AI workflows that classify, route, or process lists of items, Make's native Iterator and Router make it the stronger choice. For simple two-step automations with little logic, Zapier's setup speed wins.

AI Modules in Make.com

Make ships native modules for every major AI provider, so you don't need an HTTP module for the common cases:

• OpenAI — Chat completions (GPT-4o, GPT-4 Turbo), image generation (DALL-E 3), audio transcription (Whisper), embeddings, and fine-tune management. The completions module accepts a system prompt, message history array, and model parameters.
• Anthropic (Claude) — Claude API completions via the native Anthropic module. Supports claude-3-5-sonnet and claude-3-opus with system prompt, temperature, and max tokens.
• Google AI (Gemini) — Gemini Pro and Gemini Flash completions, multimodal inputs (image + text), and Google AI Studio integrations.
• Perplexity — Chat completions with built-in web search, useful for scenarios that need current information without a separate search step.
• HuggingFace — Inference API calls for classification, summarization, translation, and custom model endpoints hosted on HuggingFace Hub.

Each module stores your API key as a Make connection — you configure it once and reuse it across all scenarios. Make encrypts credentials at rest and never exposes them in scenario exports.

Building an AI Scenario Step by Step

Here is a practical walkthrough: classify an inbound email with GPT-4o and route it to the right Slack channel. In Make's scenario editor, you would see five modules connected left-to-right on the canvas.

1. Trigger — Gmail: Watch Emails. Set the folder to Inbox, mark as read on trigger, and set the schedule interval (minimum 15 min on free tier, 1 min on Core+). The module outputs the sender, subject, body, and attachment list.
2. OpenAI: Create a Completion. System prompt: "Classify the following customer email into exactly one of: billing, technical-support, sales, other. Reply with just the category word." User message: map the email subject and body from the previous module. Set model to gpt-4o-mini (fast and cheap for classification), temperature to 0.
3. Router. The Router module splits the flow into parallel branches. Add four branches. Each branch has a filter condition: the OpenAI response text equals "billing", "technical-support", "sales", or "other". Only the matching branch executes.
4. Slack: Create a Message (one per branch). Map the channel ID to the appropriate team channel. In the message text, use Make's template syntax to embed the sender name, subject, and a link to the email thread.
5. Gmail: Mark as Read / Add Label (optional). After routing, mark the email with a "Routed" label so your inbox stays clean.

This scenario uses 5 operations per email: trigger watch + OpenAI completion + router + Slack message + Gmail label. At 1000 emails/month on the free tier, you'd consume 5000 operations — requiring at least the Core plan.

{
  "from": "[email protected]",
  "subject": "Invoice #1042 not received",
  "body": "Hi, I placed an order last week but never got the invoice...",
  "timestamp": "2025-06-19T10:23:00Z"
}

Advanced Features for AI Workflows

Four Make-specific modules unlock patterns that are impossible or cumbersome in linear automation tools:

• Iterator — takes an array from the previous module and emits each item as a separate bundle. This lets you feed a list of 50 product SKUs into an OpenAI module one by one, with the AI generating a unique description per item. Without an Iterator you would need a loop workaround or a code step.
• Aggregator — the counterpart to Iterator. After the Iterator processes each item through AI, an Aggregator collects all the AI outputs back into a single array or text block. Common pattern: Iterator → OpenAI → Array Aggregator → Google Sheets bulk update.
• Router — splits execution into multiple parallel branches based on filter conditions. Ideal for AI classification outputs: if GPT says "urgent", notify PagerDuty; if "normal", create a Jira ticket; if "spam", archive and stop. Each branch is independent and only the matching one executes.
• Data Store — Make's built-in key-value storage, similar to a simple database. Use it to persist state between scenario runs: store processed email IDs to prevent duplicates, cache AI responses for repeated inputs, or track counters. Data Stores are scoped to your Make organization and accessible from any scenario.

Webhook Triggers

Make generates a unique HTTPS webhook URL for each scenario. When an external system POSTs to that URL, the scenario starts immediately — no polling delay. This makes webhooks far faster than scheduled triggers for real-time workflows.

To set up a webhook trigger: add a Webhooks: Custom Webhook module as the first module, copy the generated URL, and paste it into your external system (GitHub Actions, Stripe events, your own backend). Make will automatically detect the JSON schema from the first test payload and map the fields for downstream modules.

await fetch('https://hook.eu1.make.com/abc123youruniquetoken', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    event: 'new_support_ticket',
    ticket_id: 'T-9912',
    user_email: '[email protected]',
    message: 'My dashboard is not loading'
  })
});

Make can also respond to the webhook caller with data — enable Custom Webhook Response to return a JSON body and HTTP status code. This lets you use Make as a lightweight API gateway: receive a request, run AI processing, return the result synchronously to the caller.

Common AI Automation Templates

These four patterns cover the majority of AI automation use cases teams build in Make:

HTTP Module: Call Any AI API

When Make does not have a native module for an AI provider, the HTTP: Make a Request module covers any REST API. This is the escape hatch for LiteLLM proxy servers, Together AI, Groq, Fireworks, or Anthropic's API when you need a specific endpoint not in the native module.

URL: https://api.anthropic.com/v1/messages
Method: POST
Headers:
  x-api-key: {{your_anthropic_key}}
  anthropic-version: 2023-06-01
  Content-Type: application/json

Body (raw JSON):
{
  "model": "claude-3-5-sonnet-20241022",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "{{1.email_body}}"
    }
  ]
}

The {{1.email_body}} syntax references the output of module 1 (the trigger). Make's HTTP module also supports OAuth 2.0 connections, custom certificate verification, and multipart form data for file uploads — making it viable even for complex authenticated endpoints.

Make.com Pricing

Make bills by operations — each module execution in a scenario run. A 5-module scenario running 1000 times per month consumes 5000 operations.

Pro adds full execution history, high-priority processing, and advanced scenario scheduling. Teams adds multi-user access with shared connections and scenario ownership. Additional operations can be purchased as add-ons on any paid plan. All paid plans allow webhook triggers to run instantly (not on an interval).