# Könsprediktion utifrån användarnamn och smeknamn

> Analysera användarnamn och smeknamn med V2: forceToGenderize, AI per post, okända resultat och kostnaden för upprepade förfrågningar.

Canonical HTML: https://www.genderapi.io/sv/blog/konsidentifiering-fran-smeknamn-och-anvandarnamn

Last reviewed: 2026-09-28

## Publiceringsuppgifter

Först publicerad: 2025-06-04T13:00:00.000Z

Senast granskad: 2026-09-28T00:00:00.000Z

## Kan kön fastställas utifrån ett användarnamn?

GenderAPI kan analysera namnsignaler i ett användarnamn, smeknamn eller visningsnamn när inget riktigt förnamn finns. Använd API:et för enskilda förfrågningar eller batchar eller Excel/CSV-flödet och behandla resultatet som en prediktion, inte som en verifierad identitet.

## Ett smeknamn är ingen identitetskontroll

@alice_smith kan matcha ett namnelement. För prenses med forceToGenderize kan en prediktion returneras trots att namnet förblir null. user47291 kan förbli okänt. Detta är exempelindata; vi tilldelar dem inget könsresultat i förväg.

## Hur fungerar könsprediktion utifrån ett användarnamn?

Systemet kontrollerar igenkännbara namnelement och andra språkliga ledtrådar i användarnamnet eller visningsnamnet. Vanlig AI söker ett användbart riktigt förnamn; med forceToGenderize kan den tolka ett smeknamn utan ett riktigt förnamn. Resultatet returneras tillsammans med kontextfält; slumpmässig eller otillräcklig indata bör inte tvingas fram till ett resultat.

- Användarnamn: Smeknamn eller visningsnamn
- Signalanalys: Förnamn och sammanhang
- Prediktion: Kön och konfidens

## Välj den metod som passar dina data

- [Enskild förfrågan Analysera ett användarnamn via REST API. Visa API-guiden →](https://www.genderapi.io/sv/docs/v2/gender-from-username)
- [Batchförfrågan Skicka flera poster i en strukturerad förfrågan. Visa guiden för batchar →](https://www.genderapi.io/sv/docs/v2/batch)
- [Excel/CSV-flöde Bearbeta en fil utan att bygga en integration. Öppna verktyget →](https://app.genderapi.io/csv)

## Analysera användarnamn från en Excel- eller CSV-fil i fyra steg

### Öppna Excel/CSV-verktyget

Öppna GenderAPI:s importverktyg och ladda upp filen som ska bearbetas.

### Välj källkolumn

Koppla kolumnen med användarnamn, smeknamn eller visningsnamn.

### Aktivera tolkning av smeknamn

Aktivera alternativet som tolkar alias och namn som används i sociala medier.

### Granska ett urval och exportera sedan

Granska först ett representativt urval av poster, bearbeta sedan hela filen och ladda ned de berikade data.

Nya konton innehåller 200 kostnadsfria API-krediter per dag, så att du kan pröva flödet på ett urval innan du bearbetar hela filen.

Uppladdade Excel- och CSV-filer tas bort från aktiva system inom fem dagar, och efter att resultaten har exporterats kan du begära att de tas bort tidigare. Löpande överskrivna, åtkomstbegränsade säkerhetskopior kan innehålla dem i upp till ytterligare 15 dagar. Mer information finns i [integritetspolicyn](https://www.genderapi.io/sv/privacy-policy).

## Använd som kompletterande signal när ett riktigt förnamn saknas

Analys av användarnamn kan vara till hjälp för data från sociala medier, communities, spel och profiler som användare själva har skapat, när namnfältet är tomt. Om du har en mer direkt och tillåten källa, som ett riktigt förnamn eller en e-postadress, använder du motsvarande endpoint.

- [Extrahera ett förnamn och en könssignal från en e-postadress](https://www.genderapi.io/sv/blog/extrahera-namn-fran-e-postadresser)
- [Bearbeta Excel- och CSV-filer i batch](https://www.genderapi.io/sv/blog/determining-gender-of-names-in-excel-csv-with-gender-api)

## Behandla inte resultatet som en verifierad identitet

Alla smeknamn innehåller inte ett riktigt förnamn, kulturella associationer skiljer sig åt och samma uttryck kan betyda olika saker på olika språk. Om signalen är otillräcklig accepterar du ett tomt resultat i stället för att göra svaga data till en slutgiltig slutsats.

Spara fälten för konfidens och källa från V2 tillsammans, mät prestandan med dina egna data och basera inget beslut med stor påverkan för en enskild person på denna signal, till exempel inom anställning, kredit eller hälsa.

## Spara källdata och prediktion separat

Behåll postens ursprungliga identifierare. API:et öppnar ingen profil, kontrollerar inte vem som äger ett konto och bekräftar ingen identitet. Skicka landskontext bara när du har en tillförlitlig uppgift; härled den inte från domänen eller webbplatsens språk.

Skicka användarnamnet med type: username; skicka ingen profil-URL. Sökningen i datamängden tar bort ett inledande @, normaliserar texten och bildar kandidater utifrån avgränsare och siffror. En standardförfrågan kan lägga till ett begränsat antal träffar efter prefix och suffix; forceToGenderize använder inte dessa extra fragment. Om flera poster matchar väljs den med högst registrerat antal. Använd type: email för e-postadresser och type: name för riktiga namn.

| Exempelindata | Fält eller alternativ | Tolkning |
| --- | --- | --- |
| @alice_smith | data.name / data.match | Behåll det ursprungliga användarnamnet; behandla inte det hittade fragmentet som ett verifierat förnamn. |
| prenses | forceToGenderize: true | Tillåter tolkning av ett smeknamn utan ett riktigt förnamn. Ett kön kan returneras med data.name satt till null; hitta inte på ett namn för personen. |
| user47291 | data.result_status: unknown | Otydlig eller otillräcklig indata kan förbli okänd. Det är inget skäl att automatiskt upprepa förfrågan. |

### Välj bearbetningsläge och kostnad i krediter

För en enskild förfrågan är fallback standardvärdet, för poster i en batch off. forceToGenderize är valfritt för namn, e-postadresser och användarnamn; utelämna då ai_mode eller använd fallback, eftersom alternativet inte kan kombineras med off och always. Även lyckade unknown-resultat debiteras. Det räcker med ett positivt startsaldo för att starta; när åtgärden är slutförd kan saldot bli negativt.

| Alternativ | Bearbetning | Kostnad per lyckad post |
| --- | --- | --- |
| options.ai_mode: off | Endast datamängd | 1 kredit |
| options.ai_mode: fallback | Först datamängden; om inget kön fastställs, vanlig AI-reserv | Totalt 1 kredit, inklusive AI |
| options.ai_mode: always | Direkt till AI | 2 krediter |
| forceToGenderize: true | Först datamängden, därefter tolkning av smeknamnet utan krav på ett riktigt förnamn | 1 om datamängden räcker; totalt 2 om AI används |

### Ge varje post i en batch egna alternativ

Exempelindata garanterar ingen viss prediktion. Ange GENDERAPI_API_KEY i servermiljön och lägg inte nyckeln i offentlig kod på klientsidan. V1 och V2 använder samma kontonyckel och samma saldo. Kontrollera nyckeln med /api/v2/usage och se till att meta.access.mode har värdet api_key.

Välj ett programmeringsspråk. [Konfigurera din API-nyckel](https://www.genderapi.io/sv/docs/v2/authentication#environment-setup), kör sedan exemplet på din server.

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.

### Innan du kör: åtkomst och felhantering

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.

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. För batchsvar med HTTP 200 kontrollerar du dessutom data eller error i varje post.

**cURL**

cURL 7.76+ i ett POSIX-skal. Kör i terminalen. [Dokumentation för körmiljön](https://curl.se/docs/manpage.html)

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender/batch' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "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. [Dokumentation för körmiljön](https://nodejs.org/api/globals.html#fetch)

```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 = {
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
};

const response = await fetch("https://api.genderapi.io/api/v2/gender/batch", {
  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. [Dokumentation för körmiljön](https://docs.python.org/3/library/urllib.request.html)

```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("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"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/batch",
    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. [Dokumentation för körmiljön](https://www.php.net/manual/en/book.curl.php)

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"items":[{"id":"profile-001","type":"username","value":"@alice_smith","options":{"ai_mode":"off"}},{"id":"profile-002","type":"username","value":"alexriver","options":{"ai_mode":"fallback"}},{"id":"profile-003","type":"username","value":"prenses","country":"TR","forceToGenderize":true}]}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender/batch');
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. [Dokumentation för körmiljön](https://docs.oracle.com/en/java/javase/17/docs/api/java.net.http/java/net/http/HttpClient.html)

```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 = "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"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/batch"))
            .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. [Dokumentation för körmiljön](https://learn.microsoft.com/en-us/dotnet/fundamentals/networking/http/httpclient)

```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/batch");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"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. [Dokumentation för körmiljön](https://pkg.go.dev/net/http)

```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 := "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender/batch", 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)
    }
}
```

- [Guide om fel och nya försök →](https://www.genderapi.io/sv/docs/v2/errors-and-retries)

### Hantera listresultat och upprepade förfrågningar

POST /api/v2/gender/batch tar emot upp till 50 poster med API-nyckel och 10 i IP-provperioden. Ge varje post egna värden för type, value och options. Om du vill använda vanlig AI-reserv anger du fallback uttryckligen i varje post. id måste vara unikt inom batchen; index räknas från noll inom den skickade batchen. Spara dina egna jobb- och källradsidentifierare separat.

HTTP 200 betyder inte att alla poster lyckades. Hantera resultaten identified, unknown och error separat; meta.summary.succeeded räknar både identified och unknown. Bedöm data.gender, source, confidence_kind, confidence, match och reason tillsammans. Behandla inte ett AI-värde och en frekvens i datamängden som likvärdiga.

Om meta.usage.billing_status har värdet confirmed upprepar du bara driftfel som tillåter en ny förfrågan. Om statusen är unconfirmed eller svaret har gått förlorat stoppar du och stämmer av debiteringen. Att skicka samma post igen, även ett lyckat unknown-resultat, skapar en ny avgiftsbelagd åtgärd; skicka aldrig om hela listan i blindo.

[Avtal för batchförfrågningar](https://www.genderapi.io/sv/docs/v2/batch) · [Svarsfält](https://www.genderapi.io/sv/docs/v2/responses) · [AI-alternativ](https://www.genderapi.io/sv/docs/v2/ai-options) · [Bedöm noggrannhet och konfidens](https://www.genderapi.io/sv/accuracy-methodology) · [Integritetspolicy](https://www.genderapi.io/sv/privacy-policy)

Tilläggen för Excel och Google Sheets samt andra färdiga integrationer kan använda en egen anslutning och ett eget resultatformat. Utgå inte från att deras utdata följer detta JSON-schema för V2; läs den aktuella guiden för respektive integration.

## Kön utifrån ett användarnamn eller smeknamn

### Kan kön fastställas utifrån ett användarnamn?

Om du aktiverar forceToGenderize i V2 kontrolleras datamängden först; om inget kön fastställs kan AI tolka smeknamnet utan att ett riktigt förnamn behövs. Resultatet kan förbli unknown och är ingen verifierad identitet. Vanlig AI-reserv kräver däremot ett användbart riktigt förnamn.

### Vilka användarnamn ger de mest användbara resultaten?

En mer användbar signal kan komma från värden som innehåller ett riktigt förnamn, en igenkännbar smeknamnsform eller ett tydligt namnelement. Slumpmässiga teckenföljder och varumärken ger kanske inget resultat alls.

### Kan jag analysera ett enskilt användarnamn via API?

Ja. Den enskilda endpointen analyserar en post. För flera poster finns en egen endpoint för batchförfrågningar.

### Kan jag importera en Excel- eller CSV-fil?

Ja. I filverktyget kan du välja kolumnen med användarnamn eller visningsnamn och aktivera tolkning av smeknamn.

### Varför ska jag spara fälten för konfidens och källa från V2 tillsammans?

I V2 ligger data.confidence mellan 0 och 1. Bedöm värdet tillsammans med source och confidence_kind, eftersom ett AI-värde och en frekvens i datamängden är olika mått. Behåll unknown-resultat och fältet reason.

### Passar resultatet för segmentering?

Det kan fungera som en kompletterande signal i aggregerade analyser och vid databerikning, men bör inte ensamt avgöra frågor med stor påverkan för en enskild person eller fastställa dennes identitet.

### Kan jag testa tjänsten kostnadsfritt?

Nya GenderAPI-konton innehåller 200 kostnadsfria API-krediter per dag, som du kan använda för att testa representativa urval via API eller fil.