# Bestäm kön utifrån ett användarnamn eller smeknamn

> Tolka ett användarnamn med GenderAPI.io V2. Testa vanlig namnmatchning eller den valfria tolkningen av smeknamn, förstå kostnaden på 1 eller 2 krediter och behåll okända resultat.

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

Last reviewed: 2026-09-28

## Namnsignaler och smeknamns betydelse är olika saker

Använd type: username för ett användarnamn eller smeknamn. Ett valfritt inledande @ tas bort vid matchningen mot datamängden. Extraheringen av kandidater tar hänsyn till avgränsare och siffror och kan kontrollera begränsade delsträngar. Smeknamnsläget behåller matchningen av hela delar men lägger inte till sådana delsträngskandidater. Den valda lagrade posten har det största totala antalet bland de tillgängliga kandidaterna; det visar inte det riktiga namnet på personen bakom kontot.

Vanlig AI-reserv letar efter ett igenkännbart förnamn. forceToGenderize tillåter dessutom en koppling via ett personligt smeknamn när inget riktigt namn kan extraheras. Båda vägarna kan returnera unknown; ett varumärke, en fiktiv figur eller ett delat konto representerar inte nödvändigtvis en enskild person.

| Exempel på indata | Tillvägagångssätt | Vad du bör kontrollera |
| --- | --- | --- |
| `@alice.smith` | Börja med vanlig fallback, som kontrollerar datamängden först. | Granska det valda namnet och matchningsmetoden; utgå inte från att den första delen valdes. |
| `robert89` | Siffrorna kan tas bort när kandidaterna extraheras. | Ett matchande namn är en koppling, ingen bekräftad identitet. |
| `prenses` | Aktivera forceToGenderize för att tillåta ett AI-försök utifrån smeknamnet när inget resultat hittas. | gender kan vara ett annat värde än null medan name är null. AI-värden är model_reported. |
| `team_support` | Behandla funktionskonton och delade konton som konton som kanske inte hör till en enskild person. | Behåll unknown och tilldela inte ett delat konto en individuell identitet. |

## Testa tolkning av smeknamn i din integration

Den här förfrågan aktiverar tolkning av smeknamn. Datamängden kontrolleras först. Om den inte ger något kön kan AI använda aliasets betydelse. Utelämna forceToGenderize för en vanlig sökning; enskilda förfrågningar använder ändå vanlig AI-reserv som standard.

Landskontexten TR anges för det här exemplet. Använd relevant kontext från din applikation och kontrollera data.match.scope; ett angivet land garanterar ingen landsspecifik post. Det visar varken nationalitet eller bosättning.

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

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

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

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

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

## Behåll resultatet för varje användarnamn när du bearbetar en lista

Använd POST /api/v2/gender/batch för listor med användarnamn eller för blandade listor med namn, e-postadresser och användarnamn. Gränsen är 50 poster med API-nyckel eller 10 i IP-provperioden. Varje post har egna alternativ för land och AI, och valfria ID:n måste vara unika inom batchen.

Som standard använder en batch bara datamängden. Aktivera fallback per post om du vill använda vanlig AI, eller ange forceToGenderize per post för tolkning av smeknamn. Kontrollera data eller error i varje resultat och använd id eller index för att koppla resultatet till den ursprungliga raden. Lyckade okända poster debiteras.

- [Skapa en batch och hantera delvisa fel](https://www.genderapi.io/sv/docs/v2/batch)
- [Fel, förlorade svar och nya försök](https://www.genderapi.io/sv/docs/v2/errors-and-retries)

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

## Måste ett användarnamn innehålla ett riktigt förnamn?

Vanlig AI-prediktion kräver ett användbart förnamn. Med forceToGenderize kan API:et dessutom försöka göra en koppling via ett smeknamn när sökningen i datamängden inte ger något resultat. Det läget kräver inget riktigt förnamn och kan returnera name: null.

## Garanterar forceToGenderize ett kön?

Nej. Det tillåter tolkning av smeknamn, men det slutliga resultatet kan ändå vara okänt. Behåll det inbyggda JSON-värdet null och kontrollera result_status och reason.

## Kontrollerar API:et profilen i sociala medier?

Den här endpointen tolkar det skickade värdet. Den hämtar varken kontots profil, inlägg eller foton för att ta reda på vem som äger det.

## Kan jag använda forceToGenderize även för namn eller e-postadresser?

Ja. Det är valfritt för indata av typen name, email och username. Datamängden används först och därefter AI med tolkning av smeknamn om inget resultat hittas: 1 kredit för ett resultat som fastställs i datamängden eller totalt 2 om AI används.