# Bestem køn ud fra en e-mailadresse

> Brug navnesignalet i en e-mailadresse med GenderAPI.io V2. Prøv en live-forespørgsel, sammenlign indstillingerne for datasæt og AI, og se, hvordan du håndterer ukendte resultater og lister med e-mailadresser.

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

Last reviewed: 2026-09-29

## Hvad fortæller en e-mailadresse?

Send en syntaktisk gyldig e-mailadresse med type: email. GenderAPI.io leder efter et navnesignal i delen før @ og returnerer derefter en struktureret forudsigelse. Postkassen bliver ikke verificeret eller knyttet til en ejer, og ejerens kønsidentitet bliver ikke fastslået.

Matchet med datasættet udleder kandidater fra adressens dele og kan kontrollere begrænsede delstrenge. Kaldenavnstilstanden matcher stadig hele dele, men tilføjer ikke disse delstrengskandidater. Hvis flere poster matcher, vælges kandidaten med det højeste lagrede samlede antal, og det er ikke nødvendigvis det tilsigtede fornavn. Kontrollér data.name og data.match, før du bruger et udtrukket navn i en kontaktliste.

| Eksempel på input | Fortolkning |
| --- | --- |
| `alice.smith@example.com` | Den lokale del indeholder mulige navnedele. Et match er muligt, men inputtet alene afgør ikke, hvilken kandidat der vælges. |
| `alice+news@example.com` | Opslaget i datasættet fjerner suffikset efter plustegnet for sine egne kandidater. AI bliver bedt om at ignorere det, men modtager den sendte værdi. |
| `support@example.com` | En rolleadresse giver ikke et pålideligt signal om et personnavn. Tildel ikke hele den delte postkasse én persons køn. |
| `prenses@example.com` | Den valgfrie indstilling forceToGenderize tillader et forsøg ud fra et kaldenavns betydning, når datasættet ikke giver et resultat. Denne tilstand kræver ikke et egentligt navn. |
| `not-an-email` | Ugyldig syntaks returnerer en valideringsfejl i stedet for et gennemført ukendt resultat. |

## Send en forespørgsel med en e-mailadresse fra din applikation

Eksemplet bruger din eksisterende API-nøgle i Bearer-headeren og angiver fallback eksplicit. Erstat eksempeladressen med et input, du har ret til at behandle. Angiv kun country, hvis du har en relevant kontekst. E-maildomænet viser ikke, hvor en person befinder sig. Udelad feltet, hvis du ikke har en landekontekst.

Kør eksemplet på din server, når du har angivet GENDERAPI_API_KEY. Med POST holdes e-mailadressen uden for forespørgslens URL. Live-resultatet kan afvige fra demoens eksempelsvar.

Kør eksemplerne på din server. Sæt GENDERAPI_API_KEY i procesmiljøet til din eksisterende API-nøgle. Bekræft, at meta.access.mode er api_key: En nøgle, der ikke genkendes, kan føre til IP-prøveadgangen.

Hver forespørgsel om en forudsigelse er en ny operation, der koster kreditter, også når den gentages. Eksemplerne prøver ikke automatisk igen. Kontrollér opkrævningsstatus, før du sender en ny forespørgsel.

JSON-svar med HTTP 4xx og 5xx bevarer fejlens body og returnerer en exitstatus, der ikke er nul. Kontrollér code, action og meta.usage.billing_status, før du prøver igen.

**cURL**

cURL 7.76+ i en POSIX-shell. Kør i din terminal.

```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+, indbygget fetch. Gem som example.mjs, og kør node example.mjs.

```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+, standardbiblioteket. Gem som example.py, og kør python3 example.py.

```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+ med cURL-udvidelsen. Gem som example.php, og kør php example.php.

```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-klienten. Gem som GenderApiExample.java, og kør java GenderApiExample.java.

```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**

Konsolapplikation med .NET 8+. Brug som Program.cs i et konsolprojekt, og kør derefter dotnet run.

```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+, standardbiblioteket. Gem som main.go, og kør go run main.go.

```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)
    }
}
```

- [Fuld V2-reference for e-mailadresser](https://www.genderapi.io/da/docs/v2/gender-from-email)

## Gem resultatet sammen med evidensen

En udledt sammenhæng er ikke det køn, en person selv har oplyst. Gem det oprindelige input, den returnerede evidens og det, personen selv har oplyst, hver for sig. Et ukendt resultat er et gyldigt resultat og bør ikke blive til en gættet kategori i din applikation.

| Felt | Sådan bruger du det |
| --- | --- |
| `data.gender / data.result_status` | Brug kun male eller female, når status er identified. Bevar den native JSON-værdi null, når resultatet er ukendt. |
| `data.name / data.match` | Kontrollér det returnerede navn og den valgte kandidat. Et match på en delstreng beviser ikke, at inputtet tilhører en person med det navn. |
| `data.confidence / data.confidence_kind` | Konfidensen ligger på en skala fra 0 til 1 eller er null. observed_frequency bygger på lagrede frekvenser, mens model_reported er en værdi angivet af AI. Vurdér tærskelværdier separat for hver type. |
| `data.source / data.sample_count` | Skeln mellem dataset, ai og none. AI-resultater har ingen lagret stikprøvestørrelse. En stikprøvestørrelse er ikke en målt nøjagtighed. |
| `meta.access.mode` | Kontrollér i en integration med konto, at api_key returneres. Manglende eller ukendte nøgler kan i stedet bruge den delte IP-prøveadgang. |
| `meta.usage` | Læs charged_credits og billing_status. Et gennemført ukendt resultat koster kreditter. Et mistet svar beviser ikke, at forespørgslen var gratis. |

- [Svarfelter og ukendte resultater](https://www.genderapi.io/da/docs/v2/responses)
- [Nøjagtighed og konfidens forklaret](https://www.genderapi.io/da/accuracy-methodology)
- [Datakilder og databasens daterede profil](https://www.genderapi.io/da/data-provenance)

## Beslut, hvornår AI skal bruges

forceToGenderize er valgfrit for navne, e-mailadresser og brugernavne. Når det er slået til, skal du udelade ai_mode eller bruge fallback. off og always kan ikke kombineres med denne indstilling og returnerer 422. En positiv startsaldo er nok til at starte en forespørgsel, også selvom den endelige opkrævning gør saldoen negativ.

Kaldenavnstilstanden kan returnere et køn sammen med name: null. Den kan også give et ukendt resultat. Hverken den almindelige automatiske AI-fallback eller fortolkningen af kaldenavne garanterer et korrekt svar eller en værdi, der ikke er null.

| Indstilling i forespørgslen | Adfærd | Kreditter for en gennemført forespørgsel |
| --- | --- | --- |
| options.ai_mode: off | Bruger kun datasættet. | 1, også for et ukendt resultat |
| options.ai_mode: fallback | Slår først op i datasættet og bruger derefter almindelig AI, hvis der ikke returneres et køn. Det er standarden for enkeltforespørgsler. | 1 i alt, inklusive automatisk AI-fallback |
| options.ai_mode: always | Bruger AI direkte. | 2 |
| forceToGenderize: true | Slår først op i datasættet og lader derefter AI fortolke et personligt kaldenavn eller alias, også uden et egentligt fornavn. | 1 for et resultat fra datasættet, 2 i alt, hvis AI bruges |

- [AI-indstillinger og fortolkning af kaldenavne](https://www.genderapi.io/da/docs/v2/ai-options)
- [Kreditter og forbrug](https://www.genderapi.io/da/docs/v2/credits-and-usage)

## Behandl en liste med e-mailadresser i en batch

Brug POST /api/v2/gender/batch med et items-array af elementer med type: email. Adgang med en registreret API-nøgle understøtter op til 50 elementer, IP-prøveadgangen op til 10. Giv hvert element et unikt id, så du kan knytte resultaterne til den oprindelige række. Svaret følger desuden inputrækkefølgen og angiver index.

Som standard bruger elementer i en batch kun datasættet. Angiv options.ai_mode: fallback for hvert element, der skal have den almindelige automatiske AI-fallback. To gennemførte elementer med fallback koster 2 kreditter i alt, også når resultaterne er ukendte. Én HTTP-forespørgsel svarer ikke til én kredit pr. forudsigelse.

Kontrollér hvert element, også når batchen returnerer HTTP 200. Gem gennemførte og ukendte resultater, og kontrollér derefter fejl og bekræftet opkrævning, før du sender mislykkede elementer igen. Send ikke en gennemført batch igen i sin helhed efter en timeout uden først at have kontrolleret opkrævningen.

- [Batcheksempler, grænser og delvise fejl](https://www.genderapi.io/da/docs/v2/batch)

## Vid, hvad du sender

Live-demoen sender kun den indtastede værdi til GenderAPI.io, når du selv sender den. Hvis AI bruges, videregives type, value og den sendte landekontekst til den tjeneste, der er konfigureret til forudsigelser. Hvis du kun vil have en forudsigelse fra datasættet, skal du i din integration angive options.ai_mode: off uden forceToGenderize.

Privatlivspolitikken, databehandleraftalen og listen over underdatabehandlere beskriver de offentliggjorte vilkår for behandlingen. Et resultat er en udledt sammenhæng, og det, en person selv oplyser, har forrang. Brug det ikke som grundlag for beslutninger, der har betydelige konsekvenser for en person.

- [Privatlivspolitik](https://www.genderapi.io/da/privacy-policy)
- [Databehandleraftale](https://www.genderapi.io/da/data-processing-agreement)
- [Underdatabehandlere](https://www.genderapi.io/da/subprocessors)

## Kan API'et udtrække et fornavn fra en e-mailadresse?

Det kan returnere en navnekandidat, når den lokale del indeholder et brugbart signal. Både match på hele dele og på delstrenge er mulige, så kontrollér data.match. Resultatet angiver ikke fornavnet på den person, der ejer postkassen.

## Returnerer en info@- eller support@-adresse et køn?

Delte rolleadresser giver som regel ingen evidens for et personnavn. Et ukendt resultat er gyldigt. AI eller kaldenavnstilstanden må ikke betragtes som en bekræftelse for de personer, der bruger en delt postkasse.

## Koster et ukendt resultat for en e-mailadresse kreditter?

Ja. En almindelig gennemført forespørgsel med en e-mailadresse koster 1 kredit, inklusive automatisk AI-fallback og ukendte resultater. Tvungen fortolkning af kaldenavne koster 1 kredit for et resultat fra datasættet eller 2 i alt, hvis AI bruges. Ved en fejl angives opkrævningen separat i meta.usage.

## Fjernes e-maildomænet, før AI behandler adressen?

Det er ikke garanteret. Kandidaterne fra datasættet kommer fra den lokale del, mens AI modtager den sendte værdi med en instruktion om at ignorere domænet og suffikset efter plustegnet. Brug tilstanden, der kun bruger datasættet, hvis din arbejdsgang kræver det.