Make.com AI Automation Guide: Using LLMs in Your Scenarios

Make (formerly Integromat) is a visual workflow automation platform with strong AI capabilities. Its OpenAI module, AI Router, and HTTP module for custom LLMs let you build scenarios where AI classifies, summarises, generates, and routes data across 1,700+ app integrations. This guide covers Make’s AI modules, practical automation patterns, and how it compares to n8n for AI-heavy workflows.

Make’s AI Module System

Make’s AI integrations fall into three categories. Native AI modules: the OpenAI module supports chat completions, text completions, embeddings, and image generation. An Anthropic module covers Claude. Both appear in the scenario editor as standard modules, accept dynamic data from previous steps, and return structured outputs the next step can use. The AI Router module: calls an LLM to classify the current data item into one of several categories and routes it to the appropriate path — this brings LLM-driven conditional logic into Make without custom code. HTTP module: for AI services without a native module, the HTTP module makes any REST call — this covers Ollama, Groq, Mistral, and any OpenAI-compatible endpoint.

Building Your First AI Scenario

The simplest Make AI scenario: a Webhook trigger receives text, the OpenAI Chat Completion module processes it, and a subsequent module acts on the response. Add a Webhook trigger to get a URL, connect it to OpenAI > Create a Chat Completion, configure your model and system prompt, then connect the output to Gmail or Slack. Run once to test, then activate. For content generation, an RSS trigger fetches new articles on a schedule, the OpenAI module summarises each in three sentences, a filter checks quality, and a CMS module publishes the result. For document extraction, a Google Drive trigger fires when a file is added, the OpenAI module extracts structured fields (invoice number, amount, vendor) as JSON, and a Sheets module writes the data.

Figure 1 — Make AI automation patterns

Pattern Example Classify & routeSupport tickets classified by AI, routed to correct team channel Generate & publishRSS items summarised by AI, published to CMS Extract & storeInvoice PDFs parsed by AI, structured data written to Airtable

Structured Output: The Critical Prompting Pattern

The most important prompting practice for Make AI scenarios is structured output. Instruct the LLM to respond only in JSON with specific field names, then use Make’s JSON Parse module to extract values reliably. A classification prompt ends with “Respond only with a JSON object: {category: string, confidence: number}. No other text.” This eliminates brittle text parsing and makes scenarios robust to minor LLM response variations. Use Make’s JSON Parse module after the AI module to convert the JSON string into individual mapped values for subsequent steps. For high-stakes scenarios where the LLM might deviate from format, add a Router after the JSON Parse that checks whether required fields are present, and route malformed responses to an error handler.

Using Ollama via the HTTP Module

If Make is self-hosted on the same server as Ollama, the HTTP module reaches it directly. Add an HTTP module with POST method, URL set to your Ollama API endpoint, Content-Type header set to application/json, and the request body as a JSON structure with model and messages fields, stream set to false. Parse the response with Make’s JSON Parse module to extract the generated content. This gives Make access to any Ollama model for zero-cost, private LLM inference. For Make Cloud (not self-hosted), Ollama must be accessible via a public URL — expose it through a reverse proxy with HTTPS and restrict access with an API key passed in a request header.

Make vs n8n for AI Workflows

Make has a more polished UI and lower learning curve, making it better for non-technical users building business automations with cloud LLMs. n8n has a native AI Agent node with a full tool-calling ReAct loop, better Ollama support, is self-hostable for free, and suits developers building complex AI pipelines. For simple LLM-in-the-middle workflows (classify, summarise, extract, generate), Make is excellent. For agentic workflows where the LLM reasons about which actions to take, n8n’s architecture is more capable. Make’s operation-based pricing makes high-volume AI workflows expensive compared to n8n self-hosted with Ollama, which is free per-inference.

Make Pricing for AI Workflows

Make’s free tier includes 1,000 operations per month and up to 2 active scenarios. Each module execution counts as one operation — a five-module AI scenario processes 200 items per month free. Paid plans (Core, Pro, Teams, Enterprise) increase operation limits and execution frequency. For AI workflows where each item passes through 5–10 modules including an OpenAI call, operation counts add up quickly. Calculate your expected monthly volume before committing to a plan. Scenarios calling your own OpenAI API key via the HTTP module are more economical than using Make’s OpenAI module for high volumes, since the operation count is the same but you pay OpenAI directly at API rates rather than through Make’s credit system.

Frequently Asked Questions

Does Make have a free tier?
Yes — 1,000 operations per month and 2 active scenarios. Each module execution in a scenario counts as one operation, limiting free-tier AI scenarios to low-volume use.
Which LLMs does Make support natively?
OpenAI (GPT-4o, GPT-4o-mini), Anthropic (Claude 3.5 Sonnet, Haiku), Google (Gemini via Vertex AI), and Hugging Face have native modules. Any other LLM with a REST API is reachable via the HTTP module.
Can Make run AI scenarios automatically?
Yes. The Schedule trigger runs a scenario at a fixed interval. Most Make AI workflows combine a Schedule trigger (fetch new data) with AI processing and action steps that run fully automatically.

Last updated: October 2026

Error Handling in Make AI Scenarios

AI module calls can fail due to API rate limits, token limits, or unexpected responses. Wrap AI modules in Make’s Error Handler to route failures rather than stopping the scenario. The most useful error routes: on rate limit errors (HTTP 429), use a Sleep module to wait 30–60 seconds then retry; on timeout errors, log the failed item to a Google Sheet for manual review; on parse errors (the LLM returned malformed JSON), route to an alternative prompt that asks for simpler output. The Resume Error Handler lets the scenario continue processing subsequent items even when one fails — critical for batch scenarios processing hundreds of items where a single failure should not block the rest. Setting a maximum number of retries per module (available in the module settings under Advanced) prevents infinite retry loops on persistent errors.

Make for AI Content Pipelines

Make’s strengths shine particularly in content automation pipelines where AI transforms data at each step. A typical content pipeline: a Google Sheets or Airtable trigger fires when a new row is added with a content brief, a Make HTTP module fetches relevant search data or reference material, the OpenAI module drafts the content using the brief and research as context, a second OpenAI call edits and formats the draft, and a CMS module (WordPress, Webflow, Contentful) publishes the result. The scenario runs automatically for each new brief, with human review optionally inserted as a Make form step that pauses execution until someone approves. This pattern makes Make particularly popular for SEO content at scale and for social media content workflows that need consistent output format.

Make is well-suited to the majority of AI automation use cases that businesses actually need: classifying incoming data, generating content from templates, extracting structured information from documents, and enriching records with AI-generated fields. Its visual canvas, strong error handling, and broad integration coverage make it accessible to non-technical users while still offering enough flexibility for developers to build complex multi-step AI pipelines. Start with a simple classification scenario, verify the AI module output format, then gradually add complexity.

Make Scenario Versioning and Testing

Make automatically saves a version history for each scenario. This matters for AI scenarios where prompt changes can have non-obvious downstream effects — a changed prompt may break the JSON output format silently. Before changing a prompt in a live scenario, duplicate it, test the change with representative data using Make’s manual run feature, verify the output format and quality, then apply to production. Use Make’s Blueprint export (JSON) to version-control scenarios in Git alongside other workflow documentation. The comment feature lets you document why specific prompts or routing decisions were made, reducing confusion when revisiting scenarios months later.

Make vs Zapier: Which for AI Automation?

Make gives you more logic per scenario — iterators, aggregators, routers with multiple paths, and error handlers that are more flexible than Zapier’s equivalent. This matters for AI scenarios where you need to process arrays of items, merge results from multiple AI calls, or handle complex conditional routing based on AI output. Zapier is simpler and faster to set up for straightforward automations and has more native app integrations (9,000+ vs Make’s 1,700+). For developers building AI pipelines who are comfortable with Make’s canvas, Make is usually the better choice for complex scenarios. For non-technical team members building their first automation with a simple AI step, Zapier’s guided interface is less intimidating. For either platform, test with a handful of real data items before activating a scenario in production — AI outputs vary, and edge cases appear in real data that never show up in test runs with handpicked examples.

Leave a Comment