# Odhad pohlaví z uživatelských jmen a přezdívek

> Analyzujte uživatelská jména a přezdívky ve V2: forceToGenderize, AI pro jednotlivé položky, neznámé výsledky a cena opakovaných požadavků.

Canonical HTML: https://www.genderapi.io/cs/blog/gender-prediction-from-nicknames-and-usernames

Last reviewed: 2026-09-30

## Informace o publikaci

Poprvé publikováno: 2025-07-21T11:00:00.000Z

Naposledy zkontrolováno: 2026-09-30T00:00:00.000Z

## Lze odhadnout pohlaví z uživatelského jména?

GenderAPI může analyzovat jmenné signály v uživatelských jménech, přezdívkách a zobrazovaných jménech, a to i když chybí skutečné křestní jméno. Použijte jednotlivé nebo dávkové požadavky API či nástroj Excel/CSV a s výsledkem zacházejte jako s odhadem, nikoli jako s potvrzenou identitou.

## Přezdívka nepotvrzuje identitu

@alice_smith může odpovídat jmennému prvku. U prenses s forceToGenderize se může vrátit odhad, i když jméno zůstane null. user47291 může zůstat neznámé. Jde jen o ukázkové vstupy; nemají žádný předem určený výsledek pohlaví.

## Jak funguje odhad pohlaví z uživatelského jména?

Systém v uživatelském nebo zobrazovaném jméně hledá rozpoznatelné jmenné prvky a další jazykové indicie. Běžná záložní AI hledá použitelné skutečné křestní jméno; s forceToGenderize může AI vyhodnotit přezdívku i bez skutečného křestního jména. Výsledek se vrací spolu s kontextovými poli. U náhodných nebo nedostatečných vstupů výsledek nevynucujte.

- Uživatelské jméno: Přezdívka nebo zobrazované jméno
- Analýza signálu: Jméno a kontext
- Odhad: Pohlaví a spolehlivost

## Zvolte metodu, která odpovídá vašim datům

- [Jednotlivý požadavek Analyzujte jedno uživatelské jméno přes REST API. Zobrazit návod k API →](https://www.genderapi.io/cs/docs/v2/gender-from-username)
- [Dávkový požadavek Odešlete více položek v jednom strukturovaném požadavku. Zobrazit návod k dávkovým požadavkům →](https://www.genderapi.io/cs/docs/v2/batch)
- [Postup v Excelu/CSV Zpracujte soubor bez vývoje vlastní integrace. Otevřít nástroj →](https://app.genderapi.io/csv)

## Analyzujte uživatelská jména v Excelu nebo CSV ve čtyřech krocích

### Otevřete nástroj Excel/CSV

Otevřete souborový nástroj GenderAPI a nahrajte soubor, který chcete zpracovat.

### Vyberte zdrojový sloupec

Přiřaďte sloupec s uživatelskými jmény, přezdívkami nebo zobrazovanými jmény.

### Zapněte analýzu přezdívek

Aktivujte možnost, která vyhodnocuje aliasy a jména ze sociálních sítí.

### Zkontrolujte vzorek a potom exportujte

Nejprve projděte reprezentativní vzorek záznamů, poté zpracujte celý soubor a stáhněte obohacená data.

Nové účty získávají 200 bezplatných kreditů denně, takže postup můžete otestovat na vzorku dříve, než zpracujete celý soubor.

Nahrané soubory Excel a CSV jsou naplánovány k odstranění z aktivních systémů do pěti dnů. Po exportu výsledků můžete požádat o dřívější odstranění. Data mohou zůstat v průběžně přepisovaných zálohách s omezeným přístupem ještě až 15 dalších dní. Více informací najdete v [zásadách ochrany osobních údajů](https://www.genderapi.io/cs/privacy-policy).

## Použijte ho jako doplňkový signál, když chybí skutečné křestní jméno

Když je pole se jménem prázdné, může být analýza uživatelských jmen užitečná pro data ze sociálních sítí, komunit, her a profilů, které si uživatelé vytvořili sami. Pokud máte přímější a spolehlivější zdroj, například skutečné křestní jméno nebo e-mailovou adresu, použijte odpovídající endpoint.

- [Získejte z e-mailové adresy kandidátní jméno a signál pohlaví](https://www.genderapi.io/cs/blog/extract-names-from-email-addresses)
- [Hromadné zpracování souborů Excel a CSV](https://www.genderapi.io/cs/blog/determining-gender-of-names-in-excel-csv-with-gender-api)

## Nepovažujte výsledek za potvrzenou identitu

Ne každá přezdívka obsahuje skutečné křestní jméno, kulturní asociace se liší a stejný výraz může mít v různých jazycích jiný význam. Když signál nestačí, přijměte prázdný výsledek místo jistého závěru ze slabých dat.

Ukládejte pole spolehlivosti a zdroje z V2 společně a měřte kvalitu na vlastních datech. Nezakládejte na tomto signálu rozhodnutí se závažným dopadem na konkrétní osobu, například o zaměstnání, úvěru nebo zdravotní péči.

## Ukládejte zdrojová data a odhad odděleně

Zachovejte původní identifikátor záznamu. API neotevírá žádný profil, neověřuje, komu účet patří, a nepotvrzuje identitu. Kontext země posílejte jen tehdy, když máte spolehlivou informaci, a neodvozujte ho z domény ani z jazyka webu.

Uživatelské jméno pošlete s type: username, nikoli jako URL profilu. Vyhledání v datové sadě odstraní úvodní @, normalizuje text a vytvoří kandidáty podle oddělovačů a číslic. Standardní požadavek může přidat omezený počet shod ze začátku a konce; forceToGenderize tyto doplňkové části nepoužívá. Pokud odpovídá více řádků, vybere se řádek s nejvyšším počtem zaznamenaných výskytů. Pro e-mailové adresy použijte type: email a pro skutečná jména type: name.

| Ukázkový vstup | Pole nebo možnost | Výklad |
| --- | --- | --- |
| @alice_smith | data.name / data.match | Zachovejte původní uživatelské jméno a rozpoznanou část nepovažujte za ověřené jméno. |
| prenses | forceToGenderize: true | Umožní vyhodnotit přezdívku i bez skutečného křestního jména. Pohlaví se může vrátit, i když je data.name null; jméno osobě nevymýšlejte. |
| user47291 | data.result_status: unknown | Nejednoznačné nebo nedostatečné vstupy mohou zůstat neznámé. Požadavek není důvod automaticky opakovat. |

### Zvolte režim zpracování a cenu v kreditech

Výchozí hodnota pro jednotlivý požadavek je fallback, pro položky dávkového požadavku off. forceToGenderize je volitelný pro jména, e-mailové adresy i uživatelská jména; v takovém případě ai_mode vynechte nebo použijte fallback, protože tuto možnost nelze kombinovat s off ani always. Účtují se i dokončené výsledky unknown. K zahájení stačí kladný zůstatek a po dokončení zpracování může být zůstatek záporný.

| Možnost | Zpracování | Kredity za dokončenou položku |
| --- | --- | --- |
| options.ai_mode: off | Pouze datová sada | 1 kredit |
| options.ai_mode: fallback | Nejprve datová sada; běžná záložní AI, pokud pohlaví nelze určit | Celkem 1 kredit, včetně AI |
| options.ai_mode: always | Přímo AI | 2 kredity |
| forceToGenderize: true | Nejprve datová sada, poté vyhodnocení přezdívky bez požadavku na skutečné křestní jméno | 1, pokud stačí datová sada; celkem 2, pokud se použije AI |

### Každé položce dávkového požadavku dejte vlastní možnosti

Ukázkové vstupy nezaručují konkrétní odhad. Nastavte GENDERAPI_API_KEY v serverovém prostředí a klíč nevkládejte do veřejného kódu na straně klienta. V1 i V2 používají stejný API klíč a stejný zůstatek účtu. Klíč ověřte pomocí /api/v2/usage a zkontrolujte, že meta.access.mode má hodnotu api_key.

Vyberte programovací jazyk. [Nastavte API klíč](https://www.genderapi.io/cs/docs/v2/authentication#environment-setup), potom spusťte příklad na svém serveru.

Každý požadavek na odhad je nová zpoplatněná operace, včetně opakování. Tyto příklady požadavky automaticky neopakují. Před odesláním dalšího požadavku zkontrolujte stav účtování.

### Před spuštěním: přístup a zpracování chyb

Tyto příklady spouštějte na svém serveru. V prostředí procesu nastavte GENDERAPI_API_KEY na svůj stávající API klíč. Ověřte, že meta.access.mode je api_key: nerozpoznaný klíč může přejít na zkušební režim podle IP.

U odpovědí JSON s HTTP 4xx a 5xx příklady zachovají tělo chyby a skončí s nenulovým návratovým kódem. Před opakováním požadavku zkontrolujte code, action a meta.usage.billing_status. U dávkových odpovědí s HTTP 200 zkontrolujte také data nebo error u každé položky.

**cURL**

cURL 7.76+ v shellu POSIX. Spusťte v terminálu. [Dokumentace běhového prostředí](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+; vestavěné fetch. Uložte jako example.mjs a spusťte node example.mjs. [Dokumentace běhového prostředí](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+; standardní knihovna. Uložte jako example.py a spusťte python3 example.py. [Dokumentace běhového prostředí](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+ s rozšířením cURL. Uložte jako example.php a spusťte php example.php. [Dokumentace běhového prostředí](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+; standardní HTTP klient. Uložte jako GenderApiExample.java a spusťte java GenderApiExample.java. [Dokumentace běhového prostředí](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**

Konzolová aplikace .NET 8+. Použijte jako Program.cs v konzolovém projektu a potom spusťte dotnet run. [Dokumentace běhového prostředí](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+; standardní knihovna. Uložte jako main.go a spusťte go run main.go. [Dokumentace běhového prostředí](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)
    }
}
```

- [Průvodce chybami a opakováním požadavků →](https://www.genderapi.io/cs/docs/v2/errors-and-retries)

### Zpracujte výsledky seznamů a opakované pokusy

POST /api/v2/gender/batch přijímá až 50 položek s API klíčem a 10 ve zkušebním režimu podle IP. Každé položce zadejte vlastní hodnoty type, value a options. Pokud chcete použít běžnou záložní AI, musíte fallback výslovně nastavit v každé položce. id musí být v rámci dávkového požadavku jedinečné a index začíná nulou v rámci odeslaného dávkového požadavku. Vlastní ID úloh a zdrojových řádků ukládejte zvlášť.

HTTP 200 neznamená, že byly dokončeny všechny položky. Výsledky identified, unknown a error zpracujte zvlášť; meta.summary.succeeded započítává identified i unknown. Vyhodnoťte data.gender, source, confidence_kind, confidence, match a reason společně a hodnotu AI nezaměňujte s četností v datové sadě.

Pokud má meta.usage.billing_status hodnotu confirmed, opakujte jen chyby, které nový pokus připouštějí. Pokud je stav unconfirmed nebo se odpověď ztratila, zastavte se a zkontrolujte účtování. Pokud stejnou položku odešlete znovu, a to i dokončený výsledek unknown, účtuje se jako nová operace; nikdy znovu neposílejte celý seznam bez kontroly.

[Pravidla dávkových požadavků](https://www.genderapi.io/cs/docs/v2/batch) · [Pole odpovědi](https://www.genderapi.io/cs/docs/v2/responses) · [Možnosti AI](https://www.genderapi.io/cs/docs/v2/ai-options) · [Hodnocení přesnosti a spolehlivosti](https://www.genderapi.io/cs/accuracy-methodology) · [Zásady ochrany osobních údajů](https://www.genderapi.io/cs/privacy-policy)

Doplňky pro Excel a Google Sheets a další hotové integrace mohou používat vlastní připojení a vlastní formát výsledků. Nepředpokládejte, že jejich výstup odpovídá tomuto schématu JSON V2; přečtěte si aktuální návod k příslušné integraci.

## Pohlaví z uživatelských jmen a přezdívek

### Lze odhadnout pohlaví z uživatelského jména?

Když je ve V2 zapnutý forceToGenderize, nejprve se prohledá datová sada. Pokud pohlaví nelze určit, AI může vyhodnotit přezdívku i bez skutečného křestního jména. Výsledek přesto může být unknown a nejde o potvrzenou identitu. Běžná záložní AI naproti tomu vyžaduje použitelné skutečné křestní jméno.

### Která uživatelská jména dávají nejužitečnější výsledky?

Hodnoty, které obsahují skutečné křestní jméno, běžnou podobu přezdívky nebo zřetelný jmenný prvek, poskytují užitečný signál častěji. Náhodné řetězce znaků a názvy značek nemusí vrátit žádný výsledek.

### Mohu přes API analyzovat jedno uživatelské jméno?

Ano. Endpoint pro jednotlivé požadavky analyzuje jednu hodnotu a samostatný endpoint pro dávkové požadavky zpracuje více položek.

### Mohu nahrát soubor Excel nebo CSV?

Ano. V souborovém nástroji vyberte sloupec s uživatelskými nebo zobrazovanými jmény a zapněte analýzu přezdívek.

### Proč ukládat pole spolehlivosti a zdroje z V2 společně?

Ve V2 leží data.confidence mezi 0 a 1. Hodnota AI a četnost v datové sadě měří různé věci, proto hodnotu čtěte spolu se source a confidence_kind. Zachovejte také výsledky unknown a pole reason.

### Lze výsledek použít k segmentaci zákazníků?

Může sloužit jako doplňkový signál v agregovaných analýzách nebo při obohacení dat, neměl by však sám rozhodovat o záležitostech se závažným dopadem na konkrétní osobu ani sloužit k určení něčí identity.

### Mohu to vyzkoušet zdarma?

Nové účty GenderAPI získávají 200 bezplatných kreditů denně, které lze použít k otestování reprezentativního vzorku přes API nebo souborový nástroj.