# Bestäm kön utifrån en e-postadress

> Använd namnsignalen i en e-postadress med GenderAPI.io V2. Testa en livesökning, jämför alternativen för datamängd och AI och se hur du hanterar okända resultat och e-postlistor.

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

Last reviewed: 2026-09-28

## Vad säger en e-postadress?

Skicka en syntaktiskt giltig e-postadress med type: email. GenderAPI.io letar efter en namnsignal i delen före @ och returnerar sedan en strukturerad prediktion. Brevlådan verifieras inte, den kopplas inte till någon innehavare och innehavarens könsidentitet fastställs inte.

Matchningen mot datamängden härleder kandidater ur adressens delar och kan kontrollera begränsade delsträngar. Smeknamnsläget behåller matchningen av hela delar men lägger inte till sådana delsträngskandidater. Om flera poster matchar väljs kandidaten med det största lagrade totala antalet, och det behöver inte vara det avsedda förnamnet. Granska data.name och data.match innan du använder ett extraherat namn i ett kontaktregister.

| Exempel på indata | Tolkning |
| --- | --- |
| `alice.smith@example.com` | Den lokala delen innehåller möjliga namndelar. En träff är möjlig, men indata avgör inte i sig vilken kandidat som väljs. |
| `alice+news@example.com` | Sökningen i datamängden tar bort tillägget efter plustecknet för sina kandidater. AI instrueras att bortse från det men får det skickade värdet. |
| `support@example.com` | En funktionsadress ger ingen tillförlitlig signal om ett personnamn. Tilldela inte hela den delade brevlådan en persons kön. |
| `prenses@example.com` | Det valfria forceToGenderize tillåter ett försök utifrån ett smeknamns betydelse när datamängden inte ger något resultat. Ett riktigt namn krävs inte i det läget. |
| `not-an-email` | Ogiltig syntax ger ett valideringsfel i stället för ett lyckat okänt resultat. |

## Skicka en e-postsökning från din applikation

Exemplet använder din befintliga API-nyckel i Bearer-rubriken och anger fallback uttryckligen. Ersätt exempeladressen med indata som du har rätt att behandla. Ange country bara när du har relevant kontext; e-postdomänen visar inte var en person befinner sig. Utan landskontext utelämnar du fältet.

Kör exemplet på din server när du har satt GENDERAPI_API_KEY. POST håller e-postadressen borta från förfrågans URL. Liveresultatet kan skilja sig från exempelsvaret i demon.

Kör exemplen på din server. Sätt GENDERAPI_API_KEY i processmiljön till din befintliga API-nyckel. Kontrollera att meta.access.mode är api_key: en nyckel som inte känns igen kan leda till IP-provperioden.

Varje prediktionsförfrågan är en ny debiterbar åtgärd, även vid nya försök. Exemplen gör inga automatiska nya försök. Kontrollera debiteringsstatus innan du skickar en ny förfrågan.

Vid JSON-svar med HTTP 4xx och 5xx behålls felinnehållet och exemplet avslutas med en slutstatus som inte är noll. Kontrollera code, action och meta.usage.billing_status innan du försöker igen.

**cURL**

cURL 7.76+ i ett POSIX-skal. Kö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+; inbyggd fetch. Spara som example.mjs och 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. Spara som example.py och 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 tillägget cURL. Spara som example.php och 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+; inbyggd HTTP-klient. Spara som GenderApiExample.java och 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+. Använd som Program.cs i ett konsolprojekt och kör sedan 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. Spara som main.go och 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)
    }
}
```

- [Fullständig V2-referens för e-postadresser](https://www.genderapi.io/sv/docs/v2/gender-from-email)

## Spara resultatet tillsammans med underlaget

En härledd koppling är inte det kön som en person själv uppger. Spara ursprungliga indata, det returnerade underlaget och det personen själv har angett separat. Ett okänt resultat är ett giltigt resultat och bör inte bli en gissad kategori i din applikation.

| Fält | Användning |
| --- | --- |
| `data.gender / data.result_status` | Använd male eller female bara vid identified. Behåll det inbyggda JSON-värdet null vid ett okänt resultat. |
| `data.name / data.match` | Granska det returnerade namnet och den valda kandidaten. En träff på en delsträng visar inte att indata tillhör en person med det förnamnet. |
| `data.confidence / data.confidence_kind` | Konfidensen ligger på en skala från 0 till 1 eller är null. observed_frequency bygger på lagrade frekvenser; model_reported är ett AI-värde. Utvärdera tröskelvärden separat för varje typ. |
| `data.source / data.sample_count` | Skilj mellan dataset, ai och none. AI-resultat har ingen lagrad urvalsstorlek. En urvalsstorlek är inget uppmätt noggrannhetsvärde. |
| `meta.access.mode` | Kontrollera att api_key rapporteras i en kontointegration. Nycklar som saknas eller inte känns igen kan i stället använda den delade IP-provperioden. |
| `meta.usage` | Läs charged_credits och billing_status. Ett lyckat okänt resultat debiteras. Ett förlorat svar visar inte att förfrågan var kostnadsfri. |

- [Svarsfält och okända resultat](https://www.genderapi.io/sv/docs/v2/responses)
- [Noggrannhet och konfidens förklarade](https://www.genderapi.io/sv/accuracy-methodology)
- [Datakällor och den daterade databasprofilen](https://www.genderapi.io/sv/data-provenance)

## Bestäm när AI ska användas

forceToGenderize är valfritt för namn, e-postadresser och användarnamn. När det är aktiverat utelämnar du ai_mode eller använder fallback; off och always kan inte kombineras med det och ger 422. Ett positivt startsaldo räcker för att starta en förfrågan, även om den slutliga debiteringen gör saldot negativt.

Smeknamnsläget kan returnera ett kön tillsammans med name: null. Det kan också ge ett okänt resultat. Varken vanlig AI-reserv eller tolkning av smeknamn garanterar ett korrekt svar eller ett värde som inte är null.

| Alternativ i förfrågan | Beteende | Krediter för en lyckad sökning |
| --- | --- | --- |
| options.ai_mode: off | Använd bara datamängden. | 1, även för ett okänt resultat |
| options.ai_mode: fallback | Kontrollera datamängden först och använd sedan vanlig AI om inget kön returneras. Detta är standard för enskilda förfrågningar. | Totalt 1, inklusive AI-reserv |
| options.ai_mode: always | Använd AI direkt. | 2 |
| forceToGenderize: true | Kontrollera datamängden först och låt sedan AI tolka ett personligt smeknamn eller alias, även utan ett riktigt förnamn. | 1 för ett resultat som fastställs i datamängden; totalt 2 om AI används |

- [AI-alternativ och tolkning av smeknamn](https://www.genderapi.io/sv/docs/v2/ai-options)
- [Krediter och användning](https://www.genderapi.io/sv/docs/v2/credits-and-usage)

## Bearbeta en e-postlista i batchar

Använd POST /api/v2/gender/batch med en items-array av poster med type: email. Åtkomst med en registrerad API-nyckel stöder upp till 50 poster och IP-provperioden upp till 10. Behåll ett unikt id för varje post så att du kan koppla resultaten till den ursprungliga raden. Svaret följer dessutom indataordningen och anger index.

Poster i en batch använder som standard bara datamängden. Ange options.ai_mode: fallback för varje post som behöver vanlig AI-reserv. Två lyckade poster med fallback kostar totalt 2 krediter, även när resultaten är okända; en HTTP-förfrågan motsvarar inte en kredit per prediktion.

Kontrollera varje post, även när batchen returnerar HTTP 200. Spara lyckade och okända resultat och kontrollera sedan felen och den bekräftade debiteringen innan du skickar om misslyckade poster. Skicka inte om en lyckad batch i sin helhet efter en överskriden tidsgräns utan att först kontrollera debiteringen.

- [Batchexempel, gränser och delvisa fel](https://www.genderapi.io/sv/docs/v2/batch)

## Veta vad du skickar

Livedemon skickar det inmatade värdet till GenderAPI.io först när du skickar in det. Om AI används skickas den inskickade type, value och landskontexten till den konfigurerade tjänsten för prediktioner. För en prediktion som bara använder datamängden anger du options.ai_mode: off utan forceToGenderize i din integration.

Integritetspolicyn, personuppgiftsbiträdesavtalet och förteckningen över underbiträden beskriver de publicerade villkoren för behandlingen. Ett resultat är en härledd koppling, och det en person själv uppger har företräde. Använd det inte som grund för beslut med stora konsekvenser för en person.

- [Integritetspolicy](https://www.genderapi.io/sv/privacy-policy)
- [Personuppgiftsbiträdesavtal](https://www.genderapi.io/sv/data-processing-agreement)
- [Underbiträden](https://www.genderapi.io/sv/subprocessors)

## Kan API:et extrahera ett förnamn ur en e-postadress?

Det kan returnera en namnkandidat när den lokala delen innehåller en användbar signal. Både träffar på hela delar och på delsträngar är möjliga, så granska data.match. Resultatet visar inte förnamnet på den person som äger brevlådan.

## Ger info@ eller support@ ett kön?

Delade funktionsadresser ger oftast inget underlag för ett personnamn. Ett okänt resultat är giltigt. AI eller smeknamnsläget ska inte ses som en bekräftelse för de personer som använder en delad brevlåda.

## Förbrukar ett okänt resultat för en e-postadress krediter?

Ja. En lyckad vanlig e-postsökning kostar 1 kredit, inklusive AI-reserv och okända resultat. Framtvingad tolkning av smeknamn kostar 1 kredit för ett resultat som fastställs i datamängden eller totalt 2 om AI används. För fel redovisas debiteringen separat i meta.usage.

## Tas e-postdomänen bort innan AI behandlar adressen?

Det utlovas inte. Kandidaterna i datamängden kommer från den lokala delen, medan AI får det skickade värdet och instrueras att bortse från domänen och tillägget efter plustecknet. Använd läget som bara använder datamängden om ditt arbetsflöde kräver det.