DenchClaw + Make: Workflow Automation Guide

Make (formerly Integromat) is a visual automation platform with more flexibility than Zapier for complex workflows — conditional logic, data transformation, multi-branch routing, and a more generous free tier. Like Zapier, it connects to DenchClaw via webhooks. Unlike Zapier, Make's visual scenario builder makes it easier to build workflows that process and transform data before it hits your CRM.

Here's how to connect Make to DenchClaw and build useful automation scenarios.

Webhook-Based Connection Overview#

Make and DenchClaw communicate through webhooks in both directions:

Make → DenchClaw (inbound): Make's HTTP module sends data to DenchClaw's local webhook endpoint. DenchClaw creates or updates records in DuckDB based on the incoming data.

DenchClaw → Make (outbound): DenchClaw fires a webhook when something changes in your CRM (new lead, deal stage change, etc.). Make's Webhook module catches this and triggers downstream actions in other apps.

Before you start, you need DenchClaw's webhook endpoint exposed to the internet. Run:

npx denchclaw webhook expose

This creates a public tunnel (via ngrok or a similar tool) and returns a URL like https://abc123.ngrok.io. Keep this URL — you'll use it in Make.

Building Make Scenarios Triggered by DenchClaw#

This direction: something changes in DenchClaw → Make does something in other apps.

Step 1: Set up a DenchClaw webhook trigger#

Configure DenchClaw to fire a webhook when a specific event happens:

npx denchclaw webhook add \
  --name make-new-lead \
  --trigger contact_created \
  --filter "status = 'Lead'"

Or via natural language:

"Fire a webhook when a new Lead contact is created.
 I'll give you the Make webhook URL once I have it."

Step 2: Create a Make scenario with Webhook trigger#

1. In Make, click "Create a new scenario"
2. Click the "+" to add the first module
3. Search for "Webhooks" and select "Custom webhook"
4. Click "Add" to create a new webhook
5. Copy the webhook URL Make provides (looks like https://hook.eu1.make.com/abc123...)

Step 3: Connect DenchClaw to Make's webhook URL#

npx denchclaw webhook update make-new-lead \
  --url https://hook.eu1.make.com/abc123your-make-url

Or tell DenchClaw:

"Update the 'make-new-lead' webhook to fire to https://hook.eu1.make.com/abc123"

Step 4: Send a test event#

Create a test contact in DenchClaw with status "Lead":

"Create a test contact named Test User at Test Corp with status Lead"

Make should receive the webhook. Click "OK" in Make to capture the data structure. Now you can map DenchClaw fields to actions in other apps.

Webhook payload received by Make#

{
  "event": "contact_created",
  "timestamp": "2026-03-26T14:00:00Z",
  "contact": {
    "id": "c_xyz789",
    "name": "Test User",
    "email": "test@testcorp.com",
    "company": "Test Corp",
    "status": "Lead",
    "source": "manual",
    "created_at": "2026-03-26T14:00:00Z"
  }
}

Make parses this automatically once it receives the test event, giving you field references like {{contact.name}}, {{contact.email}}, etc.

Pushing Data From Make Into DenchClaw#

This direction: something happens in another app → Make processes it → DenchClaw creates or updates a record.

Setting up the DenchClaw inbound endpoint#

npx denchclaw webhook create-endpoint \
  --name make-inbound \
  --action upsert_contact \
  --secret your-webhook-secret

DenchClaw provides an endpoint URL:

https://abc123.ngrok.io/webhooks/make-inbound

Using Make's HTTP module to call DenchClaw#

In your Make scenario, after your trigger module, add an HTTP module:

1. Add module → search "HTTP" → select "Make a request"

2. Configure:

   • URL: https://abc123.ngrok.io/webhooks/make-inbound
   • Method: POST
   • Headers: Content-Type: application/json, X-Webhook-Secret: your-webhook-secret
   • Body type: Raw
   • Content type: JSON (application/json)

3. In the body, map fields from your trigger to DenchClaw's expected format:

{
  "name": "{{1.name}}",
  "email": "{{1.email}}",
  "company": "{{1.company}}",
  "phone": "{{1.phone}}",
  "status": "Lead",
  "source": "make-automation",
  "notes": "{{1.message}}",
  "custom_fields": {
    "form_id": "{{1.form_id}}",
    "utm_source": "{{1.utm_source}}"
  }
}

Replace {{1.field}} with the actual field mappings from your trigger module.

Common Make + DenchClaw Scenarios#

LinkedIn Lead Gen Form → CRM#

LinkedIn's Lead Gen Forms capture leads directly in LinkedIn. Make has a LinkedIn module that can watch for new form submissions.

Scenario:

1. Trigger: LinkedIn — Watch Lead Gen Form Submissions
2. Transform: Set default status, map fields
3. Action: HTTP — POST to DenchClaw inbound endpoint

This is one of Make's advantages over Zapier: Make has a native LinkedIn module. Combined with DenchClaw's LinkedIn browser enrichment, you get a complete workflow:

• LinkedIn form captures the lead
• Make sends it to DenchClaw
• DenchClaw enriches the contact from LinkedIn using the browser agent

Email Inquiry → Contact Entry#

Scenario: Someone emails your support or sales address. Make watches for new emails matching criteria and creates a CRM contact.

1. Trigger: Gmail — Watch Emails (filtered by subject or sender domain)
2. Filter: Check if sender is not already in a list of known customers
3. Extract: Use Make's Text Parser module to pull name from email signature
4. Action: HTTP — POST to DenchClaw
5. Action: DenchClaw creates contact with status "Lead" and logs the email

{
  "name": "{{1.from.name}}",
  "email": "{{1.from.address}}",
  "status": "Lead",
  "source": "inbound-email",
  "notes": "First contact via email. Subject: {{1.subject}}"
}

Airtable → CRM Migration#

Scenario: You're migrating contacts from Airtable to DenchClaw.

1. Trigger: Airtable — Search Records (all contacts)
2. Iterator: Process each row
3. Action: HTTP — POST to DenchClaw for each record

Make's iterator handles batch processing automatically. You can process thousands of Airtable records into DenchClaw without writing a line of code.

Webinar Registration → Lead#

Scenario: Someone registers for your webinar via a platform like Zoom Webinar or Demio. Make sends them to DenchClaw as a lead.

1. Trigger: Zoom — New Webinar Registrant (or Demio, Hopin, etc.)
2. Action: HTTP — POST to DenchClaw

{
  "name": "{{1.first_name}} {{1.last_name}}",
  "email": "{{1.email}}",
  "company": "{{1.org}}",
  "status": "Lead",
  "source": "webinar-registration",
  "custom_fields": {
    "webinar_name": "{{1.topic}}",
    "webinar_date": "{{1.start_time}}"
  }
}

Deal Closed → Slack + Email Notification#

Scenario: When DenchClaw fires a webhook for a deal reaching "Closed Won," Make sends a celebration message to Slack and a confirmation email to the customer.

1. Trigger: Webhooks — Custom Webhook (from DenchClaw deal_stage_change)
2. Filter: Only continue if {{deal.stage}} = "Closed Won"
3. Action: Slack — Create a Message in #sales-wins channel
4. Action: Gmail — Send Email to customer confirming next steps

This multi-step scenario with conditional filtering is where Make's visual builder shines.

HTTP Module Setup for Make: Complete Reference#

The HTTP module is your main tool for connecting Make to DenchClaw. Here are the key configurations:

Basic POST setup:

URL: https://your-public-url.ngrok.io/webhooks/make-inbound
Method: POST

Headers (required):

Content-Type: application/json
X-Webhook-Secret: your-secret-here

Body example for contact upsert:

{
  "name": "Full Name",
  "email": "email@example.com",
  "company": "Company Name",
  "status": "Lead",
  "source": "make",
  "custom_fields": {}
}

Handling the response:

DenchClaw returns a JSON response:

{
  "success": true,
  "action": "created",
  "contact_id": "c_abc123",
  "message": "Contact created successfully"
}

Use Make's HTTP response handling to check success and branch your scenario accordingly — for example, logging a failure to a Google Sheet if success is false.

Make vs. Zapier for DenchClaw Workflows#

Both tools do the same fundamental job. Here's where each wins:

Use Make when:

• Your workflow has conditional branches ("if company size > 100, do X, else do Y")
• You need to transform or aggregate data before sending to DenchClaw
• You want better error handling and retry logic
• You're doing bulk operations with iterators
• You need the LinkedIn module

Use Zapier when:

• Simple two-step automations (form → CRM)
• You're more comfortable with Zapier's interface
• The app you need is only on Zapier and not on Make

Frequently Asked Questions#

Does Make need to reach DenchClaw's local server?

Yes. Make's HTTP module calls your DenchClaw webhook endpoint over the internet. You need to expose your local server with npx denchclaw webhook expose (which uses ngrok or a similar tunnel). For production setups, run DenchClaw on a VPS or cloud instance with a static public IP.

Can Make trigger DenchClaw's browser agent?

Not directly via webhook. The inbound webhook creates or updates records in DuckDB. To trigger browser-based enrichment (Apollo, LinkedIn), tell DenchClaw separately: "Enrich any new leads added in the last hour." This creates a clean separation: Make handles data ingestion, DenchClaw handles enrichment.

What's the difference between Make's webhook trigger and HTTP module?

Webhook trigger: Make receives data from an external source (like DenchClaw's outbound webhook). HTTP module: Make sends data to an external endpoint (like DenchClaw's inbound webhook). You'll use both in bidirectional setups.

Can I use Make to sync DenchClaw with Salesforce or HubSpot for a team that's migrating?

Yes. Make has modules for both Salesforce and HubSpot. You can build a scenario that reads records from Salesforce/HubSpot and creates matching records in DenchClaw via the HTTP module. This is a practical migration path: run both systems in parallel, sync changes via Make during the transition, then cut over when ready.

How do I test a Make scenario without affecting real CRM data?

DenchClaw supports a test mode for incoming webhooks:

npx denchclaw webhook create-endpoint \
  --name make-inbound-test \
  --action upsert_contact \
  --dry-run true

With --dry-run, DenchClaw processes the webhook, validates the data, and logs what it would have done — but doesn't write to DuckDB. Perfect for testing your Make scenario before going live.

Ready to try DenchClaw? Install in one command: npx denchclaw. Full setup guide →