Make.com Tutorial for Beginners: Your First AI-Powered Workflow

TL;DR

Make.com (formerly Integromat) is a visual workflow automation platform that lets you connect apps, APIs, and AI services without writing code. In this tutorial, you’ll build your first AI-powered workflow that monitors Gmail for customer inquiries, uses OpenAI’s GPT-4 to generate personalized responses, and saves conversation summaries to Google Sheets.

What you’ll learn: Connect Gmail and OpenAI API triggers, design multi-step scenarios with conditional logic, handle API responses, and implement error handling. The complete workflow takes 15-20 minutes to build and processes emails automatically every 5 minutes.

Prerequisites: A free Make.com account (1,000 operations/month), Gmail account, and OpenAI API key ($5 credit recommended). No coding experience required, though basic understanding of API concepts helps.

Key workflow components:

Gmail trigger watches for new emails with specific labels
OpenAI module sends email content with a prompt template to GPT-4
Router directs responses based on sentiment analysis
Google Sheets logs all interactions with timestamps

AI integration approach: You’ll use Make.com’s HTTP module to call OpenAI’s Chat Completions API with a structured prompt:

{
  "model": "gpt-4",
  "messages": [
    {"role": "system", "content": "You are a helpful customer service assistant."},
    {"role": "user", "content": "{{email.body}}"}
  ],
  "temperature": 0.7
}

⚠️ Caution: AI models can hallucinate information or generate inappropriate responses. Always implement human review for customer-facing communications. Never auto-execute system commands or database operations based solely on AI output without validation steps.

Expected outcome: A functioning automation that drafts email responses in 30-60 seconds, reducing manual response time by 80%. You’ll understand Make.com’s visual builder, data mapping between modules, and safe AI integration patterns applicable to Slack notifications, CRM updates, and content generation workflows.

What is Make.com and Why Use It for AI Automation

Make.com (formerly Integromat) is a visual automation platform that connects apps, services, and AI models without requiring extensive coding knowledge. Unlike traditional automation tools, Make.com uses a scenario-based approach where you build workflows by connecting modules on an intuitive canvas, making it ideal for creating sophisticated AI-powered automations.

Make.com stands out for AI workflows because of its native integrations with OpenAI, Anthropic Claude, Google AI, and hundreds of other services. You can chain together API calls, data transformations, and conditional logic in a single visual workflow. For example, you might connect Gmail → OpenAI GPT-4 → Slack → Google Sheets in one scenario that automatically categorizes support emails, generates responses, notifies your team, and logs everything.

The platform offers several advantages for AI automation:

Generous free tier: 1,000 operations per month lets you experiment with AI workflows before committing to paid plans.

Built-in error handling: Unlike Zapier’s linear approach, Make.com lets you add error handlers and fallback routes when AI APIs fail or return unexpected results.

Data transformation tools: Built-in functions for parsing JSON, manipulating text, and formatting data mean you can clean AI outputs before sending them to downstream systems.

Real-time execution: Most scenarios run instantly rather than on polling intervals, crucial for time-sensitive AI applications like chatbots or alert systems.

⚠️ Caution: When using AI to generate system commands or infrastructure code (Terraform, Ansible playbooks, kubectl commands), always validate outputs in a staging environment first. AI models can hallucinate syntactically correct but functionally dangerous commands. Never pipe AI-generated bash or PowerShell scripts directly to production systems without human review.

Make.com’s visual debugging tools let you inspect each step’s input and output, essential when troubleshooting complex AI workflows where prompt engineering matters.

Understanding Make.com Core Concepts: Scenarios, Modules, and Routes

Before building your first workflow, you need to understand Make.com’s three fundamental building blocks that power every automation.

A scenario is Make.com’s term for a complete workflow. Think of it as a flowchart that executes automatically when triggered. For example, a scenario might monitor your Gmail inbox, extract invoice data using OpenAI’s GPT-4, then create records in Airtable. Scenarios run on schedules (every 15 minutes) or instantly via webhooks.

Modules: Individual Action Blocks

Modules are the individual steps within your scenario. Each module performs one specific action—like “Watch Gmail Emails,” “HTTP Request to OpenAI API,” or “Create Airtable Record.” Make.com offers 1,500+ pre-built modules for tools like Slack, Google Sheets, PostgreSQL, and AWS S3.

Here’s how you’d structure an AI-powered module calling Claude:

{
  "url": "https://api.anthropic.com/v1/messages",
  "method": "POST",
  "headers": {
    "x-api-key": "{{anthropic_api_key}}",
    "anthropic-version": "2023-06-01"
  },
  "body": {
    "model": "claude-3-5-sonnet-20241022",
    "messages": [{"role": "user", "content": "Extract invoice number from: {{email.body}}"}]
  }
}

⚠️ Caution: When using AI to generate system commands (bash scripts, SQL queries, Terraform configs), always validate outputs before execution. AI models can hallucinate non-existent flags or dangerous commands. Never pipe AI-generated bash directly to sudo or production databases.

Routes: Conditional Logic Paths

Routes let you create if/then branches in your workflow. After an AI module analyzes sentiment, you might route positive feedback to Slack and negative feedback to your ticketing system. Routes use filters with conditions like “if AI confidence score > 0.85” or “if extracted amount > $1000.”

This modular architecture makes Make.com incredibly flexible for combining AI APIs with traditional business tools.

Connecting Your First AI Service: OpenAI Integration Setup

Now that you’ve created your Make.com account, let’s connect OpenAI to power your first AI workflow. This integration will enable you to use GPT-4 for text generation, data analysis, and intelligent automation.

Navigate to platform.openai.com/api-keys and create a new API key. Copy it immediately—you won’t see it again. Store it securely in a password manager like 1Password or Bitwarden.

Adding OpenAI to Make.com

In your Make.com scenario, click the + button and search for “OpenAI.” Select the Create a Completion module (for GPT-4 or GPT-3.5-turbo models).

When prompted, click Add next to the Connection field. Paste your API key and name the connection “OpenAI Production” or similar. Click Save.

Configuring Your First AI Module

Select your model—gpt-4o offers the best balance of speed and intelligence in 2026. For the prompt, try this practical example:

{
  "role": "user",
  "content": "Analyze this server log and identify potential security issues: {{1.logData}}"
}

The {{1.logData}} syntax references data from the previous module in your workflow.

⚠️ Critical Warning: Never execute AI-generated system commands without manual review. AI models can hallucinate dangerous commands like rm -rf / or incorrect Terraform configurations that could destroy infrastructure. Always validate outputs, especially for:

Bash/PowerShell scripts
Ansible playbooks
Terraform/CloudFormation templates
Database queries
Kubernetes manifests

Testing Your Connection

Click Run Once at the bottom of the module. If successful, you’ll see the AI response in the output panel. Common errors include invalid API keys or insufficient credits—check your OpenAI billing dashboard if requests fail.

Building Your First Workflow: Email-to-Summary Automation

Now let’s build a practical workflow that monitors your Gmail inbox and uses AI to summarize important emails. This automation will check for new emails every 15 minutes, send them to OpenAI’s GPT-4 for summarization, and post the summary to Slack.

Click the + button in Make.com’s canvas and search for “Gmail.” Select Watch Emails as your trigger module. Connect your Gmail account and configure these settings:

Folder: INBOX
Criteria: Only unread emails
Maximum number of results: 5

This ensures you’re only processing new, unread messages without overwhelming your AI quota.

Configuring the OpenAI Module

Add a new module by clicking the + after Gmail. Search for “OpenAI” and select Create a Completion. You’ll need an OpenAI API key from platform.openai.com.

Configure the prompt template:

model: gpt-4-turbo
prompt: |
  Summarize this email in 2-3 bullet points focusing on action items:
  
  From: {{1.from}}
  Subject: {{1.subject}}
  Body: {{1.textPlain}}
  
  Format as markdown bullets.
max_tokens: 150
temperature: 0.3

The {{1.from}} syntax references data from module 1 (Gmail). Lower temperature (0.3) reduces creative variation for consistent summaries.

Sending Results to Slack

Add a Slack > Create a Message module. Select your workspace and channel, then format the message:

📧 *Email Summary*
From: {{1.from}}
Subject: {{1.subject}}

{{2.choices[].message.content}}

[View Email]({{1.link}})

⚠️ Caution: AI summaries may miss critical details or misinterpret technical content. Always review summaries of legal, financial, or security-related emails manually before taking action.

Click Run Once to test your workflow with real data. Make.com will show you the data flowing through each module, making debugging straightforward.

Adding Intelligence: Data Transformation and AI Prompt Engineering

Now that your workflow is capturing data, you need to transform it into actionable insights. Make.com’s built-in tools and AI modules turn raw information into intelligent automation.

Use Make.com’s Set Variable and Text Parser modules to clean and structure data before sending it to AI models. For example, extract email addresses from form submissions or parse JSON responses from APIs.

// Example: Clean and format user input
const cleanedText = input.message
  .toLowerCase()
  .trim()
  .replace(/[^\w\s]/gi, '');
return cleanedText;

Integrating AI Models

Add the OpenAI or Anthropic Claude module to your workflow. Connect it after your trigger and data transformation steps. In the module settings, craft prompts that include dynamic variables from previous steps.

# Example prompt template for customer support automation
system: "You are a technical support assistant for a SaaS platform."
user: "Analyze this support ticket and categorize it:
       Subject: {{1.subject}}
       Message: {{1.message}}
       
       Return JSON with: category, priority, suggested_response"

The AI response becomes available as output data you can route to Slack, email, or your CRM.

Prompt Engineering for Workflows

Structure prompts with clear instructions and expected output formats. Request JSON responses when you need to parse results programmatically:

{
  "category": "billing",
  "priority": "high",
  "suggested_response": "Contact our billing team at..."
}

⚠️ Critical Safety Note: If your workflow generates system commands or infrastructure code (Terraform, Ansible playbooks, kubectl commands), always add a human approval step before execution. AI models can hallucinate invalid syntax or destructive commands. Use Make.com’s Webhook module to send commands to a Slack channel for manual review before running them on production systems.

Test AI outputs thoroughly in development environments, especially when automating DevOps tasks with tools like Prometheus alerts or Docker deployments.

Step-by-Step Setup: Creating an AI Content Classifier Workflow

In this tutorial, you’ll build a workflow that automatically classifies incoming customer emails and routes them to the appropriate department using OpenAI’s GPT-4.

Log into Make.com and click “Create a new scenario.” Search for and add the Gmail module as your trigger. Select “Watch emails” and authenticate your Google account. Configure the filter to monitor your support inbox folder.

Adding the AI Classification Module

Click the plus icon to add a new module. Search for OpenAI and select “Create a completion.” You’ll need an OpenAI API key from platform.openai.com.

Configure the module with these settings:

{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "Classify this email into one of these categories: billing, technical_support, sales, general_inquiry. Respond with only the category name."
    },
    {
      "role": "user",
      "content": "{{1.subject}} - {{1.textPlain}}"
    }
  ],
  "temperature": 0.3
}

The {{1.subject}} and {{1.textPlain}} variables reference data from your Gmail trigger module.

Routing Based on Classification

Add a Router module after OpenAI. Create four routes, each with a filter checking if the AI response contains your category keywords. For each route, add a Gmail “Send an email” module or Slack “Create a message” module to notify the relevant team.

⚠️ Important: Always test your workflow with sample emails first. AI models can occasionally misclassify edge cases or produce unexpected outputs. Set up a fallback route that catches unclassified emails and sends them to a human reviewer.

Enable your scenario and monitor the execution history for the first 24 hours to ensure accurate classifications before relying on it for production traffic.

TL;DR#

What is Make.com and Why Use It for AI Automation#

Understanding Make.com Core Concepts: Scenarios, Modules, and Routes#

Modules: Individual Action Blocks#

Routes: Conditional Logic Paths#

Connecting Your First AI Service: OpenAI Integration Setup#

Adding OpenAI to Make.com#

Configuring Your First AI Module#

Testing Your Connection#

Building Your First Workflow: Email-to-Summary Automation#

Configuring the OpenAI Module#

Sending Results to Slack#

Adding Intelligence: Data Transformation and AI Prompt Engineering#

Integrating AI Models#

Prompt Engineering for Workflows#

Step-by-Step Setup: Creating an AI Content Classifier Workflow#

Adding the AI Classification Module#

Routing Based on Classification#