EmailVerify LogoEmailVerify

Quickstart

Get started with email checker API in 5 minutes. Free API key, code examples, and email verification integration guide.

Starten Sie mit der EmailVerify API in nur 5 Minuten. Diese Anleitung führt Sie durch die Verifizierung Ihrer ersten E-Mail-Adresse.

Voraussetzungen

Bevor Sie beginnen, benötigen Sie:

  • Ein EmailVerify-Konto (Kostenlos registrieren)
  • Grundkenntnisse über HTTP-Anfragen oder Vertrautheit mit einer unserer unterstützten Sprachen

Schritt 1: Konto erstellen

  1. Besuchen Sie EmailVerify und klicken Sie auf Jetzt starten
  2. Registrieren Sie sich mit Ihrer E-Mail oder Ihrem Google/GitHub-Konto
  3. Verifizieren Sie Ihre E-Mail-Adresse

Schritt 2: API-Schlüssel abrufen

  1. Melden Sie sich in Ihrem EmailVerify Dashboard an
  2. Navigieren Sie zum Abschnitt API-Schlüssel
  3. Klicken Sie auf Neuen Schlüssel erstellen
  4. Geben Sie Ihrem Schlüssel einen aussagekräftigen Namen (z. B. "Entwicklung", "Produktion")
  5. Kopieren Sie Ihren API-Schlüssel und speichern Sie ihn sicher

Geben Sie Ihren API-Schlüssel niemals in clientseitigem Code oder öffentlichen Repositories preis. Verwenden Sie Umgebungsvariablen, um Ihren Schlüssel sicher zu speichern.

Schritt 3: Ihre erste E-Mail verifizieren

Wählen Sie Ihre bevorzugte Methode für Ihre erste Verifizierungsanfrage:

curl -X POST https://api.emailverify.ai/v1/verify \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "test@example.com"}'
const response = await fetch('https://api.emailverify.ai/v1/verify', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    email: 'test@example.com',
  }),
});

const result = await response.json();
console.log(result);
import os
import requests

response = requests.post(
    'https://api.emailverify.ai/v1/verify',
    headers={
        'Authorization': f'Bearer {os.environ["EMAILVERIFY_API_KEY"]}',
        'Content-Type': 'application/json',
    },
    json={'email': 'test@example.com'}
)

result = response.json()
print(result)
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    data := map[string]string{"email": "test@example.com"}
    body, _ := json.Marshal(data)

    req, _ := http.NewRequest("POST",
        "https://api.emailverify.ai/v1/verify",
        bytes.NewBuffer(body))

    req.Header.Set("Authorization", "Bearer "+os.Getenv("EMAILVERIFY_API_KEY"))
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}
<?php
$apiKey = getenv('EMAILVERIFY_API_KEY');

$ch = curl_init('https://api.emailverify.ai/v1/verify');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode(['email' => 'test@example.com']),
]);

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result);

Schritt 4: Die Antwort verstehen

Eine erfolgreiche Verifizierung gibt eine Antwort wie diese zurück:

{
  "email": "test@example.com",
  "status": "valid",
  "result": {
    "deliverable": true,
    "valid_format": true,
    "valid_domain": true,
    "valid_mx": true,
    "disposable": false,
    "role": false,
    "catchall": false,
    "free": false,
    "smtp_valid": true
  },
  "score": 0.95,
  "credits_used": 1
}

Wichtige Antwortfelder

FeldTypBeschreibung
statusstringGesamtstatus: valid, invalid, unknown oder accept_all
deliverablebooleanOb die E-Mail Nachrichten empfangen kann
disposablebooleanOb es sich um eine temporäre/Einweg-E-Mail handelt
rolebooleanOb es sich um eine rollenbasierte Adresse handelt (info@, support@)
catchallbooleanOb die Domain alle E-Mails akzeptiert
scorenumberKonfidenzbewertung von 0 bis 1 (höher ist besser)

Statuswerte erklärt

StatusBedeutungEmpfohlene Aktion
validE-Mail existiert und kann Nachrichten empfangenSicher zu senden
invalidE-Mail existiert nicht oder kann keine Nachrichten empfangenVon Liste entfernen
unknownStatus konnte nicht ermittelt werdenSpäter erneut versuchen oder mit Vorsicht verwenden
accept_allDomain akzeptiert alle E-Mails (Catch-All)Auf Bounces überwachen

Schritt 5: Ein SDK verwenden (empfohlen)

Für eine einfachere Integration installieren Sie eines unserer offiziellen SDKs:

npm install @emailverify/node
import { EmailVerify } from '@emailverify/node';

const client = new EmailVerify({
  apiKey: process.env.EMAILVERIFY_API_KEY,
});

const result = await client.verify('test@example.com');
console.log(result.status); // 'valid'
pip install emailverify
from emailverify import Client
import os

client = Client(api_key=os.environ['EMAILVERIFY_API_KEY'])
result = client.verify('test@example.com')
print(result.status)  # 'valid'
go get github.com/emailverify/go-sdk
import emailverify "github.com/emailverify/go-sdk"

client := emailverify.NewClient(os.Getenv("EMAILVERIFY_API_KEY"))
result, err := client.Verify(ctx, "test@example.com")
fmt.Println(result.Status) // "valid"
composer require emailverify/php-sdk
use EmailVerify\Client;

$client = new Client(getenv('EMAILVERIFY_API_KEY'));
$result = $client->verify('test@example.com');
echo $result->status; // 'valid'
<dependency>
    <groupId>com.emailverify</groupId>
    <artifactId>emailverify-java</artifactId>
    <version>1.0.0</version>
</dependency>
import com.emailverify.Client;

Client client = new Client(System.getenv("EMAILVERIFY_API_KEY"));
VerificationResult result = client.verify("test@example.com");
System.out.println(result.getStatus()); // "valid"

Wie geht es weiter?

Nachdem Sie Ihre erste E-Mail verifiziert haben, erkunden Sie weitere Funktionen:

Häufige Anwendungsfälle

Formularvalidierung

Verifizieren Sie E-Mails in Echtzeit während der Benutzerregistrierung:

const onEmailBlur = async (email) => {
  const result = await client.verify(email);

  if (result.status === 'invalid') {
    showError('Bitte geben Sie eine gültige E-Mail ein');
  } else if (result.result.disposable) {
    showError('Einweg-E-Mails sind nicht erlaubt');
  }
};

Listenbereinigung

Bereinigen Sie Ihre E-Mail-Liste vor dem Versenden von Kampagnen:

for email in email_list:
    result = client.verify(email)
    if result.status == 'valid':
        clean_list.append(email)
    else:
        remove_list.append(email)

Lead-Qualifizierung

Bewerten Sie Leads basierend auf der E-Mail-Qualität:

const qualifyLead = (verificationResult) => {
  let score = verificationResult.score * 50; // Basisbewertung

  if (!verificationResult.result.free) score += 20;      // Geschäftliche E-Mail
  if (!verificationResult.result.role) score += 15;      // Persönliche Adresse
  if (!verificationResult.result.disposable) score += 15; // Permanente E-Mail

  return score;
};

Benötigen Sie Hilfe?

On this page