GenderAPI.io V2: dávkové odhady jmen, e-mailů a uživatelských jmen

Dávkové zpracování jmen, e-mailů a uživatelských jmen

Parametr	Typ	Povinné	Výchozí hodnota	Popis
`items`	`array<object>`	Ano	`—`	1 až 50 položek pro odhad; ve zkušebním režimu podle IP nejvýše 10. Výsledky zachovávají pořadí vstupů.
`items[].type`	`string`	Ano	`—`	Kategorie vstupu: name, email nebo username.
`items[].value`	`string`	Ano	`—`	Povinné. 1–254 znaků; nesmí být prázdné ani obsahovat řídicí znaky. E-mailové hodnoty musí mít platnou syntaxi e-mailové adresy.
`items[].country`	`string`	Ne	`—`	Volitelný kód ISO 3166-1 alpha-2 velkými písmeny, například TR nebo US. Vyhledávání pro konkrétní zemi může přejít na globální datovou sadu.
`items[].forceToGenderize`	`boolean`	Ne	`false`	Nejprve se prohledá datová sada, a pokud nepřinese výsledek, použije se AI s analýzou přezdívek. Podporováno pro name, email a username.
`items[].options`	`object`	Ne	`—`	Objekt s možnostmi AI pro daný vstup.
`items[].options.ai_mode`	`string`	Ne	`off`	Povolené hodnoty: off, fallback, always. Při forceToGenderize: true toto pole vynechte nebo použijte fallback.
`items[].id`	`string`	Ne	`—`	Volitelný identifikátor o délce 1–64 znaků v těle JSON u POST. Vrací se u každého výsledku dávky; v rámci dávky musí být jedinečný. U jednotlivých odhadů se přijme, ale v odpovědi se nevrací. V dotazech GET není podporován.

POST /gender/batch přijímá pole items s 1–50 položkami při přístupu s API klíčem, nebo nejvýše 10 položek ve zkušebním režimu podle IP. Můžete poslat jen jména, jen e-mailové adresy, jen uživatelská jména, nebo všechny tři typy kombinovat. Každá položka má vlastní country, forceToGenderize a options. ID jsou volitelná a musí být jedinečná.

Výsledky zachovávají pořadí vstupů a obsahují index, vaše volitelné id, charged_credits a právě jedno z polí data nebo error. HTTP 200 může obsahovat selhání jednotlivých položek, proto kontrolujte každou položku. meta.summary uvádí total, succeeded, identified, unknown a failed. Neznámý odhad je úspěšná a zpoplatněná položka.

Pokud selže validace nebo plánování požadavku, dávka je odmítnuta ještě před odečtením kreditů. Pokud selžou všechny provedené položky, API vrátí odpověď Problem se stavem mimo 2xx, s polem data a starším aliasem results. Neúspěšné položky po potvrzeném vrácení kreditů nic nestojí. Pokud účtování není potvrzeno, nepovažujte částky za jednotlivé položky za konečné.

Vyberte programovací jazyk. Nastavte API klíč, 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.

Průvodce chybami a opakováním požadavků →

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": "contact-1",
      "type": "name",
      "value": "Petra",
      "country": "CZ"
    },
    {
      "id": "contact-2",
      "type": "email",
      "value": "alice.smith@example.com",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "contact-3",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
}'

cURL 7.76+ v shellu POSIX. Spusťte v terminálu. Dokumentace běhového prostředí

// 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": "contact-1",
      "type": "name",
      "value": "Petra",
      "country": "CZ"
    },
    {
      "id": "contact-2",
      "type": "email",
      "value": "alice.smith@example.com",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "contact-3",
      "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.
}

Node.js 22+; vestavěné fetch. Uložte jako example.mjs a spusťte node example.mjs. Dokumentace běhového prostředí

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\":\"contact-1\",\"type\":\"name\",\"value\":\"Petra\",\"country\":\"CZ\"},{\"id\":\"contact-2\",\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"contact-3\",\"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.

Python 3.10+; standardní knihovna. Uložte jako example.py a spusťte python3 example.py. Dokumentace běhového prostředí

<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"items":[{"id":"contact-1","type":"name","value":"Petra","country":"CZ"},{"id":"contact-2","type":"email","value":"alice.smith@example.com","options":{"ai_mode":"fallback"}},{"id":"contact-3","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.

PHP 8+ s rozšířením cURL. Uložte jako example.php a spusťte php example.php. Dokumentace běhového prostředí

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\":\"contact-1\",\"type\":\"name\",\"value\":\"Petra\",\"country\":\"CZ\"},{\"id\":\"contact-2\",\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"contact-3\",\"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.
    }
}

Java 17+; standardní HTTP klient. Uložte jako GenderApiExample.java a spusťte java GenderApiExample.java. Dokumentace běhového prostředí

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\":\"contact-1\",\"type\":\"name\",\"value\":\"Petra\",\"country\":\"CZ\"},{\"id\":\"contact-2\",\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"contact-3\",\"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.
}

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í

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\":\"contact-1\",\"type\":\"name\",\"value\":\"Petra\",\"country\":\"CZ\"},{\"id\":\"contact-2\",\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"contact-3\",\"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)
    }
}

Go 1.22+; standardní knihovna. Uložte jako main.go a spusťte go run main.go. Dokumentace běhového prostředí

Čtení dávkové odpovědi

Tento příklad kombinuje dva skutečné výsledky získané 1. října 2026, shodu v datové sadě a neznámý výsledek, s ilustrativním selháním poskytovatele. Ukazuje částečně úspěšnou odpověď HTTP 200, nikoli očekávaný výstup výše uvedeného dávkového požadavku. Dvě úspěšné položky stojí každá 1 kredit; u neúspěšné položky je potvrzena nulová částka.

{
  "data": [
    {
      "index": 0,
      "id": "known",
      "charged_credits": 1,
      "data": {
        "input": {
          "type": "name",
          "value": "Petra",
          "country": "CZ"
        },
        "name": "petra",
        "gender": "female",
        "country": "CZ",
        "confidence": 0.9932735426008968,
        "confidence_kind": "observed_frequency",
        "sample_count": 892,
        "source": "dataset",
        "result_status": "identified",
        "reason": null,
        "country_source": "dataset",
        "match": {
          "name": "petra",
          "method": "normalized",
          "scope": "country",
          "country": "CZ"
        }
      }
    },
    {
      "index": 1,
      "id": "missing",
      "charged_credits": 1,
      "data": {
        "input": {
          "type": "name",
          "value": "zzzxxyy",
          "country": null
        },
        "name": null,
        "gender": null,
        "country": null,
        "confidence": null,
        "confidence_kind": null,
        "sample_count": null,
        "source": "none",
        "result_status": "unknown",
        "reason": "not_found",
        "country_source": null,
        "match": {
          "name": null,
          "method": null,
          "scope": null,
          "country": null
        }
      }
    },
    {
      "index": 2,
      "id": "failed",
      "charged_credits": 0,
      "error": {
        "type": "urn:genderapi:problem:ai_upstream_error",
        "title": "ai upstream error",
        "status": 502,
        "detail": "The AI provider could not complete the request.",
        "instance": "urn:uuid:11111111-1111-4111-8111-111111111111",
        "code": "ai_upstream_error",
        "request_id": "11111111-1111-4111-8111-111111111111",
        "documentation": "https://api.genderapi.io/api/v2/errors",
        "action": "inspect_billing_before_retry"
      }
    }
  ],
  "meta": {
    "request_id": "11111111-1111-4111-8111-111111111111",
    "duration_ms": 12,
    "access": {
      "mode": "ip_trial",
      "reason": "api_key_missing"
    },
    "usage": {
      "charged_credits": 2,
      "remaining_credits": 6,
      "billing_status": "confirmed",
      "resets_at": "2026-09-26T12:00:00.000Z",
      "limit": 10,
      "period_seconds": 86400
    },
    "summary": {
      "total": 3,
      "succeeded": 2,
      "identified": 1,
      "unknown": 1,
      "failed": 1
    }
  }
}

Pole výsledků dávky

Pole	Typ	Může být null	Příklad	Popis
`data`	`array<object>`	Ne	`[…]`	Seřazené výsledky. Každá položka obsahuje odhad nebo chybu; kontrolujte každou položku.
`data[].index`	`integer`	Ne	`0`	Pozice v odeslaném poli items, počítaná od nuly.
`data[].id`	`string`	Ne	`"contact-1"`	Váš identifikátor vstupu; uvádí se jen tehdy, pokud jste ho zadali.
`data[].charged_credits`	`integer`	Ne	`1`	Čistá částka za položku po potvrzeném vrácení kreditů. Pokud celkové účtování není potvrzeno, nepovažujte ji za konečnou.
`data[].data`	`object`	Ne	`{…}`	Uvádí se u úspěšné položky, včetně neznámých výsledků. Používá pole odhadu popsaná v průvodci odpověďmi.
`data[].error`	`object`	Ne	`{…}`	Uvádí se místo data u neúspěšné položky. Používá pole Problem Details popsaná v průvodci chybami.

Pole souhrnu dávky

Pole	Typ	Může být null	Příklad	Popis
`meta.summary.total`	`integer`	Ne	`3`	Celkový počet položek v dávce.
`meta.summary.succeeded`	`integer`	Ne	`2`	Úspěšné položky, včetně neznámých odhadů.
`meta.summary.identified`	`integer`	Ne	`1`	Úspěšné položky s pohlavím jiným než null.
`meta.summary.unknown`	`integer`	Ne	`1`	Úspěšné položky s pohlavím null; tyto výsledky se účtují.
`meta.summary.failed`	`integer`	Ne	`1`	Neúspěšné položky. total = succeeded + failed; succeeded = identified + unknown.

Metadata přístupu, účtování a požadavku

Pole	Typ	Může být null	Příklad	Popis
`meta.request_id`	`string`	Ne	`"550e8400-e29b-41d4-a716-446655440000"`	Jedinečný identifikátor tohoto pokusu HTTP; posílá se také v X-Request-ID.
`meta.duration_ms`	`integer`	Ne	`42`	Doba zpracování požadavku v milisekundách.
`meta.access.mode`	`string`	Ne	`"api_key"`	api_key, ip_trial nebo unauthenticated. U placeného účtu ověřte api_key.
`meta.access.reason`	`string`	Ano	`null`	Důvod přechodu na zkušební režim: api_key_missing, api_key_invalid nebo api_key_not_found; jinak null.
`meta.usage.charged_credits`	`integer`	Ano	`1`	Čistý počet odečtených kreditů. Nula před odečtením nebo po úplném potvrzeném vrácení; null, pokud účtování není potvrzeno.
`meta.usage.remaining_credits`	`integer`	Ano	`99`	Zůstatek po dokončení operace. Může být záporný; null, pokud není k dispozici nebo účtování není potvrzeno.
`meta.usage.billing_status`	`string`	Ne	`"confirmed"`	not_charged, confirmed nebo unconfirmed. Zkontrolujte před opakováním neúspěšného odhadu.
`meta.usage.resets_at`	`string`	Ano	`"2026-09-27T12:00:00.000Z"`	Čas obnovení zkušebního režimu podle IP v UTC (ISO 8601); null u účtů s API klíčem nebo pokud není znám.
`meta.usage.limit`	`integer`	Ano	`10`	Limit kreditů zkušebního režimu podle IP; null u účtů s API klíčem.
`meta.usage.period_seconds`	`integer`	Ano	`86400`	Délka období zkušebního režimu podle IP v sekundách; null u účtů s API klíčem.

Plánování kreditů a opakování u dávek

Autentizujte se svým stávajícím API klíčem v hlavičce Bearer a posílejte Content-Type: application/json. Každá odeslaná dávka je nová operace. Při opakování po částečném selhání odešlete po kontrole účtování jen neúspěšné položky; opětovně odeslané úspěšné položky se naúčtují znovu.

Položky dávky mají ve výchozím nastavení AI vypnutou (off) a stojí 1 kredit za úspěšnou položku. Explicitní fallback stojí také celkem 1 kredit, včetně AI. always stojí 2 kredity. forceToGenderize stojí 1 kredit za výsledek z datové sady, nebo 2 kredity, pokud se použije AI. Úspěšné neznámé výsledky se účtují. K zahájení dávky stačí kladný počáteční zůstatek 1 kredit; konečné vyúčtování může zůstatek dostat do záporu.

Zpracujte seznam kontaktů bez ztráty jediného řádku

Endpoint pro dávkové požadavky zpracuje seznamy pouze se jmény, pouze s e-mailovými adresami i kombinované vstupy. S API klíčem rozdělte úlohu na dávky po nejvýše 50 položkách; zkušební režim podle IP povoluje nejvýše 10 položek na požadavek. Sami si evidujte, kde v úloze jste, a každé položce dejte id, které je v rámci dávky jedinečné. Vrácený index se počítá od nuly v rámci odeslané dávky, nikoli v rámci celého seznamu kontaktů.

Krok	Co uložit nebo zkontrolovat	Proč na tom záleží
1. Připravte každou dávku	Zachovejte zdrojový řádek a id položky; country a možnosti AI nastavte pro každou položku.	Nespoléhejte na to, že je jméno mezi kontakty jedinečné.
2. Přečtěte celou odpověď	Uložte meta.request_id a každý záznam v data[] přiřaďte podle id nebo index.	HTTP 200 může obsahovat úspěšné odhady i chyby jednotlivých položek.
3. Uložte úspěšné výsledky	Zachovejte identifikované i neznámé odhady, včetně hodnot JSON null a polí s podklady.	Neznámý výsledek je dokončený a zpoplatněný; není to neúspěšný řádek k automatickému opakování.
4. Porovnejte chyby a kredity	Než se rozhodnete pro další požadavek, zkontrolujte každé error a meta.usage.billing_status.	Když je účtování potvrzeno, opakujte jen neúspěšné položky, u kterých to chyba odůvodňuje. Úspěšné položky by se naúčtovaly znovu.
5. Odložte nejistá opakování	Pokud účtování není potvrzeno nebo síťová chyba zanechá výsledek neznámý, uložte ID požadavku.	Neposílejte celou dávku znovu naslepo; nejprve se řiďte pokyny k chybám a účtování.

Zvolte režim odhadu pro každý kontakt

Tento spustitelný požadavek používá tři různá pravidla: pouze datovou sadu pro celé jméno, běžnou záložní AI pro e-mailovou adresu a záložní AI s analýzou přezdívek pro uživatelské jméno. Jde o ukázkový vstup, nikoli o slib, že všechny tři kontakty dostanou pohlaví. Nad kódem vyberte programovací jazyk a před spuštěním nastavte GENDERAPI_API_KEY.

Bez forceToGenderize mají položky dávky AI ve výchozím nastavení vypnutou (off), na rozdíl od jednotlivých vyhledání. Pro běžnou záložní AI nastavte fallback explicitně. off i běžný fallback stojí 1 kredit za úspěšnou položku; always přeskočí datovou sadu a stojí 2 kredity. forceToGenderize stojí 1 kredit za výsledek z datové sady, nebo celkem 2 kredity, pokud se použije AI. Účtují se i úspěšné neznámé výsledky. forceToGenderize nekombinujte s off ani always.