Advanced No-Code: Building APIs and Custom Webhooks with Make

Moving Beyond Simple Automations

Zapier and Make are great for connecting two apps. But what about complex workflows that require:

This is where Make (formerly Integromat) becomes a full workflow platform.

Understanding Webhooks

What Is a Webhook?

A webhook is when your application sends data to Make when something happens.

Traditional approach (polling):

Zapier asks: "Did anything happen?"
(every 5 minutes)
App says: "No... No... No... Yes!"
Zapier receives the event 5 minutes later

Webhook approach (push):

Your app says immediately: "Something happened!"
Make receives it in milliseconds

Setting Up a Webhook in Make

Step 1: Create Webhook URL

In Make:

1. Add module: "Webhooks" → "Custom Webhook"

2. Click "Add" → New webhook

3. Get the unique URL: `https://hook.make.com/abc123xyz`

Step 2: Configure Your App to Send Webhook

In your application (custom code, backend service):

// When something important happens
app.post('/api/user-signup', async (req, res) => {
  const user = req.body;
  
  // Send webhook to Make
  await fetch('https://hook.make.com/abc123xyz', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      email: user.email,
      name: user.name,
      company: user.company,
      plan: user.plan
    })
  });
  
  res.json({ success: true });
});

Step 3: Receive and Process

In Make, the webhook module receives the data:

Input: {
  email: "john@company.com",
  name: "John Doe",
  company: "Acme Corp",
  plan: "Pro"
}

Then add subsequent modules to process the data:

Building Custom HTTP APIs with Make

Use Case: Expose Make Workflow as API

You want to call your Make workflow from your application.

Solution: Use Make's HTTP module to receive and respond.

Scenario: Custom Lead Scoring API

Your application wants to score leads without building complex logic.

API Specification:

POST /api/score-lead
Body: {
  email: string,
  company: string,
  company_size: number,
  industry: string,
  engagement_score: number
}
Response: {
  lead_score: number,
  tier: "cold"|"warm"|"hot",
  recommendation: string
}

Implementation in Make:

Step 1: Receive Webhook

Module: Webhooks → Custom Webhook
Method: POST
Data input: JSON

Step 2: Validate Data

Module: Flow Control → Conditional
Condition: email and company are provided
If false: Return error response

Step 3: Lookup Company

Module: HubSpot → Search Companies
Search by: company name
Get: company size, industry, growth rate

Step 4: Calculate Score

Module: Text → Compose (or JavaScript)

Formula:
base_score = 10
if company_size > 1000: score += 30
if industry in ["SaaS", "Tech"]: score += 20
if engagement_score > 7: score += 25
if recent_website_visits > 3: score += 15
if opened_email > 2: score += 10

if score > 70: tier = "hot"
else if score > 40: tier = "warm"
else: tier = "cold"

Step 5: Return Response

Module: Webhooks → Respond to Webhook

Body:
{
  "lead_score": 85,
  "tier": "hot",
  "recommendation": "Contact immediately"
}

Status: 200

Calling the API from Your App

const response = await fetch(
  'YOUR_WEBHOOK_URL',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      email: "john@company.com",
      company: "Acme Corp",
      company_size: 500,
      industry: "SaaS",
      engagement_score: 8
    })
  }
);

const result = await response.json();
console.log(`Lead score: ${result.lead_score}, Tier: ${result.tier}`);

Advanced: Error Handling and Retries

The Problem

What if an API call fails? Default behavior: error stops the workflow.

Better approach: Intelligent retry logic.

Solution: Retry Logic with Exponential Backoff

Module: Make → Get Record (or HTTP call)
Error Handling: On Error
  → Conditional: Is error retryable? (timeout, 429, 503)
    → If Yes:
      → Add delay (2 seconds)
      → Retry (attempt 2)
    → If second attempt fails:
      → Add delay (4 seconds)
      → Retry (attempt 3)
    → If still failing:
      → Log to Slack: "API failed after 3 attempts"
      → Store in error queue
      → Human can fix manually later
    → If Yes to error:
      → Return error to webhook

Implementation

Module: HTTP → Make a Request
URL: https://api.example.com/data

Error Handling tab:
  Ignore errors: ✓ (Don't stop workflow)

Next module: Flow Control → Conditional
  Condition: "Response status != 200"
  
  If false (success): Continue
  If true (error):
    → Add delay (2s)
    → Retry HTTP call
    → If still failed:
      → Log error
      → Move to fallback

Advanced: Data Transformation

Challenge: Complex JSON Transformations

You receive data in one format, need to send in another.

Received from API:

{
  "users": [
    {
      "id": "u123",
      "profile": {
        "firstName": "John",
        "lastName": "Doe",
        "emails": ["john@work.com", "john@personal.com"]
      },
      "metadata": {"source": "web", "signup_date": "2026-03-11"}
    }
  ]
}

Need to send to CRM:

{
  "contacts": [
    {
      "first_name": "John",
      "last_name": "Doe",
      "email": "john@work.com",
      "source": "web",
      "signup_date": "2026-03-11"
    }
  ]
}

Solution: Array Iterator + Transformer

Step 1: Iterate Over Array

Module: Flow Control → Array Iterator
Array: users
Iterates over each user

Step 2: Transform Data

Module: Transformers → Set Multiple Variables

Variables:
first_name = get profile.firstName from current item
last_name = get profile.lastName from current item
email = get first email from profile.emails array
source = get metadata.source
signup_date = get metadata.signup_date

Step 3: Create Record

Module: CRM → Create Contact

Map fields:
First Name: {{first_name}}
Last Name: {{last_name}}
Email: {{email}}
Source: {{source}}
Signup Date: {{signup_date}}

Result: 50 users transformed and created in seconds.

Advanced: Scheduled Workflows

Scenario: Daily Digest Report

Trigger: Time-based (every day at 9 AM)

Workflow:

1. Query analytics (Google Analytics)

2. Query CRM (Salesforce)

3. Query financials (Stripe)

4. Combine data

5. Generate HTML email

6. Send to leadership

Setup:

Module: Webhooks → Scheduled Trigger
Frequency: Daily
Time: 09:00 AM (timezone: your local)

Next modules:
→ Google Analytics → Get data
→ Salesforce → Get metrics
→ Stripe → Get metrics
→ Transformers → Combine data
→ Email → Send report

Advanced: Conditional Workflows (Decision Trees)

Scenario: Smart Customer Routing

Incoming: Customer support email

Logic:

If customer is VIP:
  → Route to senior support
  → High priority queue
  → Send SMS notification
Else if issue is technical:
  → Route to engineering
  → Create GitHub issue
Else if issue is billing:
  → Route to finance
  → Pull payment history
Else:
  → Route to general support
  → Standard queue

Implementation:

Module: Webhooks → Receive email

Module 1: CRM → Look up customer
  Get: VIP status, history

Module 2: Flow Control → Conditional
  If VIP:
    → Slack to VIP team
    → Zendesk → Create high-priority ticket
    → Twilio → Send SMS: "Support incoming"

Module 3: Flow Control → Conditional
  Else if issue contains ["bug", "error", "crash"]:
    → Slack to engineering
    → GitHub → Create issue
    → Zendesk → Create technical ticket

Module 4: Flow Control → Conditional
  Else if issue contains ["bill", "invoice", "payment"]:
    → Slack to billing team
    → Stripe → Get payment history
    → Email → Send with context

Module 5: Default
  → Zendesk → Create regular ticket

Building Your First Advanced Workflow

Step 1: Define the Problem

What manual process wastes the most time or causes errors?

Step 2: Design the Flow

Draw it out:

Input → Validation → Processing → Decision → Action → Output

Step 3: Implement Step by Step

Do not build the entire workflow at once. Build:

1. Input (webhook)

2. One action

3. Test

4. Add next action

5. Test

6. Repeat

Step 4: Add Error Handling

Then, add error scenarios:

Step 5: Monitor and Optimize

Performance Considerations

Slow Workflows?

Common causes:

Solutions:

Troubleshooting

"Webhook not triggering"

Check:

1. Is webhook URL correct?

2. Is application actually sending POST?

3. Are you sending JSON with correct headers?

4. Check Make execution logs

"Wrong data coming through"

Check:

1. Map fields correctly (case-sensitive)

2. Are optional fields null?

3. Print variables to debug

4. Use Transformer ��� Map to see data structure

"Workflow running forever"

Check:

1. Infinite loops? (A creates B, B creates A)

2. Too many iterations?

3. API timeouts?

4. Set execution limit on loops

Conclusion

Advanced no-code workflows rival custom code in flexibility.

You can build APIs, handle webhooks, process complex data, and automate sophisticated business logic—all visually, without writing a single line of code.

The key is thinking in workflows: input → process → output → error handling.

Master that, and you can automate nearly anything.

Start building advanced workflows: make.com