> ## 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.

# Lead-verificering (n8n)

> Rens og verificer e-maillister før kampagner med et n8n-workflow, der masseverificerer leads via Enrow API og eksporterer en leveringsklar liste

At verificere leads før en kampagne reducerer bounce-rater og beskytter dit afsenderomdømme. Denne playbook bygger et n8n-workflow, der læser en e-mailliste, verificerer hver adresse med [Email Verifier](/da/api-reference/email-verifier/verify-bulk), kategoriserer resultaterne (gyldig, ugyldig, risikabel) og eksporterer en ren liste, der er klar til at sende. Hvis du er ny til n8n med Enrow, så start med [n8n kom godt i gang-guiden](/da/playbooks/n8n/getting-started).

## Hvad bygger du?

Du bygger et workflow, der:

1. **Læser e-maillisten** fra Google Sheets eller CSV
2. **Verificerer hver e-mail** med Enrow
3. **Kategoriserer resultater** (gyldig, ugyldig, risikabel)
4. **Eksporterer en ren liste** klar til kampagner

**Tid at bygge**: 10 minutter
**Sværhedsgrad**: Begynder

## Hvornår bør du bruge dette workflow?

Brug dette workflow, når e-mail-leveringsdygtighed har betydning for en efterfølgende proces. Almindelige anvendelser:

* Rens e-maillister før marketingkampagner
* Verificer formularindsendelser i realtid
* Hold databasen ren
* Reducer bounce-rater

## Hvad har du brug for, før du går i gang?

Før du bygger workflowet, skal du sikre dig, at du har følgende:

* n8n ([hent n8n](https://n8n.io))
* Enrow API-nøgle ([hent nøgle](https://app.enrow.io/settings/api-keys))
* E-mailliste (Google Sheet eller CSV)

Enrow API-nøglen autentificerer hver anmodning via `x-api-key`-headeren. Se [Autentificering](/da/authentication) for, hvordan du henter og videregiver API-nøglen, og [Credits og fakturering](/da/credits-billing) for at forstå, hvordan verificeringscredits forbruges.

## Hvordan opsætter du Google Sheet'et?

Opret et ark med e-mailadresser og tomme kolonner til resultaterne:

| Email                                         | Status | Deliverable | Risk Factors |
| --------------------------------------------- | ------ | ----------- | ------------ |
| [john@example.com](mailto:john@example.com)   |        |             |              |
| [invalid@fake.com](mailto:invalid@fake.com)   |        |             |              |
| [temp@tempmail.com](mailto:temp@tempmail.com) |        |             |              |

## Hvordan bygger du workflowet på 5 minutter?

Den hurtigste vej er at importere et færdigt workflow, konfigurere dine legitimationsoplysninger og køre det.

### Trin 1: Importer workflow

Kopiér og importer dette workflow til n8n:

```json theme={null}
{
  "name": "Enrow - Email Verification",
  "nodes": [
    {
      "parameters": {},
      "name": "Manual Trigger",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "operation": "read",
        "sheetId": "YOUR_SHEET_ID",
        "range": "Sheet1!A:D"
      },
      "name": "Read Email List",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [460, 300]
    },
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "name": "Batch Emails",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 1,
      "position": [680, 300]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.enrow.io/email/verify/bulk",
        "authentication": "headerAuth",
        "sendBody": true,
        "bodyContentType": "json",
        "jsonBody": "={\n  \"emails\": {{$json[\"emails\"].map(e => e.Email)}}\n}"
      },
      "name": "Verify Bulk",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [900, 300],
      "credentials": {
        "headerAuth": {"name": "Enrow API"}
      }
    },
    {
      "parameters": {
        "amount": 10,
        "unit": "seconds"
      },
      "name": "Wait",
      "type": "n8n-nodes-base.wait",
      "typeVersion": 1,
      "position": [1120, 300]
    },
    {
      "parameters": {
        "method": "GET",
        "url": "=https://api.enrow.io/email/verify/bulk?id={{$json[\"batch_id\"]}}",
        "authentication": "headerAuth"
      },
      "name": "Get Results",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [1340, 300],
      "credentials": {
        "headerAuth": {"name": "Enrow API"}
      }
    },
    {
      "parameters": {
        "operation": "update",
        "sheetId": "YOUR_SHEET_ID",
        "range": "Sheet1!A:D"
      },
      "name": "Update Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [1560, 300]
    }
  ],
  "connections": {
    "Manual Trigger": {
      "main": [[{"node": "Read Email List", "type": "main", "index": 0}]]
    },
    "Read Email List": {
      "main": [[{"node": "Batch Emails", "type": "main", "index": 0}]]
    },
    "Batch Emails": {
      "main": [[{"node": "Verify Bulk", "type": "main", "index": 0}]]
    },
    "Verify Bulk": {
      "main": [[{"node": "Wait", "type": "main", "index": 0}]]
    },
    "Wait": {
      "main": [[{"node": "Get Results", "type": "main", "index": 0}]]
    },
    "Get Results": {
      "main": [[{"node": "Update Sheet", "type": "main", "index": 0}]]
    }
  }
}
```

### Trin 2: Konfigurer

1. Erstat `YOUR_SHEET_ID` med dit Google Sheet-ID
2. Tilføj din Enrow API-nøgle til Header Auth-legitimationsoplysningen
3. Test først med nogle få e-mails

### Trin 3: Kør

1. Klik på **"Execute Workflow"**
2. Vent på, at verificeringen er færdig
3. Tjek dit Google Sheet for resultater

## Hvordan bygger du workflowet trin for trin?

Hvis du foretrækker at bygge workflowet node for node, så følg den detaljerede guide nedenfor.

### Trin 1: Læs e-maillisten

**Google Sheets:**

1. Tilføj en **"Google Sheets"**-node
2. Operation: **Read**
3. Vælg dit regneark
4. Range: `Sheet1!A:A` (kun e-mailkolonnen)

**CSV-fil:**

1. Tilføj en **"Read Binary Files"**-node
2. Tilføj en **"CSV to JSON"**-node
3. Map e-mailfeltet

### Trin 2: Opret batches

For bedre ydeevne kan du behandle e-mails i batches:

1. Tilføj en **"Split In Batches"**-node
2. Batch Size: **100** (eller mindre for hurtigere resultater)

Dette sender 100 e-mails ad gangen til Enrow.

### Trin 3: Verificer med Enrow Bulk API

1. Tilføj en **"HTTP Request"**-node
2. Konfigurer:

```javascript theme={null}
Method: POST
URL: https://api.enrow.io/email/verify/bulk
Authentication: Header Auth
  Name: x-api-key
  Value: YOUR_API_KEY

JSON Body:
{
  "emails": {{ $json["items"].map(item => item.Email) }}
}
```

Dette returnerer straks et `batch_id`. Se [Verificer e-mails i bulk](/da/api-reference/email-verifier/verify-bulk) for den fulde reference til anmodning og svar.

### Trin 4: Vent på resultater

Tilføj en **"Wait"**-node med 10-15 sekunders forsinkelse. For store batches skal du vente længere. For hændelsesdrevet hentning i stedet for polling kan du videregive en webhook-URL i anmodningen — se [Sådan fungerer webhooks](/da/how-webhooks-work).

### Trin 5: Hent resultater

1. Tilføj en **"HTTP Request"**-node
2. Konfigurer:

```javascript theme={null}
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
```

Endpointet [Hent bulk-verificeringer](/da/api-reference/email-verifier/get-bulk-verifications) returnerer verificeringsresultaterne for batchen.

### Trin 6: Behandl resultater

Tilføj en **"Function"**-node for at kategorisere e-mails:

```javascript theme={null}
const results = $input.all()[0].json.results;

const valid = results.filter(r =>
  r.status === 'valid' &&
  r.is_deliverable &&
  !r.metadata.is_disposable
);

const invalid = results.filter(r => r.status === 'invalid');

const risky = results.filter(r =>
  r.status === 'risky' ||
  r.metadata.is_disposable ||
  r.metadata.is_role
);

return [
  {
    json: {
      total: results.length,
      valid: valid.length,
      invalid: invalid.length,
      risky: risky.length,
      validEmails: valid.map(r => r.email),
      invalidEmails: invalid.map(r => r.email),
      riskyEmails: risky.map(r => r.email)
    }
  }
];
```

### Trin 7: Opdater Google Sheet

1. Tilføj en **"Google Sheets"**-node
2. Operation: **Update**
3. Map resultaterne tilbage til de oprindelige rækker

Eller opret separate ark for hver kategori:

* **Gyldige e-mails** → Ark "Valid"
* **Ugyldige e-mails** → Ark "Invalid"
* **Risikable e-mails** → Ark "Risky"

## Hvordan verificerer du e-mails fra en formular i realtid?

For at verificere e-mails, når brugere indsender formularer, kan du udløse workflowet med en webhook og verificere hver adresse individuelt:

```mermaid theme={null}
graph LR
    A[Webhook] --> B[Receive Form Data]
    B --> C[Verify Email]
    C --> D{Valid?}
    D -->|Yes| E[Save to CRM]
    D -->|No| F[Reject Submission]
```

### Workflow:

1. **Webhook Trigger**: Modtager formularindsendelser
2. **Extract Email**: Hent e-mail fra formulardata
3. **Verify**: Kald Enrow `/email/verify/single`
4. **Beslutning**:
   * Gyldig → Gem i CRM (Salesforce, HubSpot osv.)
   * Ugyldig → Send fejlsvar eller markér til gennemgang

```javascript theme={null}
// In Function node after verification
if ($json.status === 'valid' && $json.is_deliverable) {
  return [
    {
      json: {
        action: 'accept',
        email: $json.email
      }
    }
  ];
} else {
  return [
    {
      json: {
        action: 'reject',
        email: $json.email,
        reason: 'Invalid or undeliverable email'
      }
    }
  ];
}
```

Verificering af en enkelt adresse bruger endpointet [Verificer enkelt e-mail](/da/api-reference/email-verifier/verify-single). For at sende accepterede leads ind i dit CRM, se integrationerne [HubSpot](/da/integrations/crm/hubspot) og [Salesforce](/da/integrations/crm/salesforce).

## Hvordan eksporterer du den rene liste?

Når resultaterne er kategoriseret, kan du eksportere den rene liste i det format, din stack har brug for.

### Mulighed 1: Google Sheets

Allerede gjort! Resultaterne er i dit ark.

### Mulighed 2: CSV-eksport

1. Tilføj en **"Move Binary Data"**-node
2. Tilføj en **"Write Binary File"**-node
3. Gem til disk eller send via e-mail

### Mulighed 3: Send til e-mailplatform

1. Tilføj en **"HTTP Request"**-node til din e-mailplatforms API
2. Eksempler:
   * **Mailchimp**: Tilføj til audience
   * **SendGrid**: Opdater kontakter
   * **Customer.io**: Synkronisér attributter

## Hvordan sporer du verificeringsmetrikker?

Tilføj en opsummeringsnode for at beregne leveringsmetrikker for hver kørsel:

```javascript theme={null}
// Function node
const results = $input.all()[0].json.results;
const summary = {
  timestamp: new Date().toISOString(),
  total_verified: results.length,
  valid: results.filter(r => r.status === 'valid').length,
  invalid: results.filter(r => r.status === 'invalid').length,
  risky: results.filter(r => r.status === 'risky').length,
  disposable: results.filter(r => r.metadata?.is_disposable).length,
  role_based: results.filter(r => r.metadata?.is_role).length,
  free_provider: results.filter(r => r.metadata?.is_free).length
};

summary.valid_rate = (summary.valid / summary.total_verified * 100).toFixed(2) + '%';
summary.invalid_rate = (summary.invalid / summary.total_verified * 100).toFixed(2) + '%';

return [{ json: summary }];
```

Send denne opsummering til:

* **Slack**: Send opsummering i en kanal
* **Email**: Daglige/ugentlige rapporter
* **Database**: Spor over tid

## Hvordan reducerer du creditforbruget?

Verificering forbruger credits pr. e-mail, så reducer arbejdet før hver kørsel. Tre taktikker holder omkostningerne nede.

### Fjern dubletter før verificering

```javascript theme={null}
// Function node before verification
const emails = $input.all().map(item => item.json.Email);
const unique = [...new Set(emails)];

return unique.map(email => ({ json: { Email: email } }));
```

At fjerne dubletter sparer credits ved kun at verificere hver adresse én gang.

### Cache resultater

Gem verificeringsresultater i 30-90 dage:

```javascript theme={null}
// Check cache before API call
const cached = await redis.get(`verified:${email}`);
if (cached) {
  return JSON.parse(cached);
}

// Call API
const result = await verifyEmail(email);

// Cache result
await redis.setex(`verified:${email}`, 7776000, JSON.stringify(result)); // 90 days

return result;
```

### Spring allerede verificerede over

Verificer kun e-mails med tom status:

```javascript theme={null}
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
```

Se [Credits og fakturering](/da/credits-billing) for creditomkostningen pr. endpoint.

## Bedste praksis

<AccordionGroup>
  <Accordion title="Verificer før kampagner">
    Verificer altid din liste 24-48 timer før afsendelse. E-mailgyldighed kan ændre sig.
  </Accordion>

  <Accordion title="Håndtér risikable e-mails">
    Beslut ud fra anvendelsen:

    * **B2B**: Rolle-e-mails (info@, support@) kan være i orden
    * **B2C**: Afvis engangs-e-mails
    * **Cold outreach**: Brug kun e-mails med høj sikkerhed
  </Accordion>

  <Accordion title="Overvåg leveringsdygtighed">
    Spor bounce-rater efter afsendelse. Hvis de er høje, så verificer din liste igen.
  </Accordion>

  <Accordion title="Regelmæssig oprydning">
    Verificer hele din liste hver 3.-6. måned for at fjerne ugyldige e-mails.
  </Accordion>
</AccordionGroup>

## Fejlfinding

**Tager verificeringen for lang tid?**

* Reducer batch-størrelsen til 50-100 e-mails
* Øg ventetiden mellem batches

**Nogle e-mails vises som "risky"?**

* Tjek `metadata.is_disposable` – kan være midlertidige e-mails
* Gennemgå `metadata.is_catch_all` – accept-all-servere

**Bliver du rate limited?**

* Tilføj forsinkelser mellem batches
* Reducer batch-størrelsen
* Opgradér dit Enrow-abonnement

For anmodningslofter og håndtering af `429`, se [Rate limits](/da/rate-limits). For statuskoder og fejlformater, se [Fejlhåndtering](/da/error-handling).

## FAQ

<AccordionGroup>
  <Accordion title="Hvor mange e-mails kan jeg verificere i én batch?">
    Brug Batch Emails-noden til at behandle e-mails i grupper (eksemplet bruger en batch-størrelse på 100). For meget store lister kan du opdele arbejdet i mindre batches og tilføje en længere ventetid mellem anmodningerne for at undgå at blive rate limited. Se [Rate limits](/da/rate-limits) for anmodningslofterne.
  </Accordion>

  <Accordion title="Hvad betyder statusserne gyldig, ugyldig og risikabel?">
    `valid` betyder, at adressen er leveringsdygtig, `invalid` betyder, at den ville bounce, og `risky` dækker catch-all-, engangs- eller rollebaserede adresser, hvor leveringsdygtigheden er usikker. Brug `metadata`-felterne (`is_disposable`, `is_role`, `is_catch_all`, `is_free`) til at beslutte, hvordan du behandler risikable resultater i din anvendelse.
  </Accordion>

  <Accordion title="Bør jeg verificere en enkelt e-mail eller bruge bulk?">
    Brug [Verificer e-mails i bulk](/da/api-reference/email-verifier/verify-bulk) til lister og planlagt oprydning, og [Verificer enkelt e-mail](/da/api-reference/email-verifier/verify-single) til realtidstjek såsom formularindsendelser.
  </Accordion>

  <Accordion title="Hvordan undgår jeg at spilde credits?">
    Fjern dubletter af adresser før verificering, cache resultater i 30-90 dage, og spring rækker over, der allerede har en status. Se [Credits og fakturering](/da/credits-billing) for omkostninger pr. endpoint.
  </Accordion>
</AccordionGroup>

## Næste skridt

<CardGroup cols={2}>
  <Card title="E-mailberigelse" icon="envelope-circle-check" href="/da/playbooks/n8n/email-enrichment-workflow">
    Find e-mails til dine kontakter med et n8n-workflow.
  </Card>

  <Card title="Verificer e-mails i bulk" icon="code" href="/da/api-reference/email-verifier/verify-bulk">
    Udforsk referencen til bulk-verificerings-endpointet.
  </Card>

  <Card title="Autentificering" icon="key" href="/da/authentication">
    Sådan videregiver du din API-nøgle i x-api-key-headeren.
  </Card>

  <Card title="Webhooks" icon="bell" href="/da/how-webhooks-work">
    Få besked automatisk, når en batch er færdig.
  </Card>
</CardGroup>