Stats
Actions
Tags
From automation-tools
Expert-level Make.com automation platform guidance covering scenario design, API integration, AI agents, Make Bridge, error resilience, performance optimization, enterprise observability, and Blueprint JSON structure for scenario recreation. Use for any workflow automation, integration, or orchestration challenge including fix-and-flip property analysis and scenario programmatic building.
How this skill is triggered — by the user, by Claude, or both
Slash command
/automation-tools:make-comThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Make.com (formerly Integromat) is the most comprehensive iPaaS for scenario automation, AI orchestration, and real-time integrations. It evolved from a visual workflow builder into a complete enterprise automation platform supporting:
Make.com (formerly Integromat) is the most comprehensive iPaaS for scenario automation, AI orchestration, and real-time integrations. It evolved from a visual workflow builder into a complete enterprise automation platform supporting:
As of 2025, Make transitioned from "operations" to "credits" billing (1 operation = 1 credit, with complex operations consuming multiple credits). The platform now offers enterprise features including Make Grid (3D workflow visualization), AI Agents with tool integration, and Make Bridge for embedded automation.
Consult this skill for: scenario architecture and troubleshooting, API integration patterns, webhook security and reliability, AI agent design, error handling and resilience, performance optimization, Make API programmatic access, Make Bridge embedded integrations, incomplete execution recovery, Make Grid ecosystem analysis, data transformation logic, credit optimization, and production operations management.
Account Configuration: Create a Make account, connect applications via OAuth or API authentication. For production, use dedicated connections per environment (DEV, STAGING, PROD) to prevent data leaks. Generate API keys from User Profile → API tokens for Make API access and MCP integrations.
Regional Endpoints: Make operates from multiple zones (EU1, EU2, US1, US2, AU1). Specify zone-appropriate endpoints:
https://eu1.make.com/api/v2/https://us1.make.com/api/v2/Critical URLs:
Billing Model (2025):
Scenarios: Automation workflows consisting of trigger(s), modules, routers/filters, and error handlers. Execute on schedule, webhook trigger, app event, or manual invocation. Each scenario execution can process multiple bundles (data items).
Modules: Discrete actions interacting with apps or data. Types: triggers (Webhook, Scheduled), actions (Create/Update records), search/iterators, transformers (JSON, text parsing), flow control (Router, Filter), error handlers, and AI modules.
Connections: Secured credentials linking scenarios to external apps. Environment-scoped (DEV/STAGING/PROD). Token expiry requires re-authorization. Use unique connections per sensitive integration to prevent cascading failures.
Bundles & Cycles: A bundle is the data packet passed between modules. An iterator creates multiple cycles (executions of downstream modules per item), each processing one bundle at a time.
Routers & Filters: Routers create conditional branches; filters gate execution. Router outputs only ONE bundle per execution to the matching branch; filters continue or halt execution sequentially.
Iterators & Aggregators: Iterator expands arrays into individual cycles; Aggregator consolidates results back into single array. Essential for efficient batch processing (10,000+ items).
Webhooks: Real-time triggers via HTTP POST to unique HTTPS URLs. Support instant delivery, API keys, IP whitelisting, and payload validation. Queue overflow protection via async patterns and batch processing.
Data Stores: Native Make key-value storage for caching, lookups, and inter-scenario state. 10-100x faster than external APIs for small data; credit-based pricing. No size limits within org quotas.
Make Grid (June 2025+): Real-time 3D visualization of scenario ecosystem showing all scenarios, webhooks, data stores, and interconnections. Filters by team, status, app, or custom properties. Overlays credit consumption for optimization. Essential for enterprise impact analysis and dependency tracking.
Make Bridge: White-label integration platform allowing embedding Make automation into your applications. Provides API for managing integrations, users, and configurations programmatically. Uses JWT authentication with short-lived tokens.
AI Agents (2025+): Goal-driven LLM entities equipped with tools for autonomous reasoning and execution. Unlike scenarios (fixed-path logic), agents dynamically determine execution based on LLM reasoning. Can use tools from toolset (Salesforce lookup, CRM query, etc.) and integrate with external MCP servers.
Make API: RESTful API for programmatic scenario management, webhook orchestration, execution monitoring, and integration with external systems. Supports API key and OAuth authentication. Used for DevOps automation, CI/CD integration, and custom dashboard building.
Incomplete Executions (DLQ): Dead Letter Queue storing scenarios that failed to complete. Accessible via API (GET /dlqs) for retrieval and analysis. Enables error recovery and operational alerting.
MCP (Model Context Protocol): Bidirectional protocol enabling: (1) Make scenarios exposed as tools to external AI systems (e.g., Claude, other AI models), and (2) Make AI Agents connecting to external MCP servers for advanced tool capabilities.
HTTP & API Modules:
Make a Request: Custom HTTP calls (GET/POST/PUT/PATCH/DELETE) with headers, auth, body, timeoutsMake an OAuth 2.0 Request: OAuth 2.0 flows for APIs without native Make connectionsGet a File: Download and process files from URLs or external storageTriggers:
Webhooks > Custom Webhook: Real-time HTTP POST with optional API key, IP whitelist, payload validationScheduled: Cron-like execution on daily/weekly/monthly/custom schedules in UTC (convert timezones carefully)Watch field for changes: Monitor app records for field-level updatesFlow Control:
Router: Conditional branching; evaluates routes sequentially; only ONE route executes per bundleFilter: Single-condition gate; stops if false, continues if trueIterator: Processes arrays one item per cycle; downstream modules repeat per itemAggregator: Consolidates multiple cycles back into single array; place after iterators for batch operationsBreak/Continue/Commit: Loop control and transactional markersData Transformation:
Text Parser > Match Pattern: Regex extraction with named capture groupsJSON: Parse, create, stringify JSON dataArray functions: map(), length(), flatten(), deduplicate(), slice()Date/Time: formatDate(), parseDate(), addMonths(), timezone-aware conversionsString functions: split(), trim(), capitalize(), replace()Math: add(), multiply(), round(), min(), max()Error Handling Routes:
Ignore: Skip failed module, continue (⚠️ data loss risk; use rarely)Resume: Use fallback data; downstream receives fallback instead of outputRollback: Undo transactional operations (database modules)Break: Retry with exponential backoff (1s, 2s, 4s, 8s...); configurable count and intervalCommit: Save partial progress before stoppingAI Modules:
Run an Agent: Execute LLM-powered agent with tools and autonomous reasoningCompletion (OpenAI/Claude/Gemini): Call external LLMs with system/user messages, temperature, max tokensAI Content Extractor: OCR, PDF text extraction, audio transcription, document parsingData Stores:
Add/Replace Record: Insert or update key-value data (auto-creates store if needed)Get/Search Records: Retrieve by key or search by field conditionsUtility:
Set Variable/Set Multiple Variables: Store values for reuse in downstream modulesSleep: Pause execution (useful for rate-limit avoidance, waiting for async operations)Webhooks > Webhook Response: Send synchronous response back to webhook caller1. Basic Trigger-Action Flow
Webhook Trigger → HTTP Make Request → Webhook Response
Minimal synchronous API integration. Caller waits for response.
2. Batch Data Processing Pipeline
Trigger (new data)
→ Iterator (per item)
→ Transform (Text Parser, JSON)
→ Filter (validate)
→ Aggregator (collect results)
→ Batch API call (Google Sheets Add Rows, bulk database insert)
→ Error handler: Break (retry) → Resume (partial commit)
Processes 10,000+ items in 2-3 credits vs. 10,000+ with one-by-one approach.
3. Conditional Multi-Branch Routing
Trigger
→ Router
├── Route 1: [Status = "Premium"] → VIP flow (priority, expedited)
├── Route 2: [Status = "Standard"] → Standard flow
└── Route 3: (fallback) → Default flow
→ Consolidate → Final action
Each bundle executes ONE matching branch.
4. Error Resilience with Exponential Backoff
HTTP Module (critical API)
├── Success → continue
└── Error Handler: Break
└── Retry: count=5, interval=1 (doubles each retry)
└── Max retries exceeded: Resume (use default/fallback data)
Handles transient failures (429 rate limits, 503 temporarily unavailable).
5. Webhook Chaining for Multi-Scenario Workflows
Scenario A (processes data)
→ HTTP Make Request to Scenario B's webhook URL (passes data in body)
→ Scenario B triggered immediately
→ B completes → (optional) Calls back to A via callback webhook
Sequential multi-scenario orchestration. Enable async pattern to avoid timeout.
6. Caching with Data Stores
Check Data Store for key
├── Found: Use cached value → continue
└── Not found: API call → Save to Data Store → Use result
Prevents redundant expensive API calls. 10-100x faster than external API for lookups.
7. Webhook Queue Management
Incoming webhooks → Immediately save to Data Store
→ Scheduled scenario (every 5 min) processes Data Store records in batches
→ Clear processed records
Prevents queue overflow; enables batch optimization.
8. AI Agent with Tool Integration
Run AI Agent with goal: "Analyze lead and route to appropriate sales team"
├── Agent's tools: [Salesforce Lead lookup, Team availability API, CRM update]
├── Agent reasoning: "Lead is high-value + Team A available → route to A"
→ Router (based on agent output): Team assignment → Slack notify
Autonomous, reasoning-based task execution vs. fixed logic flows.
API Key Authentication (Simpler, for server-to-server):
curl -H "Authorization: YOUR_API_KEY" \
https://eu1.make.com/api/v2/scenarios/112
JWT Authentication (For Make Bridge and custom integrations):
const jwt = require('jsonwebtoken');
const crypto = require('crypto');
const SECRET_KEY = '04XXXXXXXXXXXXXXXXXXXX'; // from Make Account
const KEY_ID = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX';
const userId = '[email protected]'; // unique user identifier
const token = jwt.sign(
{ sub: userId, jti: crypto.randomUUID() },
SECRET_KEY,
{ expiresIn: '2m', keyid: KEY_ID }
);
// Use token in Authorization header: Bearer {token}
Activate Scenario:
POST https://eu1.make.com/api/v2/scenarios/{scenarioId}/start
Authorization: YOUR_API_KEY
Response: { scenario: { id: 5, isActive: true, islinked: true } }
Deactivate Scenario:
POST https://eu1.make.com/api/v2/scenarios/{scenarioId}/stop
Authorization: YOUR_API_KEY
Response: { scenario: { id: 5, isActive: false } }
Get Scenario Details (includes blueprint, status, execution history):
GET https://eu1.make.com/api/v2/scenarios/{scenarioId}
Authorization: YOUR_API_KEY
Response: { scenario: { id: 112, name: "Sync Leads", blueprint: {...}, isActive: true } }
Update Scenario Interface (modify scenario inputs for programmatic calls):
PATCH https://eu1.make.com/api/v2/scenarios/{scenarioId}/interface
Authorization: YOUR_API_KEY
Content-Type: application/json
{
"interface": {
"input": [
{ "name": "email", "type": "text", "required": true },
{ "name": "priority", "type": "text", "default": "medium" }
]
}
}
Get All Webhooks (list registered webhooks):
GET https://eu1.make.com/api/v2/hooks
Authorization: YOUR_API_KEY
Response: { hooks: [ { id: 654, label: "New Lead", url: "https://..." } ] }
Get Webhook Logs (retrieve execution history; 3 days retention, 30 days Enterprise):
GET https://eu1.make.com/api/v2/hooks/{hookId}/logs?from=1234567890&to=1234567899
Authorization: YOUR_API_KEY
Response: {
hookLogs: [
{ statusId: 1, parser: "gateway-webhook", loggedAt: "2025-01-15T10:30:00Z", data: {...} },
{ statusId: 3, parser: "gateway-webhook", loggedAt: "2025-01-15T10:25:00Z" }
]
}
statusId: 1 = success, statusId: 3 = failed. Use data field to inspect request/response.
Get Specific Webhook Log:
GET https://eu1.make.com/api/v2/hooks/{hookId}/logs/{logId}
Authorization: YOUR_API_KEY
Response: {
hookLog: {
statusId: 1,
data: { request: { headers: {...}, body: {...} }, response: { status: 200, body: "..." } },
loggedAt: "2025-01-15T10:30:00Z"
}
}
List Incomplete Executions (scenarios that failed to complete):
GET https://eu1.make.com/api/v2/dlqs?scenarioId={scenarioId}
Authorization: YOUR_API_KEY
Response: {
dlqs: [
{ id: "a07e16f2ad134bf49cf83a00aa95c0a5", reason: "Rate limit exceeded", timestamp: "2025-01-15T10:30:00Z" }
]
}
Get Failed Scenario Blueprint (retrieve exact state at failure):
GET https://eu1.make.com/api/v2/dlqs/{dlqId}/blueprint
Authorization: YOUR_API_KEY
Response: {
blueprint: {
flow: [ { id: 1, module: "http:ActionSendData", mapper: {...}, onerror: [...] } ],
metadata: {...}
}
}
Use this to understand failure context, replay with fixes, or alert operations.
Make Bridge enables white-label automation by embedding Make into your applications. Users create integrations through your interface without accessing Make directly.
Key Concepts:
Bridge API Example (list user's integrations):
async function getBridgeIntegrations(userId) {
const token = generateMakeBridgeJwt(userId);
const response = await fetch('https://eu2.make.com/portal/api/bridge/integrations', {
method: 'GET',
headers: { Authorization: `Bearer ${token}` }
});
return response.json();
}
Use Cases:
Accessing Make Grid: Organization section in top menu; provides 3D visualization of entire scenario ecosystem.
What Grid Shows:
Grid Features:
Optimization Workflow:
Scenario Architecture:
Performance & Credit Optimization:
Error Handling Strategy:
Ignore only for truly optional operationsResume with sensible defaults for non-critical API failuresBreak for transient errors (rate limits, timeouts); configure exponential backoffCommit for batch scenarios to preserve partial progress on errorSecurity Best Practices:
Monitoring & Observability:
Testing & Validation:
Maintainability:
{{customer_first_name}} not {{var1}}Connection Failures (401/403):
Data Type Mismatches:
ifempty() for optional fields. Convert types: toString(), toNumber(), toJSON(). Use Text Parser for extracting typed data from unstructured input.Timeout Errors (54xx):
Rate Limiting (429):
Webhook Queue Backlog:
Make Grid Unavailable:
AI Agent Hallucination/Incorrect Output:
Example 1: Salesforce Lead Enrichment Pipeline
Example 2: Multi-Scenario Batch Report Generation
Example 3: Real-Time Customer Support Routing with AI Agent
Example 4: Data Warehouse Sync with Incomplete Execution Recovery
/dlqs for incomplete executions/dlqs/{dlqId}/blueprintExample 5: Embedded Integration Platform (Make Bridge)
Example 6: Make Grid Dependency Impact Analysis
Use Make API to Trigger Scenarios from External Systems:
Use Case: CI/CD pipeline triggers Make scenario for deployment automation, data migration, or report generation.
Make AI Agents as Tools for External LLMs (e.g., Claude, ChatGPT):
External MCP Servers in Make AI Agents:
Strategy:
This section provides the JSON schema and patterns for building, exporting, and reconstructing Make.com scenarios programmatically. Understanding JSON structure enables automation, version control, and scenario cloning.
Every Make scenario exports as JSON containing metadata, modules, connections, and flow logic:
{
"name": "Lead_Enrichment_Pipeline_PROD",
"description": "Enriches Salesforce leads with third-party data, routes by score",
"flow": [
{ "id": 1, "module": "webhooks:ActionCustomWebhook", "mapper": {}, "enabled": true },
{ "id": 2, "module": "http:ActionSendData", "mapper": { "url": "https://api.enrichment.com/enrich", "method": "POST" }, "onerror": [ { "type": "break", "count": 3, "interval": 1 } ] },
{ "id": 3, "module": "router:ActionRouter", "routes": [ { "condition": "{{2.score > 80}}", "path": [4, 5] }, { "condition": "{{2.score <= 80}}", "path": [6] } ] },
{ "id": 4, "module": "salesforce:ActionCreateRecord", "mapper": { "table": "Lead", "data": { "Score__c": "{{2.score}}", "Status": "Hot" } } },
{ "id": 5, "module": "slack:ActionSendMessage", "mapper": { "channel": "#sales", "text": "High-value lead: {{1.email}}" } },
{ "id": 6, "module": "dataStore:ActionAddRecord", "mapper": { "storeId": "lead_queue", "key": "{{1.id}}", "data": "{{1}}" } }
],
"connections": [
{ "from": 1, "to": 2 },
{ "from": 2, "to": 3 },
{ "from": 3, "to": [4, 5, 6] }
],
"metadata": {
"version": "1.0.0",
"team": "sales-automation",
"tags": ["lead-enrichment", "production"],
"createdAt": "2025-01-15T10:30:00Z",
"lastModified": "2025-01-20T14:45:00Z"
}
}
Key Fields: flow array with module objects (id, module name, mapper config), onerror handlers, routes for conditional branching, connections for data flow, metadata for versioning/documentation.
HTTP Request with Retries:
{ "id": 2, "module": "http:ActionSendData", "mapper": { "url": "https://api.example.com/enrich", "method": "POST", "body": { "email": "{{1.email}}" }, "timeout": 30 }, "onerror": [{ "type": "break", "count": 5, "interval": 1, "exponentialBackoff": true }, { "type": "resume", "fallback": { "score": 0 } }] }
Iterator (Array Processing):
{ "id": 3, "module": "arrayIterator:ActionArrayIterator", "mapper": { "array": "{{1.customers}}" } }
Repeats downstream modules per array item. Reference current: {{3.firstName}}
Aggregator (Collect Results):
{ "id": 5, "module": "arrayAggregator:ActionAggregator", "mapper": { "targetArray": "results" } }
Consolidates multiple cycles back into array. Place after iterator's dependent modules.
Router (Conditional Branching):
{ "id": 6, "module": "router:ActionRouter", "routes": [ { "label": "Premium", "condition": "{{2.tier}} == 'premium'", "path": [7, 8] }, { "label": "Standard", "condition": "{{2.tier}} == 'standard'", "path": [9] }, { "label": "Default", "condition": "", "path": [10] } ] }
Evaluated top-to-bottom; first TRUE executes. Empty condition = fallback (always matches).
Filter (Gate Execution):
{ "id": 7, "module": "filter:ActionFilter", "mapper": { "condition": "{{1.amount}} > 1000" } }
TRUE: continue. FALSE: halt for this bundle.
AI Completion Module:
{ "id": 8, "module": "openai:ActionCompletion", "mapper": { "model": "gpt-4", "systemMessage": "You are a real estate analyst.", "userMessage": "Analyze: {{1.property}}. Return JSON.", "temperature": 0.7, "maxTokens": 1000, "responseFormat": "json" } }
Output: {{8.response}}. Use responseFormat: "json" for structured output.
AI Agent Module (Autonomous Reasoning):
{ "id": 9, "module": "makeAI:ActionAgent", "mapper": { "goal": "Route lead to appropriate team", "tools": [{ "name": "Get Lead", "type": "rest", "endpoint": "https://salesforce.api/leads/{{1.leadId}}" }], "maxIterations": 5, "temperature": 0.5 } }
Output: {{9.reasoning}}, {{9.result}} (agent's decision + thought process).
Data Store (Cache/Lookup):
{ "id": 10, "module": "dataStore:ActionAddRecord", "mapper": { "storeId": "lead_cache", "key": "lead_{{1.id}}", "data": { "email": "{{1.email}}", "score": "{{2.score}}" }, "ttl": 3600 } }
Retrieve: { "id": 11, "module": "dataStore:ActionSearchRecord", "mapper": { "storeId": "lead_cache", "key": "lead_{{1.id}}" } }
Set Variable (Reuse Values):
{ "id": 12, "module": "util:ActionSetVariable", "mapper": { "name": "enriched_lead", "value": { "id": "{{1.id}}", "score": "{{2.score}}" } } }
Reference: {{12.enriched_lead}}
Break + Exponential Backoff:
"onerror": [{ "type": "break", "count": 5, "interval": 1, "exponentialBackoff": true }]
Retries: 1s, 2s, 4s, 8s, 16s. Use for transient errors (429, 503).
Resume with Fallback (Non-critical operations):
"onerror": [{ "type": "resume", "fallback": { "status": "error", "data": null } }]
Downstream gets fallback; execution continues.
Chained: Retry then Fallback:
"onerror": [{ "type": "break", "count": 3, "interval": 1 }, { "type": "resume", "fallback": { "status": "retry_failed" } }]
Webhook (property data) → Market enrichment API → AI scoring → Router by score tier → Notifications + DB storage.
{
"name": "Property_DealAnalysis_FixAndFlip",
"flow": [
{ "id": 1, "module": "webhooks:ActionCustomWebhook", "mapper": { "label": "New Property", "api_key": true }, "enabled": true },
{ "id": 2, "module": "http:ActionSendData", "mapper": { "url": "https://realestateapi.com/search", "method": "POST", "body": { "address": "{{1.address}}", "zipCode": "{{1.zipCode}}" } }, "onerror": [{ "type": "break", "count": 3 }, { "type": "resume", "fallback": { "marketData": null } }] },
{ "id": 3, "module": "openai:ActionCompletion", "mapper": { "model": "gpt-4", "systemMessage": "Real estate investment analyst. Return JSON: {score, arv, repairs, buyerProfile}", "userMessage": "Address: {{1.address}}\nPrice: ${{1.purchasePrice}}\nBeds: {{1.beds}}\nBaths: {{1.baths}}\nMarket: {{2.comps}}", "responseFormat": "json" } },
{ "id": 4, "module": "router:ActionRouter", "routes": [ { "label": "High (>75)", "condition": "{{3.score}} > 75", "path": [5, 6, 7] }, { "label": "Medium (50-75)", "condition": "{{3.score}} > 50", "path": [8, 9] }, { "label": "Low", "condition": "", "path": [10] } ] },
{ "id": 5, "module": "slack:ActionSendMessage", "mapper": { "channel": "#premium-deals", "text": "🔥 HIGH: {{1.address}} | Score: {{3.score}}/100 | ARV: ${{3.arv}}" } },
{ "id": 6, "module": "salesforce:ActionCreateRecord", "mapper": { "table": "Deal__c", "data": { "Address__c": "{{1.address}}", "Score__c": "{{3.score}}", "ARV__c": "{{3.arv}}", "Status__c": "Qualified" } } },
{ "id": 7, "module": "gmail:ActionSendEmail", "mapper": { "to": "[email protected]", "subject": "Deal: {{1.address}}", "body": "Score: {{3.score}}/100 | ARV: ${{3.arv}} | Repairs: ${{3.repairs}} | Profile: {{3.buyerProfile}}" } },
{ "id": 8, "module": "slack:ActionSendMessage", "mapper": { "channel": "#standard-deals", "text": "📋 STANDARD: {{1.address}} | Score: {{3.score}}" } },
{ "id": 9, "module": "dataStore:ActionAddRecord", "mapper": { "storeId": "deals_queue", "key": "deal_{{1.id}}", "data": { "address": "{{1.address}}", "score": "{{3.score}}", "tier": "standard" }, "ttl": 86400 } },
{ "id": 10, "module": "dataStore:ActionAddRecord", "mapper": { "storeId": "deals_archive", "key": "deal_{{1.id}}", "data": { "address": "{{1.address}}", "score": "{{3.score}}", "reason": "Below threshold" }, "ttl": 604800 } }
],
"connections": [ { "from": 1, "to": 2 }, { "from": 2, "to": 3 }, { "from": 3, "to": 4 }, { "from": 4, "to": [5, 6, 7, 8, 9, 10] } ],
"metadata": { "version": "2.0.0", "tags": ["real-estate", "fix-flip", "ai-scoring", "prod"], "environment": "PROD" }
}
Export: Make Dashboard → Scenario → Download a Copy (JSON includes flow, connections, config).
Rebuild: Import JSON blueprint via Make UI or Make API: POST /api/v2/scenarios with blueprint.
Programmatic:
curl -X POST https://eu1.make.com/api/v2/scenarios -H "Authorization: KEY" -d '{"name": "Deal_Analysis", "blueprint": {"flow": [...], "connections": [...]}}'
Key Patterns for JSON:
{{id.field}}This structure enables version control (git), scenario cloning, and accurate recreation. When you ask me to build or recreate scenarios, provide JSON examples or describe architecture—I'll use these patterns.
On Production Alert (scenario failed):
GET /api/v2/hooks/{hookId}/logsGET /api/v2/dlqs?scenarioId=XGET /api/v2/dlqs/{dlqId}/blueprint (see exact failure state)Most-Used Formulas:
{{now}} - Current Unix timestamp{{formatDate(date; "YYYY-MM-DD HH:mm:ss")}} - Format date{{ifempty(value; "default")}} - Null coalesce{{map(array; "fieldName")}} - Extract field from array items{{split(text; ",")}} - String to array{{join(array; ", ")}} - Array to comma-separated string{{length(array)}} - Count items{{add(1; 2; 3)}} - Sum values{{toJSON(object)}} - Object to JSON string{{parseDate(date_string; "YYYY-MM-DD"; "America/New_York")}} - Parse with timezoneCommon HTTP Status Codes:
Make API Base URLs by Region:
https://eu1.make.com/api/v2/https://eu2.make.com/api/v2/https://us1.make.com/api/v2/https://us2.make.com/api/v2/https://au1.make.com/api/v2/Module Output Inspection: After scenario run, click "bubble" above connection → see exact data passed. Essential for debugging data type mismatches and mapping errors.
For advanced challenges not covered in this skill, consult the official API documentation, community forums, or Make support. This skill prioritizes production-grade patterns; edge cases are handled via documented resources.
Skill Version: 2.2 | Last Updated: October 2025 (Blueprint JSON Structure Added) | Context7 Sources: Make API Documentation, Make Developer Hub, Make Custom Apps, Real Estate Automation Examples
npx claudepluginhub nickloveinvesting/nick-love-plugins --plugin automation-toolsGuides designing Make scenarios: choosing modules, composing flows, setting routing/branching/filtering/iterations/aggregations, building blueprints, deploying, error handling, scheduling.
Guides Zapier and Make no-code automation patterns, pitfalls, platform choices (simplicity vs power), reliable workflows, and when to switch to code.
Automates Make (Integromat) tasks via Rube MCP (Composio): retrieve operations/logs, list languages/timezones. Requires Rube MCP connection and tool schema checks.