# Geschlecht aus einem Benutzernamen mit API v2

> Vorhersagen anhand von Benutzernamen und Spitznamen mit GenderAPI v2. Erfahren Sie mehr über forceToGenderize, Dataset-First-Lookup, KI-Antwortfelder und den 1- oder 2-Credit-Tarif.

Canonical HTML: https://www.genderapi.io/de/docs/v2/gender-from-username

Last reviewed: 2026-09-25

## Vor dem Absenden der Anfrage

Senden Sie JSON an POST https://api.genderapi.io/api/v2/gender.. Verwenden Sie Ihren vorhandenen API-Schlüssel in Authorization: Bearer YOUR_API_KEY und Content-Type: application/json. Jede Anfrage wird eigenständig bearbeitet.

Wählen Sie Ihre Sprache im Codebeispiel. Legen Sie GENDERAPI_API_KEY in der Prozessumgebung fest, bevor Sie es ausführen. Fehlende oder nicht erkannte Schlüssel können die freigegebene IP-Testversion verwenden. Stellen Sie daher sicher, dass meta.access.mode api_key ist, wenn Sie ein Konto integrieren.

- [Authentifizierung und Testzugang](https://www.genderapi.io/de/docs/v2/authentication)
- [Alle Anforderungsparameter](https://www.genderapi.io/de/docs/v2/request-parameters)

## Geschlecht aus einem Benutzernamen oder Spitznamen

Verwenden Sie type: username als Benutzernamen oder Spitznamen. Setzen Sie forceToGenderize auf true, um das Geschlecht aus der Bedeutung eines Alias wie prenses abzuleiten, auch wenn kein echter Vorname extrahiert werden kann. Der Datensatz wird zunächst überprüft. Eine Spitznamenvorhersage kann ein Geschlecht zurückgeben, selbst wenn name: null.

Führen Sie diese Beispiele auf Ihrem Server aus. Setzen Sie GENDERAPI_API_KEY in der Prozessumgebung auf Ihren vorhandenen API-Schlüssel. Bestätigen Sie, dass meta.access.mode api_key ist: Ein nicht erkannter Schlüssel kann auf die IP-Testversion zurückgreifen.

Jede Vorhersageanfrage ist ein neuer kostenpflichtiger Vorgang, einschließlich Wiederholungsversuchen. Bei diesen Beispielen wird der Versuch nicht automatisch wiederholt. Überprüfen Sie den Rechnungsstatus, bevor Sie eine weitere Anfrage senden.

HTTP 4xx und 5xx JSON-Antworten behalten den Fehlertext bei und geben einen Exit-Status ungleich Null zurück. Überprüfen Sie code, action und meta.usage.billing_status, bevor Sie es erneut versuchen.

**cURL**

cURL 7.76+ in einer POSIX-Shell. Führen Sie es in Ihrem Terminal aus.

```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": "username",
  "value": "prenses",
  "country": "TR",
  "forceToGenderize": true
}'
```

**JavaScript / Node.js**

Node.js 22+; Integrierter Abruf. Speichern Sie es als example.mjs und führen Sie node example.mjs aus.

```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": "username",
  "value": "prenses",
  "country": "TR",
  "forceToGenderize": true
};

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. Speichern Sie es als example.py und führen Sie python3 example.py aus.

```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\":\"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",
    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. Speichern Sie es als example.php und führen Sie php example.php aus.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"type":"username","value":"prenses","country":"TR","forceToGenderize":true}', 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. Speichern Sie es als GenderApiExample.java und führen Sie java GenderApiExample.java aus.

```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\":\"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"))
            .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**

.NET 8+ Konsolenanwendung. 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\":\"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. Speichern Sie es als main.go und führen Sie go run main.go aus.

```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\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}"
    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)
    }
}
```

## Beispielantwort

Diese synthetische Antwort veranschaulicht die JSON-Form, nicht die gemessene Genauigkeit oder ein garantiertes Live-Ergebnis. Es zeigt den IP-Testzugang; Ein authentifizierter Vorgang meldet die Kontingentfelder meta.access.mode: api_key und null, die nur für die Testversion bestimmt sind. Lesen Sie Daten für die Schlussfolgerung und meta.usage für das Abrechnungsergebnis des Vorgangs.

```json
{
  "data": {
    "input": {
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    },
    "name": null,
    "gender": "female",
    "country": "TR",
    "confidence": 0.7,
    "confidence_kind": "model_reported",
    "sample_count": null,
    "source": "ai",
    "result_status": "identified",
    "reason": null,
    "country_source": "ai_association",
    "match": {
      "name": null,
      "method": "model_inference",
      "scope": null,
      "country": null
    }
  },
  "meta": {
    "request_id": "11111111-1111-4111-8111-111111111111",
    "duration_ms": 12,
    "access": {
      "mode": "ip_trial",
      "reason": "api_key_missing"
    },
    "usage": {
      "charged_credits": 2,
      "remaining_credits": -1,
      "billing_status": "confirmed",
      "resets_at": "2026-09-26T12:00:00.000Z",
      "limit": 10,
      "period_seconds": 86400
    }
  }
}
```

- [Antwortfelder und Konfidenz](https://www.genderapi.io/de/docs/v2/responses)

## Lesen Sie eine Spitznamenvorhersage

In diesem Beispiel wird forceToGenderize: true verwendet. Wenn der Datensatz ein Geschlecht identifiziert, betragen die Kosten 1 Credit. Andernfalls interpretiert die KI den Alias und eine abgeschlossene Anfrage kostet insgesamt 2 Credits, auch wenn das Geschlecht unbekannt bleibt. Lassen Sie ai_mode weg oder setzen Sie es auf fallback. Die Verwendung von off oder always zusammen mit forceToGenderize gibt HTTP 422 zurück.

Im Nickname-Modus ist eine Geschlechtsvorhersage mit name: null erlaubt. Das bedeutet, dass kein richtiger Vorname extrahiert wurde und nicht, dass die Analyse fehlgeschlagen ist. Wenn KI ein Geschlecht zurückgibt, werden sample_count: null und confidence_kind: model_reported zurückgegeben. Der Score ist keine kalibrierte Wahrscheinlichkeit und überprüft nicht die persönliche Identität.

Ohne forceToGenderize wird bei der Suche nach einem einzelnen Benutzernamen weiterhin standardmäßig der normale KI fallback für insgesamt 1 Credit verwendet, es ist jedoch ein verwendbarer echter Vorname erforderlich. Verwenden Sie options.ai_mode: off für die reine Datensatzverarbeitung.

## Verwandte Leitfäden

- [KI-Modi und forceToGenderize](https://www.genderapi.io/de/docs/v2/ai-options)
- [Batch-Vorhersagen](https://www.genderapi.io/de/docs/v2/batch)
- [Credits und Nutzung](https://www.genderapi.io/de/docs/v2/credits-and-usage)
- [Fehler und Wiederholungsversuche](https://www.genderapi.io/de/docs/v2/errors-and-retries)