> ## 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 med Make
> Byg visuelle no-code-workflows, der finder og verificerer e-mails med Enrow API i Make (tidligere Integromat)
Make (tidligere Integromat) er en visuel automatiseringsplatform, der lader dig bygge no-code Enrow-workflows med en træk-og-slip-grænseflade. Denne guide viser, hvordan du kalder Enrow API fra et Make-scenarie, modtager resultater via en webhook og forgrener på udfaldet — uden server. Autentificer hver forespørgsel med din [API-nøgle](/da/authentication) i `x-api-key`-headeren.
## Hvad er Make?
Make er en visuel automatiseringsplatform, der forbinder apps og API'er via scenarier — kæder af moduler, der kører, når en trigger udløses. Med HTTP-modulet kan du kalde ethvert Enrow-endpoint og derefter dirigere svaret videre til Google Sheets, et CRM eller en notifikation uden at skrive kode. For et administreret alternativ tilbyder Enrow også [native CRM-integrationer](/da/integrations/overview).
## Hvordan kalder jeg Enrow API fra Make?
Byg et scenarie med en trigger, et HTTP-modul der kalder Enrow, og en webhook der opfanger det asynkrone resultat. Følg disse trin.
### Trin 1: Opret et scenarie
1. Gå til [Make.com](https://make.com)
2. Klik på **"Create a new scenario"**
3. Navngiv det "Enrow Email Finder"
### Trin 2: Tilføj en trigger
Vælg, hvad der starter scenariet:
* **Google Sheets**: Overvåg rækker
* **Webhooks**: Brugerdefineret webhook
* **Schedule**: Kør hver time
* **Watch for changes**: I dit CRM
### Trin 3: Tilføj HTTP-modulet til Enrow
1. Klik på **"+"** for at tilføje et modul
2. Søg efter **"HTTP"**
3. Vælg **"Make a request"**
### Trin 4: Konfigurer Enrow API-kaldet
Peg HTTP-modulet mod [Find Single Email](/da/api-reference/email-finder/find-single)-endpointet, og send din API-nøgle med i headerne.
**URL:**
```
https://api.enrow.io/email/find/single
```
**Metode:** 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}}"
}
```
### Trin 5: Tilføj en webhook til resultater
Enrow behandler søgninger asynkront og notificerer en webhook, når hver søgning er færdig. Se [How Webhooks Work](/da/how-webhooks-work) for payload-formatet.
1. Tilføj et **"Webhooks"**-modul som ny trigger
2. Vælg **"Custom webhook"**
3. Kopiér webhook-URL'en
4. Gå tilbage til HTTP-modulet
5. Opdater JSON-body'en, så den inkluderer webhooken:
```json theme={null}
{
"company_domain": "{{1.company_domain}}",
"fullname": "{{1.first_name}} {{1.last_name}}",
"settings": {
"webhook": "YOUR_MAKE_WEBHOOK_URL"
}
}
```
### Trin 6: Behandl resultaterne
Efter at webhooken har modtaget resultater:
1. Tilføj et **"Router"**-modul for at forgrene logikken
2. Gren 1: Gem i Google Sheets
3. Gren 2: Opdater CRM
4. Gren 3: Send notifikation
## Hvilke scenarier kan jeg bygge?
Almindelige Enrow-scenarier kombinerer en trigger, HTTP-modulet og webhooken med efterfølgende apps. Her er tre mønstre at starte fra.
### Scenarie 1: Berig Google Sheets
```
Google Sheets (Watch rows)
→ HTTP (Find email with Enrow)
→ Webhook (Receive results)
→ Google Sheets (Update row)
```
### Scenarie 2: Verificer og tilføj til Mailchimp
```
Typeform (Watch responses)
→ HTTP (Verify email)
→ Filter (Only valid emails)
→ Mailchimp (Add subscriber)
```
### Scenarie 3: Bulk-behandling
```
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)
```
## Hvorfor bruge Make til Enrow?
Make giver dig en visuel byggeflade, indbygget fejlhåndtering og parallel eksekvering — nyttigt, når et Enrow-workflow skal forgrene sig ud i flere apps.
Se hele dit automatiseringsflow visuelt. Perfekt til kompleks logik.
Indbygget fejlhåndtering og genforsøgsmekanismer.
Kraftfulde funktioner og værktøjer til at transformere data mellem trin.
Kør flere stier samtidig med Router-modulet.
## Hvordan bygger jeg effektive Make-scenarier?
Behandl Enrow-resultater i batches, tilføj fejlhåndteringer, og cache resultater for at undgå overflødige kald. Mønstrene nedenfor holder scenarier hurtige og inden for både dine Make-operationer og dine Enrow-[credits](/da/credits-billing).
### Brug Iterator-modulet
Behandl bulk-resultater ét ad gangen:
```
HTTP (Bulk find)
→ Webhook (Receive batch results)
→ Iterator (Loop through results)
→ Google Sheets (Update each row)
```
### Tilføj fejlhåndteringer
1. Højreklik på et hvilket som helst modul
2. Tilføj **"Error handler"**
3. Konfigurer, hvad der sker ved fejl (log, e-mail, genforsøg)
### Brug Data Stores
Cache resultater for at undgå overflødige API-kald:
```
Router
→ Path 1: Check data store for cached email
→ Path 2: If not found, call Enrow API → Save to data store
```
## Hvordan behandler jeg bulk-operationer?
Aggreger rækker i batches, og kald [Find Bulk Emails](/da/api-reference/email-finder/find-bulk)-endpointet (op til 5.000 søgninger pr. batch), og iterer derefter over webhook-resultaterne. Dette behandler 1.000 kontakter i en håndfuld operationer i stedet for én pr. kontakt.
```
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
```
## Hvilke Make-moduler skal jeg bruge til Enrow?
Dette er de moduler, der optræder i de fleste Enrow-scenarier:
| Module | Anvendelse |
| -------------------- | ---------------------------------------- |
| **HTTP** | Kald Enrow API |
| **Webhooks** | Modtag asynkrone resultater |
| **Iterator** | Behandl bulk-resultater |
| **Router** | Forgren logik (gyldig/ugyldig) |
| **Filter** | Spring resultater med lav konfidens over |
| **Data Store** | Cache resultater |
| **Array Aggregator** | Opret batches |
## Hvordan holder jeg operationsforbruget lavt?
Make opkræver pr. operation, så foretræk bulk-endpoints, cache resultater i data stores, og filtrér tidligt for at springe unødvendige trin over. En enkelt bulk-forespørgsel tæller som langt færre operationer end mange enkelte forespørgsler.
**Eksempel:**
* ❌ Dårligt: 1000 enkelte forespørgsler = 1000 operationer
* ✅ Godt: 10 bulk-forespørgsler (100 hver) = 10 operationer
## FAQ
Bekræft, at scenariet er aktivt (ON), tjek at webhook-URL'en i Enrow-feltet `settings.webhook` matcher den, Make genererede, præcist, og test endpointet med et værktøj som Postman først. Se [How Webhooks Work](/da/how-webhooks-work) for payload-formatet.
Skift enkelte kald til [Find Bulk Emails](/da/api-reference/email-finder/find-bulk)-endpointet, cache hyppigt tilgået data i en Data Store, og opgrader din Make-plan, hvis du stadig har brug for flere operationer.
Del et stort scenarie op i mindre, brug planlagte triggere i stedet for øjeblikkelige, og reducer batch-størrelser. Fordi Enrow-søgninger er asynkrone, så lad webhooken levere resultaterne i stedet for at vente inde i HTTP-modulet.
Brug [Find Single Email](/da/api-reference/email-finder/find-single) eller [Verify Single Email](/da/api-reference/email-verifier/verify-single) til arbejde pr. række, og [Find Bulk Emails](/da/api-reference/email-finder/find-bulk)-endpointet når du aggregerer mange rækker. De autentificerer alle med den samme `x-api-key`-header.
## Næste skridt
Kald det endpoint, dit HTTP-modul vil bruge til at finde en e-mail.
Kør op til 5.000 e-mailsøgninger i én forespørgsel.
Forstå den asynkrone resultat-payload, Make modtager.
Byg den samme automatisering på et selvhostet alternativ.