# Finn kjønn fra et brukernavn eller kallenavn

> Tolk et brukernavn med GenderAPI.io V2. Prøv vanlig navnetreff eller valgfri tolkning av kallenavn, se prisen på 1 eller 2 kreditter, og behold ukjente resultater.

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

Last reviewed: 2026-09-29

## Navnesignaler og betydningen av kallenavn er to forskjellige ting

Bruk type: username for et brukernavn eller kallenavn. En valgfri @ først fjernes ved treff i datasettet. Uttrekket av kandidater tar hensyn til skilletegn og sifre og kan kontrollere et begrenset antall delstrenger. Kallenavnmodus beholder treff på hele deler, men legger ikke til disse kandidatene basert på delstrenger. Den valgte lagrede oppføringen har det høyeste totalantallet blant de tilgjengelige kandidatene; det viser ikke det virkelige navnet til personen bak kontoen.

Vanlig KI-reserve ser etter et gjenkjennelig fornavn. forceToGenderize tillater i tillegg en tilknytning via et personlig kallenavn når det ikke kan hentes ut et ekte navn. Begge veiene kan returnere unknown; et varemerke, en fiktiv figur eller en delt konto representerer ikke nødvendigvis én enkelt person.

| Eksempel på inndata | Fremgangsmåte | Hva du bør kontrollere |
| --- | --- | --- |
| `@alice.smith` | Start med vanlig fallback, som søker i datasettet først. | Kontroller det valgte navnet og treffmetoden; ikke anta at den første delen ble valgt. |
| `robert89` | Sifre kan fjernes under uttrekket av kandidater. | Et navn som gir treff, er en tilknytning, ikke en bekreftet identitet. |
| `prenses` | Aktiver forceToGenderize for å tillate et KI-forsøk basert på kallenavnet når det ikke finnes et resultat. | gender kan ha en verdi som ikke er null, mens name er null. KI-verdier er model_reported. |
| `team_support` | Behandle rollekontoer og delte kontoer som kontoer som kanskje ikke tilhører én enkelt person. | Behold unknown, og ikke tilskriv en delt konto en individuell identitet. |

## Prøv tolkning av kallenavn i integrasjonen din

Denne forespørselen aktiverer tolkning av kallenavn. Datasettet søkes først. Hvis det ikke returnerer et kjønn, kan KI bruke betydningen av aliaset. Utelat forceToGenderize for et vanlig oppslag; enkeltforespørsler bruker uansett vanlig KI-reserve som standard.

I dette eksemplet angis landkonteksten TR. Bruk relevant kontekst fra applikasjonen din, og kontroller data.match.scope; et oppgitt land garanterer ikke en landspesifikk oppføring. Det viser verken nasjonalitet eller bosted.

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

**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": "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+; 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\":\"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+ 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":"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-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\":\"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**

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\":\"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+; 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\":\"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)
    }
}
```

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

## 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)

## Behold resultatet for hvert brukernavn når du behandler en liste

Bruk POST /api/v2/gender/batch for lister med brukernavn eller blandede lister med navn, e-postadresser og brukernavn. Grensen er 50 elementer med en API-nøkkel eller 10 i IP-prøveperioden. Hvert element har egne alternativer for land og KI, og valgfrie ID-er må være unike innenfor samleforespørselen.

Som standard bruker en samleforespørsel bare datasettet. Aktiver fallback per element hvis du vil bruke vanlig KI, eller angi forceToGenderize per element for å tolke kallenavn. Kontroller data eller error i hvert resultat, og bruk id eller index for å koble resultatet til den opprinnelige raden. Vellykkede ukjente elementer belastes.

- [Lag en samleforespørsel og håndter delvise feil](https://www.genderapi.io/nb/docs/v2/batch)
- [Feil, tapte svar og nye forsøk](https://www.genderapi.io/nb/docs/v2/errors-and-retries)

## 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)

## Må et brukernavn inneholde et ekte fornavn?

En vanlig KI-prediksjon krever et brukbart fornavn. Med forceToGenderize kan API-et i tillegg forsøke en tilknytning via et kallenavn når oppslaget i datasettet ikke gir et resultat. Denne modusen krever ikke et ekte fornavn og kan returnere name: null.

## Garanterer forceToGenderize et kjønn?

Nei. Det tillater tolkning av kallenavn, men det endelige resultatet kan fortsatt være ukjent. Behold den opprinnelige JSON-verdien null, og kontroller result_status og reason.

## Kontrollerer API-et profilen i sosiale medier?

Dette endepunktet tolker verdien som sendes. Det henter ikke profilen, innleggene eller bildene til kontoen for å finne ut hvem som eier den.

## Kan jeg bruke forceToGenderize også for navn eller e-postadresser?

Ja. Det er valgfritt for inndata av typen name, email og username. Datasettet brukes først, og deretter, hvis det ikke finnes et resultat, KI med tolkning av kallenavn: 1 kreditt for et resultat fra datasettet eller 2 totalt hvis KI brukes.