# Geschlecht anhand einer E-Mail-Adresse bestimmen

> Nutzen Sie den Namenshinweis einer E-Mail-Adresse mit GenderAPI.io V2. Testen Sie eine Live-Abfrage, vergleichen Sie die Optionen für Datensatz und KI und erfahren Sie, wie Sie unbekannte Ergebnisse und E-Mail-Listen verarbeiten.

Canonical HTML: https://www.genderapi.io/de/determine-gender-from-email

Last reviewed: 2026-09-28

## Was verrät eine E-Mail-Adresse?

Senden Sie eine syntaktisch gültige E-Mail-Adresse mit type: email. GenderAPI.io sucht im Teil vor dem @ nach einem Namenshinweis und liefert dann eine strukturierte Vorhersage. Das Postfach wird dabei weder verifiziert noch einem Inhaber zugeordnet, und die Geschlechtsidentität dieser Person wird nicht festgestellt.

Der Abgleich mit dem Datensatz leitet Kandidaten aus Bestandteilen ab und kann begrenzte Teilstrings prüfen. Der Spitznamenmodus behält den Abgleich ganzer Bestandteile bei, fügt aber keine solchen Teilstring-Kandidaten hinzu. Passen mehrere Einträge, wird der Kandidat mit der größten gespeicherten Gesamtzahl ausgewählt; das muss nicht der gemeinte Vorname sein. Prüfen Sie data.name und data.match, bevor Sie einen extrahierten Namen in einem Kontaktdatensatz verwenden.

| Beispieleingabe | Einordnung |
| --- | --- |
| `alice.smith@example.com` | Der lokale Teil enthält mögliche Namensbestandteile. Ein Treffer ist möglich, doch die Eingabe allein legt nicht fest, welcher Kandidat ausgewählt wird. |
| `alice+news@example.com` | Die Datensatzabfrage entfernt für ihre Kandidaten den Zusatz nach dem Pluszeichen. Die KI wird angewiesen, ihn zu ignorieren, erhält aber den übermittelten Wert. |
| `support@example.com` | Eine Funktionsadresse liefert keinen verlässlichen Hinweis auf einen Personennamen. Weisen Sie dem gesamten gemeinsamen Postfach nicht das Geschlecht einer Person zu. |
| `prenses@example.com` | Das optionale forceToGenderize erlaubt einen Versuch anhand der Bedeutung eines Spitznamens, wenn der Datensatz kein Ergebnis liefert. Ein echter Name ist in diesem Modus nicht erforderlich. |
| `not-an-email` | Eine ungültige Syntax liefert einen Validierungsfehler statt eines erfolgreichen unbekannten Ergebnisses. |

## Eine E-Mail-Abfrage aus Ihrer Anwendung senden

Dieses Beispiel verwendet Ihren vorhandenen API-Schlüssel im Bearer-Header und setzt fallback ausdrücklich. Ersetzen Sie die Beispieladresse durch eine Eingabe, die Sie verarbeiten dürfen. Geben Sie country nur an, wenn Sie relevanten Kontext haben; die E-Mail-Domain belegt nicht den Aufenthaltsort einer Person. Ohne Länderkontext lassen Sie dieses Feld weg.

Führen Sie das Beispiel auf Ihrem Server aus, nachdem Sie GENDERAPI_API_KEY gesetzt haben. POST hält die E-Mail-Adresse aus der Anfrage-URL heraus. Das Live-Ergebnis kann von der beispielhaften Antwort in der Demo abweichen.

Führen Sie diese Beispiele auf Ihrem Server aus. Setzen Sie GENDERAPI_API_KEY in der Prozessumgebung auf Ihren vorhandenen API-Schlüssel. Prüfen Sie, ob meta.access.mode den Wert api_key hat: Ein nicht erkannter Schlüssel kann in den IP-Testzugang wechseln.

Jede Vorhersageanfrage ist ein neuer kostenpflichtiger Vorgang, auch bei Wiederholungen. Diese Beispiele wiederholen Anfragen nicht automatisch. Prüfen Sie den Abrechnungsstatus, bevor Sie eine weitere Anfrage senden.

Bei HTTP-4xx- und -5xx-Antworten im JSON-Format bleibt der Fehlerinhalt erhalten, und das Beispiel endet mit einem Exit-Status ungleich null. Prüfen Sie code, action und meta.usage.billing_status, bevor Sie die Anfrage wiederholen.

**cURL**

cURL 7.76+ in einer POSIX-Shell. Im Terminal ausführen.

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "type": "email",
  "value": "alice.smith@example.com",
  "country": "US",
  "options": {
    "ai_mode": "fallback"
  }
}'
```

**JavaScript / Node.js**

Node.js 22+; integriertes fetch. Als example.mjs speichern und node example.mjs ausführen.

```javascript
// Server-side Node.js. Save as example.mjs.
const apiKey = process.env.GENDERAPI_API_KEY;
if (!apiKey) throw new Error("Set GENDERAPI_API_KEY");
const body = {
  "type": "email",
  "value": "alice.smith@example.com",
  "country": "US",
  "options": {
    "ai_mode": "fallback"
  }
};

const response = await fetch("https://api.genderapi.io/api/v2/gender", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
  signal: AbortSignal.timeout(30_000),
  redirect: "error",
});
const raw = await response.text();
if (!(response.headers.get("content-type") ?? "").includes("json")) {
  throw new Error(`HTTP ${response.status}: expected JSON; request ID ${response.headers.get("x-request-id")}`);
}
const result = JSON.parse(raw); // Also accepts application/problem+json.
if (!response.ok) {
  console.error(`HTTP ${response.status}`, result);
  process.exitCode = 1; // A retry is a new operation; inspect billing first.
} else {
  console.log(JSON.stringify(result, null, 2));
  // For batches, inspect every item: HTTP 200 may contain item errors.
}
```

**Python**

Python 3.10+; Standardbibliothek. Als example.py speichern und python3 example.py ausführen.

```python
import json
import os
import sys
import urllib.error
import urllib.request

api_key = os.environ.get("GENDERAPI_API_KEY")
if not api_key:
    raise RuntimeError("Set GENDERAPI_API_KEY")
body = json.loads("{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\",\"options\":{\"ai_mode\":\"fallback\"}}")

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

request = urllib.request.Request(
    "https://api.genderapi.io/api/v2/gender",
    method="POST",
    data=json.dumps(body).encode("utf-8"),
    headers={
        "Authorization": "Bearer " + api_key,
        "Content-Type": "application/json",
    },
)
opener = urllib.request.build_opener(NoRedirect())
try:
    response = opener.open(request, timeout=30)
except urllib.error.HTTPError as error:
    response = error  # Keep the Problem Details body on non-2xx responses.
with response:
    status = response.status
    raw = response.read().decode("utf-8")
    if "json" not in response.headers.get("Content-Type", ""):
        raise RuntimeError(f"HTTP {status}: expected a JSON response")
    result = json.loads(raw)
print(json.dumps(result, indent=2), file=sys.stderr if status >= 300 else sys.stdout)
if not 200 <= status < 300:
    sys.exit(1)  # Inspect code, action and billing before retrying.
# For batches, inspect every item even when HTTP status is 200.
```

**PHP**

PHP 8+ mit der cURL-Erweiterung. Als example.php speichern und php example.php ausführen.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"type":"email","value":"alice.smith@example.com","country":"US","options":{"ai_mode":"fallback"}}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($body, JSON_THROW_ON_ERROR),
]);
$raw = curl_exec($ch);
if ($raw === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE) ?: '';
curl_close($ch);
if (strpos($contentType, 'json') === false) {
    throw new RuntimeException("HTTP $status: expected a JSON response");
}
$result = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
$output = json_encode($result, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR) . PHP_EOL;
if ($status < 200 || $status >= 300) {
    fwrite(STDERR, $output); // Preserve the Problem Details body.
    exit(1);
}
echo $output;
// For batches, inspect every item; HTTP 200 can contain item errors.
```

**Java**

Java 17+; Standard-HTTP-Client. Als GenderApiExample.java speichern und java GenderApiExample.java ausführen.

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

public class GenderApiExample {
    private static String requiredEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.isBlank()) throw new IllegalStateException("Set " + name);
        return value;
    }

    public static void main(String[] args) throws Exception {
        String apiKey = requiredEnv("GENDERAPI_API_KEY");
        String body = "{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\",\"options\":{\"ai_mode\":\"fallback\"}}";
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NEVER)
            .build();
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.genderapi.io/api/v2/gender"))
            .timeout(Duration.ofSeconds(30))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8))
            .build();
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        if (!response.headers().firstValue("content-type").orElse("").contains("json")) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": expected JSON");
        }
        // JSON text; parse with your application's JSON library when integrating.
        if (response.statusCode() < 200 || response.statusCode() >= 300) {
            System.err.println(response.body()); // Includes Problem Details.
            System.exit(1);
        }
        System.out.println(response.body());
        // For batches, inspect each item's data or error, including on HTTP 200.
    }
}
```

**C# / .NET**

Konsolenanwendung mit .NET 8+. Als Program.cs in einem Konsolenprojekt verwenden und dann dotnet run ausführen.

```csharp
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

string RequiredEnv(string name) =>
    !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(name))
        ? Environment.GetEnvironmentVariable(name)!
        : throw new InvalidOperationException($"Set {name}");

var apiKey = RequiredEnv("GENDERAPI_API_KEY");
using var handler = new HttpClientHandler { AllowAutoRedirect = false };
using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) };
using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.genderapi.io/api/v2/gender");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\",\"options\":{\"ai_mode\":\"fallback\"}}", Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);
var raw = await response.Content.ReadAsStringAsync();
if (!(response.Content.Headers.ContentType?.MediaType?.Contains("json") ?? false))
    throw new InvalidOperationException($"HTTP {(int)response.StatusCode}: expected JSON");
using var result = JsonDocument.Parse(raw);
if (!response.IsSuccessStatusCode)
{
    Console.Error.WriteLine(result.RootElement); // Preserve Problem Details.
    Environment.ExitCode = 1;
}
else
{
    Console.WriteLine(result.RootElement);
    // For batches, inspect every item even on HTTP 200.
}
```

**Go**

Go 1.22+; Standardbibliothek. Als main.go speichern und go run main.go ausführen.

```go
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "time"
)

func requiredEnv(name string) string {
    value := os.Getenv(name)
    if value == "" { panic("Set " + name) }
    return value
}

func run() error {
    apiKey := requiredEnv("GENDERAPI_API_KEY")
    body := "{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\",\"options\":{\"ai_mode\":\"fallback\"}}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender", strings.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + apiKey)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{
        Timeout: 30 * time.Second,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        },
    }
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    raw, err := io.ReadAll(response.Body)
    if err != nil { return err }
    if !strings.Contains(response.Header.Get("Content-Type"), "json") || !json.Valid(raw) {
        return fmt.Errorf("HTTP %d: expected a JSON response", response.StatusCode)
    }
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, raw)
    }
    fmt.Println(string(raw))
    // For batches, inspect every item even on HTTP 200.
    return nil
}

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err) // Keep Problem Details for error handling.
        os.Exit(1)
    }
}
```

- [Vollständige V2-Referenz für E-Mail-Adressen](https://www.genderapi.io/de/docs/v2/gender-from-email)

## Ergebnis und Belege gemeinsam aufbewahren

Eine abgeleitete Zuordnung ist nicht das Geschlecht, das eine Person selbst angibt. Bewahren Sie die ursprüngliche Eingabe, die zurückgegebenen Belege und alle Angaben der Person selbst getrennt auf. Ein unbekanntes Ergebnis ist ein gültiges Ergebnis; es sollte in Ihrer Anwendung nicht zu einer geratenen Kategorie werden.

| Feld | Verwendung |
| --- | --- |
| `data.gender / data.result_status` | Verwenden Sie male oder female nur bei identified. Behalten Sie bei einem unbekannten Ergebnis den nativen JSON-Wert null bei. |
| `data.name / data.match` | Prüfen Sie den zurückgegebenen Namen und den ausgewählten Kandidaten. Ein Treffer über einen Teilstring belegt nicht, dass die Eingabe zu einer Person mit diesem Vornamen gehört. |
| `data.confidence / data.confidence_kind` | Die Konfidenz liegt auf einer Skala von 0–1 oder ist null. observed_frequency beruht auf gespeicherten Häufigkeiten; model_reported ist ein KI-Wert. Bewerten Sie Schwellenwerte für jede Art getrennt. |
| `data.source / data.sample_count` | Unterscheiden Sie dataset, ai und none. KI-Ergebnisse haben keine gespeicherte Stichprobengröße. Eine Stichprobengröße ist kein gemessener Genauigkeitswert. |
| `meta.access.mode` | Prüfen Sie bei einer Kontointegration, ob api_key gemeldet wird. Fehlende oder nicht erkannte Schlüssel können stattdessen den gemeinsamen IP-Testzugang nutzen. |
| `meta.usage` | Lesen Sie charged_credits und billing_status. Ein erfolgreiches unbekanntes Ergebnis ist kostenpflichtig. Eine verlorene Antwort belegt nicht, dass die Anfrage kostenlos war. |

- [Antwortfelder und unbekannte Ergebnisse](https://www.genderapi.io/de/docs/v2/responses)
- [Genauigkeit und Konfidenz erklärt](https://www.genderapi.io/de/accuracy-methodology)
- [Datenquellen und das datierte Datenbankprofil](https://www.genderapi.io/de/data-provenance)

## Festlegen, wann KI eingesetzt wird

forceToGenderize ist für Namen, E-Mail-Adressen und Benutzernamen optional. Ist es aktiviert, lassen Sie ai_mode weg oder verwenden Sie fallback; off und always sind damit unvereinbar und liefern 422. Ein positives Anfangsguthaben genügt, um eine Anfrage zu starten, auch wenn die endgültige Abbuchung das Guthaben unter null senkt.

Der Spitznamenmodus kann ein Geschlecht zusammen mit name: null zurückgeben. Er kann auch ein unbekanntes Ergebnis liefern. Weder der gewöhnliche KI-Fallback noch die Spitznamen-Auswertung garantieren eine richtige Antwort oder einen Wert ungleich null.

| Anfrageoption | Verhalten | Credits für eine erfolgreiche Abfrage |
| --- | --- | --- |
| options.ai_mode: off | Nur den Datensatz verwenden. | 1, auch bei einem unbekannten Ergebnis |
| options.ai_mode: fallback | Zuerst den Datensatz prüfen, dann gewöhnliche KI, wenn kein Geschlecht zurückgegeben wird. Das ist der Standard für Einzelanfragen. | Insgesamt 1, einschließlich KI-Fallback |
| options.ai_mode: always | Direkt KI verwenden. | 2 |
| forceToGenderize: true | Zuerst den Datensatz prüfen, dann KI einen persönlichen Spitznamen oder Alias auswerten lassen, auch ohne echten Vornamen. | 1 für ein im Datensatz aufgelöstes Ergebnis; insgesamt 2, wenn KI eingesetzt wird |

- [KI-Optionen und Spitznamen-Auswertung](https://www.genderapi.io/de/docs/v2/ai-options)
- [Credits und Nutzung](https://www.genderapi.io/de/docs/v2/credits-and-usage)

## Eine E-Mail-Liste in Batches verarbeiten

Verwenden Sie POST /api/v2/gender/batch mit einem items-Array aus Einträgen mit type: email. Der Zugang mit registriertem API-Schlüssel unterstützt bis zu 50 Einträge, der IP-Testzugang bis zu 10. Behalten Sie für jeden Eintrag eine eindeutige id, damit Sie die Ergebnisse der ursprünglichen Zeile zuordnen können. Die Antwort behält außerdem die Eingabereihenfolge bei und meldet index.

Batch-Einträge nutzen standardmäßig nur den Datensatz. Setzen Sie options.ai_mode: fallback bei jedem Eintrag, der den gewöhnlichen KI-Fallback benötigt. Zwei erfolgreiche Einträge mit fallback kosten insgesamt 2 Credits, auch bei unbekannten Ergebnissen; eine HTTP-Anfrage entspricht nicht einem Credit pro Vorhersage.

Prüfen Sie jeden Eintrag, auch wenn der Batch HTTP 200 zurückgibt. Speichern Sie erfolgreiche und unbekannte Ergebnisse und prüfen Sie dann Fehler und die bestätigte Abrechnung, bevor Sie fehlgeschlagene Einträge erneut senden. Senden Sie nach einer Zeitüberschreitung keinen erfolgreichen Batch vollständig erneut, ohne das Abrechnungsergebnis zu prüfen.

- [Batch-Beispiele, Limits und Teilfehler](https://www.genderapi.io/de/docs/v2/batch)

## Wissen, was Sie senden

Die Live-Demo sendet den eingegebenen Wert erst dann an GenderAPI.io, wenn Sie ihn absenden. Wird KI eingesetzt, gehen der übermittelte type, der value und der Länderkontext an den konfigurierten Inferenzdienst. Für eine Vorhersage nur mit dem Datensatz verwenden Sie in Ihrer Integration options.ai_mode: off ohne forceToGenderize.

Die Datenschutzerklärung, der Auftragsverarbeitungsvertrag und das Verzeichnis der Unterauftragsverarbeiter beschreiben die veröffentlichten Verarbeitungsbedingungen. Ein Ergebnis ist eine abgeleitete Zuordnung; Angaben der Person selbst haben Vorrang. Nutzen Sie es nicht als Grundlage für folgenreiche Entscheidungen über eine Person.

- [Datenschutzerklärung](https://www.genderapi.io/de/privacy-policy)
- [Auftragsverarbeitungsvertrag](https://www.genderapi.io/de/data-processing-agreement)
- [Verzeichnis der Unterauftragsverarbeiter](https://www.genderapi.io/de/subprocessors)

## Kann die API einen Vornamen aus einer E-Mail-Adresse extrahieren?

Sie kann einen Namenskandidaten zurückgeben, wenn der lokale Teil einen verwertbaren Hinweis enthält. Treffer über ganze Bestandteile und über Teilstrings sind möglich; prüfen Sie daher data.match. Das Ergebnis belegt nicht den Vornamen der Person, der das Postfach gehört.

## Liefern info@ oder support@ ein Geschlecht?

Gemeinsam genutzte Funktionsadressen liefern in der Regel keinen Beleg für einen Personennamen. Ein unbekanntes Ergebnis ist gültig. KI oder der Spitznamenmodus sollten nicht als Bestätigung für die Personen gelten, die ein gemeinsames Postfach nutzen.

## Verbraucht ein unbekanntes Ergebnis für eine E-Mail-Adresse Credits?

Ja. Eine erfolgreiche gewöhnliche E-Mail-Abfrage kostet 1 Credit, einschließlich KI-Fallback und unbekannter Ergebnisse. Die erzwungene Spitznamen-Auswertung kostet 1 Credit für ein im Datensatz aufgelöstes Ergebnis oder insgesamt 2, wenn KI eingesetzt wird. Für Fehler wird das Abrechnungsergebnis separat in meta.usage gemeldet.

## Wird die E-Mail-Domain vor der Verarbeitung durch die KI entfernt?

Eine solche Entfernung wird nicht zugesagt. Kandidaten aus dem Datensatz stammen aus dem lokalen Teil, während die KI den übermittelten Wert erhält und angewiesen wird, die Domain und den Zusatz nach dem Pluszeichen zu ignorieren. Verwenden Sie den Modus nur mit dem Datensatz, wenn Ihr Ablauf das erfordert.