Enrow with Make - Enrow API Documentation

Make (formerly Integromat) is a visual automation platform that lets you build no-code Enrow workflows with a drag-and-drop interface. This guide shows how to call the Enrow API from a Make scenario, receive results through a webhook, and branch on the outcome — no server required. Authenticate every request with your API key in the x-api-key header.

What is Make?

Make is a visual automation platform that connects apps and APIs through scenarios — chains of modules that run when a trigger fires. With the HTTP module you can call any Enrow endpoint, then route the response into Google Sheets, a CRM, or a notification without writing code. For a managed alternative, Enrow also offers native CRM integrations.

How do I call the Enrow API from Make?

Build a scenario with a trigger, an HTTP module that calls Enrow, and a webhook that catches the async result. Follow these steps.

Step 1: Create a scenario

Go to Make.com
Click “Create a new scenario”
Name it “Enrow Email Finder”

Step 2: Add a trigger

Choose what starts the scenario:

Google Sheets: Watch rows
Webhooks: Custom webhook
Schedule: Run every hour
Watch for changes: In your CRM

Step 3: Add the HTTP module for Enrow

Click ”+” to add a module
Search for “HTTP”
Choose “Make a request”

Step 4: Configure the Enrow API call

Point the HTTP module at the Find Single Email endpoint and pass your API key in the headers. URL:

https://api.enrow.io/email/find/single

Method: POST Headers:

Content-Type: application/json
x-api-key: YOUR_ENROW_API_KEY

Body (JSON):

{
  "company_domain": "{{1.company_domain}}",
  "fullname": "{{1.first_name}} {{1.last_name}}"
}

Step 5: Add a webhook for results

Enrow processes searches asynchronously and notifies a webhook when each search finishes. See How Webhooks Work for the payload format.

Add a “Webhooks” module as a new trigger
Choose “Custom webhook”
Copy the webhook URL
Go back to the HTTP module
Update the JSON body to include the webhook:

{
  "company_domain": "{{1.company_domain}}",
  "fullname": "{{1.first_name}} {{1.last_name}}",
  "settings": {
    "webhook": "YOUR_MAKE_WEBHOOK_URL"
  }
}

Step 6: Process the results

After the webhook receives results:

Add a “Router” module to branch logic
Branch 1: Save to Google Sheets
Branch 2: Update CRM
Branch 3: Send notification

What scenarios can I build?

Common Enrow scenarios combine a trigger, the HTTP module, and the webhook with downstream apps. Here are three patterns to start from.

Scenario 1: Enrich Google Sheets

Google Sheets (Watch rows)
  → HTTP (Find email with Enrow)
  → Webhook (Receive results)
  → Google Sheets (Update row)

Scenario 2: Verify & add to Mailchimp

Typeform (Watch responses)
  → HTTP (Verify email)
  → Filter (Only valid emails)
  → Mailchimp (Add subscriber)

Scenario 3: Bulk processing

Schedule (Every hour)
  → Google Sheets (Get rows without emails)
  → Array aggregator (Batch 100 rows)
  → HTTP (Bulk find emails)
  → Webhook (Receive results)
  → Iterator (Process each result)
  → Google Sheets (Update row)

Why use Make for Enrow?

Make gives you a visual builder, built-in error handling, and parallel execution — useful when an Enrow workflow has to fan out into several apps.

Visual Workflow Builder

See your entire automation flow visually. Perfect for complex logic.

Error Handling

Built-in error handling and retry mechanisms.

Data Transformation

Powerful functions and tools to transform data between steps.

Parallel Execution

Run multiple paths simultaneously with Router module.

How do I build efficient Make scenarios?

Process Enrow results in batches, add error handlers, and cache results to avoid redundant calls. The patterns below keep scenarios fast and within both your Make operations and your Enrow credits.

Use the Iterator module

Process bulk results one by one:

HTTP (Bulk find)
  → Webhook (Receive batch results)
  → Iterator (Loop through results)
  → Google Sheets (Update each row)

Add error handlers

Right-click any module
Add “Error handler”
Configure what happens on error (log, email, retry)

Use Data Stores

Cache results to avoid redundant API calls:

Router
  → Path 1: Check data store for cached email
  → Path 2: If not found, call Enrow API → Save to data store

How do I process bulk operations?

Aggregate rows into batches and call the Find Bulk Emails endpoint (up to 5,000 searches per batch), then iterate over the webhook results. This processes 1,000 contacts in a handful of operations instead of one per contact.

Google Sheets (Get all rows)
  → Array aggregator (Batch size: 100)
  → HTTP (POST /email/find/bulk)
  → Webhook (Receive bulk results)
  → Iterator (Loop results)
  → Router
    → Path 1 (Valid): Update sheet with email
    → Path 2 (Invalid): Log to error sheet

Which Make modules do I need for Enrow?

These are the modules that appear in most Enrow scenarios:

Module	Use Case
HTTP	Call Enrow API
Webhooks	Receive async results
Iterator	Process bulk results
Router	Branch logic (valid/invalid)
Filter	Skip low-confidence results
Data Store	Cache results
Array Aggregator	Create batches

How do I keep operation usage low?

Make charges per operation, so prefer bulk endpoints, cache results in data stores, and filter early to skip unnecessary steps. A single bulk request counts as far fewer operations than many single requests. Example:

❌ Bad: 1000 single requests = 1000 operations
✅ Good: 10 bulk requests (100 each) = 10 operations

FAQ

Why isn't my webhook receiving data?

Verify the scenario is active (ON), check that the webhook URL in the Enrow settings.webhook field matches the one Make generated exactly, and test the endpoint with a tool like Postman first. See How Webhooks Work for the payload format.

My scenario hit the operations limit — what should I do?

Switch single calls to the Find Bulk Emails endpoint, cache frequently accessed data in a Data Store, and upgrade your Make plan if you still need more operations.

My scenario is timing out — how do I fix it?

Break a large scenario into smaller ones, use scheduled triggers instead of instant ones, and reduce batch sizes. Because Enrow searches are asynchronous, let the webhook deliver results rather than waiting inside the HTTP module.

Which Enrow endpoint should the HTTP module call?

Use Find Single Email or Verify Single Email for per-row work, and the Find Bulk Emails endpoint when aggregating many rows. All of them authenticate with the same x-api-key header.

Next steps

Find Single Email

Call the endpoint your HTTP module will use to find an email.

Find emails in bulk

Run up to 5,000 email searches in a single request.

How Webhooks Work

Understand the async result payload Make receives.

n8n Workflows

Build the same automation on a self-hosted alternative.

​What is Make?

​How do I call the Enrow API from Make?

​Step 1: Create a scenario

​Step 2: Add a trigger

​Step 3: Add the HTTP module for Enrow

​Step 4: Configure the Enrow API call

​Step 5: Add a webhook for results

​Step 6: Process the results

​What scenarios can I build?

​Scenario 1: Enrich Google Sheets

​Scenario 2: Verify & add to Mailchimp

​Scenario 3: Bulk processing

​Why use Make for Enrow?

​How do I build efficient Make scenarios?

​Use the Iterator module

​Add error handlers

​Use Data Stores

​How do I process bulk operations?

​Which Make modules do I need for Enrow?

​How do I keep operation usage low?

​FAQ

​Next steps