# Geschlechtsvorhersage anhand von Benutzernamen und Spitznamen

> Benutzernamen und Spitznamen mit V2 analysieren: forceToGenderize, KI pro Eintrag, unbekannte Ergebnisse und die Kosten von Wiederholungen.

Canonical HTML: https://www.genderapi.io/de/blog/geschlechtserkennung-anhand-von-benutzernamen-und-spitznamen

Last reviewed: 2026-09-28

## Angaben zur Veröffentlichung

Erstveröffentlichung: 2025-06-04T13:00:00.000Z

Zuletzt geprüft: 2026-09-28T00:00:00.000Z

## Kann man das Geschlecht anhand eines Benutzernamens bestimmen?

GenderAPI kann Namenssignale in einem Benutzernamen, Spitznamen oder Anzeigenamen analysieren, wenn kein echter Vorname verfügbar ist. Verwenden Sie die Einzel- oder Batch-API oder den Excel/CSV-Ablauf und behandeln Sie das Ergebnis als Vorhersage, nicht als verifizierte Identität.

## Ein Spitzname ist keine Identitätsprüfung

@alice_smith kann zu einem Namensbestandteil passen. Bei prenses mit forceToGenderize kann eine Vorhersage zurückgegeben werden, obwohl der Name null bleibt. user47291kann unbekannt bleiben. Dies sind Beispieleingaben; wir ordnen ihnen vorab kein Geschlechtsergebnis zu.

## Wie funktioniert die Geschlechtsvorhersage anhand eines Benutzernamens?

Das System prüft erkennbare Namensbestandteile und andere sprachliche Hinweise im Benutzernamen oder Anzeigenamen. Die Standard-KI sucht einen brauchbaren echten Vornamen; mit forceToGenderize kann sie einen Spitznamen ohne echten Vornamen auswerten. Das Ergebnis wird zusammen mit Kontextfeldern zurückgegeben; zufällige oder unzureichende Eingaben sollten nicht zu einem Ergebnis gezwungen werden.

- Benutzername: Spitzname oder Anzeigename
- Signalanalyse: Vorname und Kontext
- Vorhersage: Geschlecht und Konfidenz

## Wählen Sie die Methode, die zu Ihren Daten passt

- [Einzelanfrage Einen Benutzernamen per REST API analysieren. API-Leitfaden ansehen →](https://www.genderapi.io/de/docs/v2/gender-from-username)
- [Batch-Anfrage Mehrere Datensätze in einer strukturierten Anfrage senden. Batch-Leitfaden ansehen →](https://www.genderapi.io/de/docs/v2/batch)
- [Excel/CSV-Ablauf Eine Datei verarbeiten, ohne eine Integration zu erstellen. Werkzeug öffnen →](https://app.genderapi.io/csv)

## Benutzernamen aus einer Excel- oder CSV-Datei in vier Schritten analysieren

### Excel/CSV-Werkzeug öffnen

Öffnen Sie das Import-Werkzeug von GenderAPI und laden Sie die zu verarbeitende Datei hoch.

### Quellspalte wählen

Ordnen Sie die Spalte mit Benutzernamen, Spitznamen oder Anzeigenamen zu.

### Spitznamen-Auswertung aktivieren

Aktivieren Sie die Option, die Aliase und in sozialen Medien verwendete Namen auswertet.

### Stichprobe prüfen und dann exportieren

Prüfen Sie zuerst eine repräsentative Auswahl von Datensätzen, verarbeiten Sie anschließend die gesamte Datei und laden Sie die angereicherten Daten herunter.

Neue Konten enthalten täglich 200 kostenlose API-Credits, sodass Sie den Ablauf an einer Stichprobe prüfen können, bevor Sie die gesamte Datei verarbeiten.

Hochgeladene Excel- und CSV-Dateien werden innerhalb von fünf Tagen aus den aktiven Systemen entfernt, und nach dem Export der Ergebnisse können Sie eine frühere Entfernung verlangen. Fortlaufend überschriebene, zugriffsbeschränkte Sicherungskopien können sie bis zu 15 weitere Tage enthalten. Einzelheiten finden Sie in der [Datenschutzerklärung](https://www.genderapi.io/de/privacy-policy).

## Als unterstützendes Signal nutzen, wenn ein echter Vorname fehlt

Die Analyse von Benutzernamen kann bei Daten aus sozialen Medien, Communitys, Spielen und von Nutzern erstellten Profilen hilfreich sein, wenn das Namensfeld leer ist. Haben Sie eine direktere und zulässige Quelle wie einen echten Vornamen oder eine E-Mail-Adresse, verwenden Sie den passenden Endpunkt.

- [Vornamen und Geschlechtssignal aus einer E-Mail-Adresse extrahieren](https://www.genderapi.io/de/blog/namen-aus-e-mail-adressen-extrahieren)
- [Excel- und CSV-Dateien im Batch verarbeiten](https://www.genderapi.io/de/blog/determining-gender-of-names-in-excel-csv-with-gender-api)

## Das Ergebnis nicht als verifizierte Identität behandeln

Nicht jeder Spitzname enthält einen echten Vornamen, kulturelle Assoziationen unterscheiden sich, und derselbe Ausdruck kann je nach Sprache Unterschiedliches bedeuten. Ist das Signal unzureichend, akzeptieren Sie ein leeres Ergebnis, statt schwache Daten in eine endgültige Schlussfolgerung zu verwandeln.

Speichern Sie die Felder zu Konfidenz und Quelle aus V2 gemeinsam, messen Sie die Leistung mit Ihren eigenen Daten und stützen Sie keine Entscheidung mit großer Tragweite für eine bestimmte Person auf dieses Signal, etwa zu Beschäftigung, Kredit oder Gesundheit.

## Quelldaten und Vorhersage getrennt speichern

Bewahren Sie die ursprüngliche Kennung des Datensatzes auf. Die API öffnet kein Profil, prüft nicht, wem ein Konto gehört, und bestätigt keine Identität. Senden Sie einen Länderkontext nur, wenn Sie eine verlässliche Angabe haben; leiten Sie ihn nicht aus der Domain oder der Sprache der Website ab.

Senden Sie den Benutzernamen mit type: username; senden Sie keine Profil-URL. Die Suche im Datensatz entfernt ein führendes @, normalisiert den Text und bildet Kandidaten anhand von Trennzeichen und Ziffern. Eine Standardanfrage kann eine begrenzte Anzahl von Treffern nach Präfix und Suffix ergänzen; forceToGenderize nutzt diese zusätzlichen Fragmente nicht. Passen mehrere Einträge, wird der mit der höchsten erfassten Anzahl gewählt. Verwenden Sie für E-Mail-Adressen type: email und für echte Namen type: name.

| Beispieleingabe | Feld oder Option | Interpretation |
| --- | --- | --- |
| @alice_smith | data.name / data.match | Bewahren Sie den ursprünglichen Benutzernamen auf; behandeln Sie das gefundene Fragment nicht als verifizierten Vornamen. |
| prenses | forceToGenderize: true | Erlaubt die Auswertung eines Spitznamens ohne echten Vornamen. Ein Geschlecht kann bei data.name gleich null zurückgegeben werden; erfinden Sie für diese Person keinen Namen. |
| user47291 | data.result_status: unknown | Undurchsichtige oder unzureichende Eingaben können unbekannt bleiben. Das ist kein Grund für eine automatische Wiederholung der Anfrage. |

### Verarbeitungsmodus und Kosten in Credits wählen

Bei einer Einzelanfrage ist fallback der Standardwert, bei Batch-Einträgen off. forceToGenderize ist für Namen, E-Mail-Adressen und Benutzernamen optional; lassen Sie in diesem Fall ai_mode weg oder verwenden Sie fallback, denn diese Option ist nicht mit off und always kombinierbar. Auch erfolgreiche unknown-Ergebnisse werden berechnet. Für den Start genügt ein positives Anfangsguthaben; nach Abschluss des Vorgangs kann das Guthaben unter null fallen.

| Option | Verarbeitung | Kosten pro erfolgreichem Eintrag |
| --- | --- | --- |
| options.ai_mode: off | Nur Datensatz | 1 Credit |
| options.ai_mode: fallback | Zuerst der Datensatz; wird kein Geschlecht ermittelt, die Standard-KI | Insgesamt 1 Credit, einschließlich KI |
| options.ai_mode: always | Direkt KI | 2 Credits |
| forceToGenderize: true | Zuerst der Datensatz, danach die Auswertung des Spitznamens ohne Voraussetzung eines echten Vornamens | 1, wenn der Datensatz genügt; insgesamt 2, wenn KI eingesetzt wird |

### Jedem Batch-Eintrag eigene Optionen zuweisen

Die Beispieleingaben garantieren keine bestimmte Vorhersage. Setzen Sie GENDERAPI_API_KEY in der Serverumgebung und legen Sie den Schlüssel nicht in öffentlichem clientseitigem Code ab. V1 und V2 verwenden denselben Kontoschlüssel und dasselbe Guthaben. Prüfen Sie den Schlüssel mit /api/v2/usage und stellen Sie sicher, dass meta.access.mode den Wert api_key hat.

Wählen Sie eine Programmiersprache. [Richten Sie Ihren API-Schlüssel ein](https://www.genderapi.io/de/docs/v2/authentication#environment-setup), und führen Sie dann das Beispiel auf Ihrem Server aus.

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.

### Vor der Ausführung: Zugang und Fehlerbehandlung

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.

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. Prüfen Sie bei Batch-Antworten mit HTTP 200 außerdem data oder error jedes Eintrags.

**cURL**

cURL 7.76+ in einer POSIX-Shell. Im Terminal ausführen. [Dokumentation der Laufzeitumgebung](https://curl.se/docs/manpage.html)

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender/batch' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
}'
```

**JavaScript / Node.js**

Node.js 22+; integriertes fetch. Als example.mjs speichern und node example.mjs ausführen. [Dokumentation der Laufzeitumgebung](https://nodejs.org/api/globals.html#fetch)

```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 = {
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
};

const response = await fetch("https://api.genderapi.io/api/v2/gender/batch", {
  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. [Dokumentation der Laufzeitumgebung](https://docs.python.org/3/library/urllib.request.html)

```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("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}")

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/batch",
    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. [Dokumentation der Laufzeitumgebung](https://www.php.net/manual/en/book.curl.php)

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"items":[{"id":"profile-001","type":"username","value":"@alice_smith","options":{"ai_mode":"off"}},{"id":"profile-002","type":"username","value":"alexriver","options":{"ai_mode":"fallback"}},{"id":"profile-003","type":"username","value":"prenses","country":"TR","forceToGenderize":true}]}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender/batch');
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. [Dokumentation der Laufzeitumgebung](https://docs.oracle.com/en/java/javase/17/docs/api/java.net.http/java/net/http/HttpClient.html)

```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 = "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}";
        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/batch"))
            .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. [Dokumentation der Laufzeitumgebung](https://learn.microsoft.com/en-us/dotnet/fundamentals/networking/http/httpclient)

```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/batch");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}", 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. [Dokumentation der Laufzeitumgebung](https://pkg.go.dev/net/http)

```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 := "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender/batch", 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)
    }
}
```

- [Anleitung zu Fehlern und Wiederholungen →](https://www.genderapi.io/de/docs/v2/errors-and-retries)

### Listenergebnisse und Wiederholungen verarbeiten

POST /api/v2/gender/batch nimmt bis zu 50 Einträge mit API-Schlüssel und 10 im IP-Testzugang an. Geben Sie jedem Eintrag eigene Werte für type, value und options. Wenn Sie den Standard-KI-Fallback nutzen möchten, setzen Sie fallback in jedem Eintrag ausdrücklich. id muss innerhalb des Batches eindeutig sein; index zählt ab null innerhalb des gesendeten Batches. Speichern Sie eigene Auftrags- und Quellzeilenkennungen getrennt.

HTTP 200 bedeutet nicht, dass alle Einträge erfolgreich waren. Verarbeiten Sie die Ergebnisse identified, unknown und error getrennt; meta.summary.succeeded zählt sowohl identified als auch unknown. Bewerten Sie data.gender, source, confidence_kind, confidence, match und reason gemeinsam. Behandeln Sie einen KI-Wert und eine Häufigkeit im Datensatz nicht als gleichwertig.

Hat meta.usage.billing_status den Wert confirmed, wiederholen Sie nur betriebliche Fehler, die eine Wiederholung zulassen. Lautet der Status unconfirmed oder ist die Antwort verloren gegangen, halten Sie an und gleichen Sie die Abrechnung ab. Das erneute Senden desselben Datensatzes, auch eines erfolgreichen unknown-Ergebnisses, erzeugt einen neuen kostenpflichtigen Vorgang; senden Sie niemals blind die gesamte Liste erneut.

[Vertrag für Batch-Anfragen](https://www.genderapi.io/de/docs/v2/batch) · [Antwortfelder](https://www.genderapi.io/de/docs/v2/responses) · [KI-Optionen](https://www.genderapi.io/de/docs/v2/ai-options) · [Genauigkeit und Konfidenz bewerten](https://www.genderapi.io/de/accuracy-methodology) · [Datenschutzerklärung](https://www.genderapi.io/de/privacy-policy)

Die Add-ons für Excel und Google Sheets sowie andere fertige Integrationen können eine eigene Verbindung und ein eigenes Ergebnisformat verwenden. Gehen Sie nicht davon aus, dass ihre Ausgabe diesem V2-JSON-Schema entspricht; prüfen Sie den aktuellen Leitfaden der jeweiligen Integration.

## Geschlecht anhand eines Benutzernamens oder Spitznamens

### Kann man das Geschlecht anhand eines Benutzernamens bestimmen?

Wenn Sie in V2 forceToGenderize aktivieren, wird zuerst der Datensatz geprüft; wird kein Geschlecht ermittelt, kann KI den Spitznamen auswerten, ohne dass ein echter Vorname nötig ist. Das Ergebnis kann unknown bleiben und ist keine verifizierte Identität. Die Standard-KI benötigt dagegen einen brauchbaren echten Vornamen.

### Welche Benutzernamen liefern die nützlichsten Ergebnisse?

Ein nützlicheres Signal können Werte liefern, die einen echten Vornamen, eine erkennbare Koseform oder einen deutlichen Namensbestandteil enthalten. Zufällige Zeichenfolgen und Markennamen liefern möglicherweise gar kein Ergebnis.

### Kann ich einen einzelnen Benutzernamen per API analysieren?

Ja. Der Einzel-Endpunkt analysiert einen Datensatz. Für mehrere Datensätze gibt es einen eigenen Endpunkt für Batch-Anfragen.

### Kann ich eine Excel- oder CSV-Datei importieren?

Ja. Im Datei-Werkzeug können Sie die Spalte mit Benutzernamen oder Anzeigenamen wählen und die Spitznamen-Auswertung aktivieren.

### Warum sollte ich die Felder zu Konfidenz und Quelle aus V2 gemeinsam speichern?

In V2 liegt data.confidence zwischen 0 und 1. Bewerten Sie den Wert zusammen mit source und confidence_kind, denn ein KI-Wert und eine Häufigkeit im Datensatz sind unterschiedliche Maße. Bewahren Sie unknown-Ergebnisse und das Feld reason auf.

### Eignet sich das Ergebnis für die Segmentierung?

Es kann als unterstützendes Signal in aggregierten Analysen und bei der Datenanreicherung dienen, sollte aber nicht allein über Angelegenheiten mit großer Tragweite für eine bestimmte Person entscheiden oder deren Identität festlegen.

### Kann ich den Dienst kostenlos testen?

Neue GenderAPI-Konten enthalten täglich 200 kostenlose API-Credits, mit denen Sie repräsentative Stichproben per API oder Datei testen können.
