AI Prompts for Make.com Automation Workflows

AI prompts for Make.com automation are structured system and user instructions designed to process, extract, categorize, or generate data within automated scenarios. By configuring modules like OpenAI, Anthropic, or custom LLM endpoints with deterministic prompts, automators can turn raw, unstructured text—such as emails, support tickets, and form responses—into reliable, structured data feeds. This capability allows Make.com to make intelligent routing decisions and perform complex actions without human intervention.

The Role of AI Prompts in Make.com Workflows

Visual automation platforms like Make.com rely on clear logic, predictable data structures, and consistent dynamic variables. While standard modules handle structured API data effortlessly, business workflows frequently encounter unstructured inputs: free-text email inquiries, customer support logs, voice transcripts, and PDF documents.

Integrating Large Language Model (LLM) modules into Make.com bridges the gap between unstructured human communication and strict computer logic. High-performing AI prompts serve as data transformers. When crafted correctly, an AI prompt acts as an automated parser, sentiment analyzer, content summarizer, or decision logic router inside your scenarios.

Using optimized AI prompts inside Make.com enables you to:

• Parse Unstructured Inputs: Extract key entities (names, email addresses, order IDs, budget figures) from unstructured text directly into Make.com mapping variables.
• Normalize Data Formats: Convert messy dates, ambiguous responses, or variant address inputs into standardized database records.
• Route Logic Dynamically: Categorize inbound requests by intent, sentiment, or priority so Make.com filters and routers can send data to the correct branch.
• Automate Content Generation: Draft personalized email replies, generate social media updates, or build Slack digest summaries tailored to team specifications.

Core Concepts for Designing Automation-Ready Prompts

Prompts meant for conversational chatbots like ChatGPT differ significantly from prompts designed for background workflow automation. Chatbots encourage conversational nuance, whereas automated workflows require zero conversational filler, absolute structural consistency, and predictable schema outputs.

1. Separate System Role and User Role Instructions

Most AI integration modules in Make.com (such as OpenAI’s “Create a Completion” or “Create a Response” modules) allow you to specify distinct system and user messages. Use the System Role to establish behavioral boundaries, output rules, and fallback protocols. Use the User Role to pass the actual dynamic content mapped from previous Make.com scenario modules.

2. Enforce Strict JSON Schema Outputs

Never request plain paragraph text from an AI module if downstream Make.com modules need to read specific values. Always instruct the model to return a raw JSON object. Pair this instruction with Make.com’s Parse JSON module, or turn on native JSON mode within the LLM module configuration settings, allowing you to easily map isolated keys (like lead_score or action_required) into subsequent modules.

3. Manage Temperature Settings

Temperature controls randomness in LLM output generation. For data extraction, classification, and logical operations inside Make.com, set the module temperature between 0.0 and 0.2 to maximize deterministic, repeatable outputs. Reserve higher settings (0.7 to 0.9) strictly for creative copy generation tasks.

Copy-and-Use AI Prompt Templates for Make.com

Below are production-ready prompt templates organized by common Make.com automation use cases. Copy these templates directly into your OpenAI, Anthropic, or HTTP modules in Make.com, replacing the bracketed variables with mapped values from your scenario modules.

1. Inbound Lead Categorization and Data Extraction

Use this prompt when processing incoming contact form submissions or inbound sales emails. It extracts lead details and categorizes lead quality for CRM tools like HubSpot or Salesforce.

[SYSTEM ROLE]
You are a precise data extraction API integrated into a automated CRM workflow. Your task is to analyze the raw lead text provided by the user and extract key details into a valid JSON object.

RULES:
1. Return ONLY a valid JSON object. Do not include markdown code fences (e.g., ```json), conversational text, or explanations.
2. If a field cannot be determined, set its value to null.
3. Classify lead_quality as "High", "Medium", or "Low" based on budget presence, explicit need, and company size.

JSON SCHEMA:
{
  "first_name": string or null,
  "last_name": string or null,
  "company_name": string or null,
  "email": string or null,
  "phone": string or null,
  "budget_mentioned": string or null,
  "lead_quality": "High" | "Medium" | "Low",
  "summary": "Concise 1-sentence summary of request"
}

[USER ROLE]
Analyze the following contact submission:
{{1.submission_text}}

2. Support Ticket Sentiment Analysis and Priority Routing

Use this prompt to categorize incoming support tickets, determine user sentiment, and provide a suggested resolution action before routing the ticket to Zendesk, Freshdesk, or Slack.

[SYSTEM ROLE]
You are a customer support intake router. Analyze the support ticket and determine sentiment, core intent, priority level, and assigned department.

RULES:
1. Return strictly raw JSON.
2. priority must be one of: "URGENT", "HIGH", "MEDIUM", "LOW".
3. sentiment must be one of: "POSITIVE", "NEUTRAL", "NEGATIVE", "ANGRY".
4. department must be one of: "BILLING", "TECHNICAL", "SALES", "GENERAL".

JSON SCHEMA:
{
  "sentiment": string,
  "priority": string,
  "department": string,
  "is_churn_risk": boolean,
  "suggested_action": string
}

[USER ROLE]
Support Ticket Content:
Subject: {{1.subject}}
Body: {{1.body_text}}

3. Unstructured Text and Invoice Document Parsing

When extracting text from receipts, invoices, or contract PDFs via OCR modules, pass the raw text to this prompt to extract operational data cleanly.

[SYSTEM ROLE]
You are an automated accounting data extraction module. Extract structural financial data from the unstructured invoice OCR text.

RULES:
1. Output valid JSON only.
2. Format all monetary values as floating-point numbers without currency symbols.
3. Format dates strictly as ISO-8601 (YYYY-MM-DD).

JSON SCHEMA:
{
  "vendor_name": string or null,
  "invoice_number": string or null,
  "invoice_date": string or null,
  "due_date": string or null,
  "subtotal": number or null,
  "tax_amount": number or null,
  "total_amount": number or null,
  "line_items": [
    {
      "description": string,
      "amount": number
    }
  ]
}

[USER ROLE]
Raw OCR Text:
{{1.ocr_text}}

4. Automated Slack/Teams Notification Summarizer

Use this prompt to condense long email threads, call transcripts, or project updates into formatted bullet points ideal for Slack or Microsoft Teams webhook messages.

[SYSTEM ROLE]
You are a executive summarizer bot. Create a clean, bulleted executive summary from the provided document or transcript.

RULES:
1. Output key points formatted specifically for Slack message readability using standard Slack markdown (*bold*, _italics_).
2. Keep the summary under 150 words.
3. Include explicit Action Items with assigned owners if mentioned.

FORMAT TEMPLATE:
*Executive Summary:*
• [Key takeaway 1]
• [Key takeaway 2]

*Action Items:*
• [Task - Owner (if specified)]

[USER ROLE]
Transcript/Document Content:
{{1.transcript_text}}

Step-by-Step: Adding AI Prompts to Make.com Modules

Follow these operational steps to build a robust AI-driven scenario in Make.com:

1. Add the AI Module: Create a new scenario step and search for OpenAI (or your chosen provider). Select the action module (e.g., Create a Completion or Create a Response).
2. Select the Model: Choose a performant, cost-effective model (e.g., gpt-4o-mini or claude-3-5-sonnet via HTTP) appropriate for structured data processing.
3. Configure System Instructions: In the System Prompt field, paste your explicit instructions, including constraints, output rules, and target JSON structure.
4. Inject Dynamic Variables: In the User Prompt field, map the dynamic output variables from preceding modules (e.g., {{1.text_body}}).
5. Set Output Format and Temperature: If available in the module settings, set the response format option to JSON Object and set the temperature value between 0.0 and 0.2.
6. Parse the Response: Place Make.com’s native Parse JSON module directly after the AI module. Map the response string content into the JSON parser input to turn the LLM text output into accessible Make.com data fields.

Prompt Strategy Comparison for Automation

Choosing the right prompt structure dictates the reliability of your automated scenarios. The comparison table below highlights how different prompting methodologies perform inside Make.com.

Best Practices and Expert Tips

To maintain high uptime and prevent scenario errors when deploying AI prompts inside Make.com, apply these production guidelines:

• Always Implement Fallback Values: Tell the AI explicitly what value to return if a data point is missing or ambiguous (e.g., "unknown" or null). This prevents module execution errors further downstream.
• Sanitize Inputs: If dynamic values passed into the user prompt contain special characters, quotation marks, or escaped characters, consider using Make.com function helpers like replace() to prevent string breaking within API payloads.
• Enforce Schema Integrity: Always test your prompt against edge cases—such as empty input fields or foreign language submissions—to ensure the module returns valid JSON every time.
• Utilize Make.com Error Handlers: Attach a Break or Resume error handling directive to your AI module. If an API rate limit occurs or the model returns invalid JSON, your error routing can retry or notify an administrator without stopping the scenario.

Common Mistakes to Avoid

• Including Conversational Filler in System Rules: Avoid letting the model answer with phrases like “Sure, here is your JSON object:”. This breaks Make.com JSON parsers unless filtered out.
• High Temperature for Logical Tasks: Leaving temperature settings at the default 0.7 or 1.0 for data extraction causes key names to change unpredictably between runs.
• Not Setting Maximum Token Limits: Failing to limit output tokens can lead to run-away scenario execution costs if unexpected long-form input causes the LLM to output massive responses.
• Hardcoding Scenario Logic inside the Prompt: Keep business routing rules inside Make.com’s native Router and Filter modules, using the AI prompt primarily for data normalization and feature classification.

Frequently Asked Questions

What is the best prompt format for Make.com OpenAI modules?

The best prompt format uses a strict split between a System Prompt and a User Prompt, enforcing an explicit JSON output structure without markdown wrappers. This ensures Make.com can parse the output into native variables easily using its Parse JSON module.

How do I prevent AI modules from breaking my Make.com scenarios?

Set the module temperature to 0.0, explicitly state in the system prompt to return only valid JSON with specified key names, and implement Make.com error-handling routers (such as a Catch or Resume directive) directly on the AI module to manage API timeouts or unexpected responses.

Can I use System Prompts in Make.com AI modules?

Yes. Most modern AI modules in Make.com—including OpenAI, Anthropic, and specialized HTTP API calls—support message role definitions. Using the System Role field allows you to define strict rules and schemas separately from the dynamic user input mapped from your workflow.

Why should I set temperature low in Make.com AI prompts?

Setting a low temperature (between 0.0 and 0.2) reduces the randomness of the model’s outputs. For workflow automation, low temperature ensures consistent JSON schemas, standardized data categories, and repeatable logic execution across thousands of workflow runs.

Conclusion

Mastering AI prompts for Make.com automation changes LLMs from simple text generators into powerful data conversion engines for your business operations. By setting clear system roles, enforcing strict JSON schemas, and maintaining low module temperatures, you can reliably turn unstructured real-world inputs into structured data arrays. Build these prompt patterns into your Make.com scenarios to increase workflow reliability, eliminate manual data entry, and execute complex business logic seamlessly at scale.