# Finn kjønn fra en e-postadresse

> Bruk navnesignalet i en e-postadresse med GenderAPI.io V2. Prøv en forespørsel i sanntid, sammenlign alternativene for datasett og KI, og se hvordan du håndterer ukjente resultater og lister med e-postadresser.

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

Last reviewed: 2026-09-29

## Hva forteller en e-postadresse?

Send en syntaktisk gyldig e-postadresse med type: email. GenderAPI.io ser etter et navnesignal i delen foran @ og returnerer deretter en strukturert prediksjon. Postkassen blir ikke verifisert, den blir ikke knyttet til en innehaver, og innehaverens kjønnsidentitet blir ikke fastslått.

Treff i datasettet henter kandidater fra delene av adressen og kan kontrollere et begrenset antall delstrenger. Kallenavnmodus beholder treff på hele deler, men legger ikke til disse kandidatene basert på delstrenger. Hvis flere oppføringer gir treff, velges kandidaten med det høyeste lagrede totalantallet, og det er ikke nødvendigvis det tiltenkte fornavnet. Kontroller data.name og data.match før du bruker et uttrukket navn i et kontaktregister.

| Eksempel på inndata | Tolkning |
| --- | --- |
| `alice.smith@example.com` | Den lokale delen inneholder mulige navnedeler. Et treff er mulig, men inndataene alene avgjør ikke hvilken kandidat som velges. |
| `alice+news@example.com` | Oppslaget i datasettet fjerner suffikset etter plusstegnet for sine egne kandidater. KI blir bedt om å se bort fra det, men mottar verdien som ble sendt. |
| `support@example.com` | En rolleadresse gir ikke et pålitelig signal om et personnavn. Ikke tilskriv hele den delte postkassen kjønnet til én person. |
| `prenses@example.com` | Det valgfrie alternativet forceToGenderize tillater et forsøk basert på betydningen av et kallenavn når datasettet ikke gir et resultat. I denne modusen trengs det ikke et ekte navn. |
| `not-an-email` | Ugyldig syntaks gir en valideringsfeil i stedet for et vellykket ukjent resultat. |

## Send en forespørsel for en e-postadresse fra applikasjonen din

Eksemplet bruker din eksisterende API-nøkkel i Bearer-headeren og angir fallback eksplisitt. Erstatt eksempeladressen med inndata du har rett til å behandle. Angi country bare når du har relevant kontekst; e-postdomenet viser ikke hvor en person befinner seg. Uten landkontekst utelater du feltet.

Kjør eksemplet på serveren din etter at du har satt GENDERAPI_API_KEY. Med POST holdes e-postadressen utenfor URL-en til forespørselen. Resultatet i sanntid kan avvike fra eksempelsvaret i demoen.

Kjør disse eksemplene på serveren din. Sett GENDERAPI_API_KEY i prosessmiljøet til din eksisterende API-nøkkel. Bekreft at meta.access.mode er api_key: en nøkkel som ikke gjenkjennes, kan føre til IP-prøveperioden.

Hver prediksjonsforespørsel er en ny operasjon som belastes, også nye forsøk. Disse eksemplene prøver ikke automatisk på nytt. Sjekk belastningsstatusen før du sender en ny forespørsel.

Ved JSON-svar med HTTP 4xx og 5xx beholdes feilinnholdet, og eksemplet avsluttes med en exit-status som ikke er null. Sjekk code, action og meta.usage.billing_status før du prøver på nytt.

**cURL**

cURL 7.76+ i et POSIX-skall. Kjør i terminalen.

```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+; innebygd fetch. Lagre som example.mjs og kjø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. Lagre som example.py og kjø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-utvidelsen. Lagre som example.php og kjø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-klient. Lagre som GenderApiExample.java og kjø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**

Konsollapplikasjon i .NET 8+. Bruk som Program.cs i et konsollprosjekt, og kjør deretter 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. Lagre som main.go og kjø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)
    }
}
```

- [Fullstendig V2-referanse for e-postadresser](https://www.genderapi.io/nb/docs/v2/gender-from-email)

## Lagre resultatet sammen med grunnlaget

En utledet tilknytning er ikke det kjønnet en person selv har oppgitt. Lagre de opprinnelige inndataene, grunnlaget som ble returnert, og det personen selv har oppgitt, hver for seg. Et ukjent resultat er et gyldig resultat og bør ikke bli en gjettet kategori i applikasjonen din.

| Felt | Bruk |
| --- | --- |
| `data.gender / data.result_status` | Bruk male eller female bare sammen med identified. Ved et ukjent resultat beholder du den opprinnelige JSON-verdien null. |
| `data.name / data.match` | Kontroller det returnerte navnet og den valgte kandidaten. Et treff på en delstreng beviser ikke at inndataene tilhører en person med dette navnet. |
| `data.confidence / data.confidence_kind` | Konfidensen er en verdi fra 0 til 1 eller null. observed_frequency bygger på lagrede frekvenser; model_reported er en verdi fra KI. Evaluer tersklene separat for hver type. |
| `data.source / data.sample_count` | Skill mellom dataset, ai og none. KI-resultater har ingen lagret utvalgsstørrelse. En utvalgsstørrelse er ikke en målt nøyaktighet. |
| `meta.access.mode` | Kontroller at api_key rapporteres i en integrasjon med konto. Nøkler som mangler eller ikke gjenkjennes, kan i stedet bruke den delte IP-prøveperioden. |
| `meta.usage` | Les charged_credits og billing_status. Et vellykket ukjent resultat belastes. Et tapt svar beviser ikke at forespørselen var gratis. |

- [Svarfelt og ukjente resultater](https://www.genderapi.io/nb/docs/v2/responses)
- [Nøyaktighet og konfidens forklart](https://www.genderapi.io/nb/accuracy-methodology)
- [Datakilder og den daterte profilen til datasettet](https://www.genderapi.io/nb/data-provenance)

## Bestem når KI skal brukes

forceToGenderize er valgfritt for navn, e-postadresser og brukernavn. Når det er aktivert, utelater du ai_mode eller bruker fallback; off og always kan ikke kombineres med dette alternativet og gir 422. En positiv startsaldo er nok til å starte en forespørsel, selv om den endelige belastningen gjør saldoen negativ.

Kallenavnmodus kan returnere et kjønn sammen med name: null. Den kan også gi et ukjent resultat. Verken vanlig KI-reserve eller tolkning av kallenavn garanterer et riktig svar eller en verdi som ikke er null.

| Alternativ i forespørselen | Virkemåte | Kreditter for et vellykket oppslag |
| --- | --- | --- |
| options.ai_mode: off | Bruker bare datasettet. | 1, også for et ukjent resultat |
| options.ai_mode: fallback | Søker først i datasettet og bruker deretter vanlig KI hvis det ikke returneres et kjønn. Dette er standard for enkeltforespørsler. | 1 totalt, inkludert KI-reserve |
| options.ai_mode: always | Bruker KI direkte. | 2 |
| forceToGenderize: true | Søker først i datasettet og lar deretter KI tolke et personlig kallenavn eller alias, selv uten et ekte fornavn. | 1 for et resultat fra datasettet; 2 totalt hvis KI brukes |

- [KI-alternativer og tolkning av kallenavn](https://www.genderapi.io/nb/docs/v2/ai-options)
- [Kreditter og forbruk](https://www.genderapi.io/nb/docs/v2/credits-and-usage)

## Behandle en liste med e-postadresser i en samleforespørsel

Bruk POST /api/v2/gender/batch med en items-matrise av elementer med type: email. Tilgang med en registrert API-nøkkel støtter opptil 50 elementer, IP-prøveperioden opptil 10. Gi hvert element en unik id, slik at du kan koble resultatene til den opprinnelige raden. Svaret følger dessuten rekkefølgen i inndataene og oppgir index.

Som standard bruker elementer i en samleforespørsel bare datasettet. Angi options.ai_mode: fallback for hvert element som trenger vanlig KI-reserve. To vellykkede elementer med fallback koster 2 kreditter totalt, også når resultatene er ukjente; én HTTP-forespørsel tilsvarer ikke én kreditt per prediksjon.

Kontroller hvert element, også når samleforespørselen returnerer HTTP 200. Lagre vellykkede og ukjente resultater, og kontroller deretter feil og bekreftet belastning før du sender mislykkede elementer på nytt. Etter et tidsavbrudd må du ikke sende en vellykket samleforespørsel på nytt i sin helhet uten først å ha sjekket belastningen.

- [Eksempler, grenser og delvise feil for samleforespørsler](https://www.genderapi.io/nb/docs/v2/batch)

## Vit hva du sender

Demoen i sanntid sender verdien du skriver inn, til GenderAPI.io bare når du selv sender den. Hvis KI brukes, overføres type, value og landkonteksten som ble sendt, til tjenesten som er konfigurert for prediksjoner. For en prediksjon som bare bruker datasettet, angir du options.ai_mode: off uten forceToGenderize i integrasjonen din.

Personvernerklæringen, databehandleravtalen og listen over underdatabehandlere beskriver de publiserte vilkårene for behandlingen. Et resultat er en utledet tilknytning, og det en person selv oppgir, har forrang. Ikke bruk det som grunnlag for beslutninger som har store konsekvenser for en person.

- [Personvernerklæring](https://www.genderapi.io/nb/privacy-policy)
- [Databehandleravtale](https://www.genderapi.io/nb/data-processing-agreement)
- [Underdatabehandlere](https://www.genderapi.io/nb/subprocessors)

## Kan API-et hente ut et fornavn fra en e-postadresse?

Det kan returnere en navnekandidat når den lokale delen inneholder et brukbart signal. Både treff på hele deler og på delstrenger er mulig, så kontroller data.match. Resultatet viser ikke fornavnet til personen som eier postkassen.

## Gir en adresse som info@ eller support@ et kjønn?

Delte rolleadresser gir vanligvis ikke grunnlag for et personnavn. Et ukjent resultat er gyldig. KI eller kallenavnmodus skal ikke regnes som en bekreftelse for personene som bruker en delt postkasse.

## Bruker et ukjent resultat for en e-postadresse kreditter?

Ja. En vanlig vellykket forespørsel for en e-postadresse koster 1 kreditt, inkludert KI-reserve og ukjente resultater. Tvunget tolkning av kallenavn koster 1 kreditt for et resultat fra datasettet eller 2 totalt hvis KI brukes. Ved en feil vises belastningen separat i meta.usage.

## Fjernes e-postdomenet før KI behandler adressen?

Det er ikke garantert. Kandidatene i datasettet kommer fra den lokale delen, mens KI mottar verdien som ble sendt, med beskjed om å se bort fra domenet og suffikset etter plusstegnet. Bruk modusen med bare datasettet hvis arbeidsflyten din krever det.