> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enrow.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Enrow met Make
> Bouw visuele no-code workflows die e-mails vinden en verifiëren met de Enrow API in Make (voorheen Integromat)
Make (voorheen Integromat) is een visueel automatiseringsplatform waarmee je no-code Enrow-workflows bouwt met een drag-and-drop-interface. Deze handleiding laat zien hoe je de Enrow API aanroept vanuit een Make-scenario, resultaten ontvangt via een webhook en vertakt op basis van de uitkomst — zonder server. Authenticeer elke aanvraag met je [API-sleutel](/nl/authentication) in de `x-api-key`-header.
## Wat is Make?
Make is een visueel automatiseringsplatform dat apps en API's verbindt via scenario's — ketens van modules die draaien wanneer een trigger afgaat. Met de HTTP-module kun je elk Enrow-endpoint aanroepen en de respons vervolgens routeren naar Google Sheets, een CRM of een notificatie zonder code te schrijven. Voor een beheerd alternatief biedt Enrow ook [native CRM-integraties](/nl/integrations/overview).
## Hoe roep ik de Enrow API aan vanuit Make?
Bouw een scenario met een trigger, een HTTP-module die Enrow aanroept en een webhook die het async resultaat opvangt. Volg deze stappen.
### Stap 1: Maak een scenario
1. Ga naar [Make.com](https://make.com)
2. Klik op **"Create a new scenario"**
3. Noem het "Enrow Email Finder"
### Stap 2: Voeg een trigger toe
Kies wat het scenario start:
* **Google Sheets**: Rijen bewaken
* **Webhooks**: Custom webhook
* **Schedule**: Elk uur uitvoeren
* **Watch for changes**: In je CRM
### Stap 3: Voeg de HTTP-module voor Enrow toe
1. Klik op **"+"** om een module toe te voegen
2. Zoek naar **"HTTP"**
3. Kies **"Make a request"**
### Stap 4: Configureer de Enrow API-aanroep
Richt de HTTP-module op het [Find Single Email](/nl/api-reference/email-finder/find-single)-endpoint en geef je API-sleutel mee in de 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):**
```json theme={null}
{
"company_domain": "{{1.company_domain}}",
"fullname": "{{1.first_name}} {{1.last_name}}"
}
```
### Stap 5: Voeg een webhook toe voor resultaten
Enrow verwerkt zoekopdrachten asynchroon en stuurt een notificatie naar een webhook wanneer elke zoekopdracht klaar is. Zie [How Webhooks Work](/nl/how-webhooks-work) voor het payloadformaat.
1. Voeg een **"Webhooks"**-module toe als nieuwe trigger
2. Kies **"Custom webhook"**
3. Kopieer de webhook-URL
4. Ga terug naar de HTTP-module
5. Werk de JSON-body bij om de webhook op te nemen:
```json theme={null}
{
"company_domain": "{{1.company_domain}}",
"fullname": "{{1.first_name}} {{1.last_name}}",
"settings": {
"webhook": "YOUR_MAKE_WEBHOOK_URL"
}
}
```
### Stap 6: Verwerk de resultaten
Nadat de webhook resultaten ontvangt:
1. Voeg een **"Router"**-module toe om de logica te vertakken
2. Tak 1: Opslaan in Google Sheets
3. Tak 2: CRM bijwerken
4. Tak 3: Notificatie versturen
## Welke scenario's kan ik bouwen?
Veelgebruikte Enrow-scenario's combineren een trigger, de HTTP-module en de webhook met downstream-apps. Hier zijn drie patronen om mee te beginnen.
### Scenario 1: Google Sheets verrijken
```
Google Sheets (Watch rows)
→ HTTP (Find email with Enrow)
→ Webhook (Receive results)
→ Google Sheets (Update row)
```
### Scenario 2: Verifiëren en toevoegen aan Mailchimp
```
Typeform (Watch responses)
→ HTTP (Verify email)
→ Filter (Only valid emails)
→ Mailchimp (Add subscriber)
```
### Scenario 3: Bulkverwerking
```
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)
```
## Waarom Make gebruiken voor Enrow?
Make geeft je een visuele builder, ingebouwde foutafhandeling en parallelle uitvoering — handig wanneer een Enrow-workflow naar meerdere apps moet uitwaaieren.
Bekijk je volledige automatiseringsflow visueel. Perfect voor complexe logica.
Ingebouwde foutafhandeling en retry-mechanismen.
Krachtige functies en tools om data tussen stappen te transformeren.
Voer meerdere paden tegelijk uit met de Router-module.
## Hoe bouw ik efficiënte Make-scenario's?
Verwerk Enrow-resultaten in batches, voeg foutafhandelaars toe en cache resultaten om overbodige aanroepen te voorkomen. De onderstaande patronen houden scenario's snel en binnen zowel je Make-operaties als je Enrow-[credits](/nl/credits-billing).
### Gebruik de Iterator-module
Verwerk bulkresultaten één voor één:
```
HTTP (Bulk find)
→ Webhook (Receive batch results)
→ Iterator (Loop through results)
→ Google Sheets (Update each row)
```
### Voeg foutafhandelaars toe
1. Klik met de rechtermuisknop op een module
2. Voeg **"Error handler"** toe
3. Configureer wat er gebeurt bij een fout (loggen, e-mailen, opnieuw proberen)
### Gebruik Data Stores
Cache resultaten om overbodige API-aanroepen te voorkomen:
```
Router
→ Path 1: Check data store for cached email
→ Path 2: If not found, call Enrow API → Save to data store
```
## Hoe verwerk ik bulkbewerkingen?
Aggregeer rijen tot batches en roep het [Find Bulk Emails](/nl/api-reference/email-finder/find-bulk)-endpoint aan (tot 5.000 zoekopdrachten per batch) en itereer vervolgens over de webhook-resultaten. Hiermee verwerk je 1.000 contacten in een handvol operaties in plaats van één 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
```
## Welke Make-modules heb ik nodig voor Enrow?
Dit zijn de modules die in de meeste Enrow-scenario's voorkomen:
| Module | Toepassing |
| -------------------- | --------------------------------------------- |
| **HTTP** | Enrow API aanroepen |
| **Webhooks** | Async resultaten ontvangen |
| **Iterator** | Bulkresultaten verwerken |
| **Router** | Logica vertakken (geldig/ongeldig) |
| **Filter** | Resultaten met lage betrouwbaarheid overslaan |
| **Data Store** | Resultaten cachen |
| **Array Aggregator** | Batches maken |
## Hoe houd ik het operatieverbruik laag?
Make rekent per operatie af, dus geef de voorkeur aan bulk-endpoints, cache resultaten in data stores en filter vroeg om onnodige stappen over te slaan. Eén bulkaanvraag telt als veel minder operaties dan veel losse aanvragen.
**Voorbeeld:**
* ❌ Slecht: 1000 losse aanvragen = 1000 operaties
* ✅ Goed: 10 bulkaanvragen (elk 100) = 10 operaties
## FAQ
Controleer of het scenario actief is (ON), controleer of de webhook-URL in het Enrow-veld `settings.webhook` exact overeenkomt met de URL die Make heeft gegenereerd, en test het endpoint eerst met een tool zoals Postman. Zie [How Webhooks Work](/nl/how-webhooks-work) voor het payloadformaat.
Schakel losse aanroepen over naar het [Find Bulk Emails](/nl/api-reference/email-finder/find-bulk)-endpoint, cache veelgebruikte data in een Data Store en upgrade je Make-abonnement als je nog steeds meer operaties nodig hebt.
Splits een groot scenario op in kleinere, gebruik geplande triggers in plaats van directe triggers en verklein de batchgroottes. Omdat Enrow-zoekopdrachten asynchroon zijn, laat je de webhook de resultaten afleveren in plaats van binnen de HTTP-module te wachten.
Gebruik [Find Single Email](/nl/api-reference/email-finder/find-single) of [Verify Single Email](/nl/api-reference/email-verifier/verify-single) voor werk per rij, en het [Find Bulk Emails](/nl/api-reference/email-finder/find-bulk)-endpoint bij het aggregeren van veel rijen. Ze authenticeren allemaal met dezelfde `x-api-key`-header.
## Volgende stappen
Roep het endpoint aan dat je HTTP-module gebruikt om een e-mail te vinden.
Voer tot 5.000 e-mailzoekopdrachten uit in één aanvraag.
Begrijp de async resultaat-payload die Make ontvangt.
Bouw dezelfde automatisering op een self-hosted alternatief.