Previsões em lote por nome, e-mail e nome de usuário

Nomes, e-mails e nomes de usuário em lote

Parâmetro	Tipo	Obrigatório	Padrão	Descrição
`items`	`array<object>`	Sim	`—`	Entre 1 e 50 itens de previsão; no máximo 10 no teste por IP. Os resultados preservam a ordem de entrada.
`items[].type`	`string`	Sim	`—`	Categoria de entrada: name, email ou username.
`items[].value`	`string`	Sim	`—`	Obrigatório. 1–254 caracteres; não pode estar em branco nem conter caracteres de controle. Valores de e-mail precisam ter sintaxe de e-mail válida.
`items[].country`	`string`	Não	`—`	Código ISO 3166-1 alfa-2 opcional em maiúsculas, por exemplo TR ou US. A consulta específica do país pode recorrer ao conjunto de dados global.
`items[].forceToGenderize`	`boolean`	Não	`false`	Consulta primeiro o conjunto de dados e, se não houver resultado, usa a IA com interpretação de apelidos. Aceito em name, email e username.
`items[].options`	`object`	Não	`—`	Objeto com as opções de IA de cada entrada.
`items[].options.ai_mode`	`string`	Não	`off`	Valores permitidos: off, fallback, always. Com forceToGenderize: true, omita este campo ou use fallback.
`items[].id`	`string`	Não	`—`	Identificador opcional de 1 a 64 caracteres no JSON do POST. É retornado junto com cada resultado do lote e deve ser único dentro do lote. Em previsões individuais, é aceito, mas não é devolvido. Não é aceito em consultas GET.

POST /gender/batch aceita um array items com 1 a 50 itens no acesso com chave de API, ou no máximo 10 com o teste por IP. Você pode enviar apenas nomes, apenas e-mails, apenas nomes de usuário ou misturar os três. Cada item tem seus próprios country, forceToGenderize e options. Os IDs são opcionais e precisam ser únicos.

Os resultados preservam a ordem de entrada e incluem index, o seu id opcional, charged_credits e exatamente um entre data e error. Um HTTP 200 pode conter falhas em itens, por isso verifique cada item. meta.summary informa total, succeeded, identified, unknown e failed. Uma previsão desconhecida é um item bem-sucedido e cobrado.

Uma falha de validação ou de planejamento da requisição rejeita o lote antes do débito. Se todos os itens executados falharem, a API retorna uma resposta Problem diferente de 2xx com um array data e o alias legado results. Itens com falha custam zero após um reembolso confirmado. Se a cobrança não estiver confirmada, não presuma que os valores cobrados por item são definitivos.

Escolha uma linguagem de programação. Configure sua chave de API, depois execute o exemplo no seu servidor.

Cada requisição de previsão é uma nova operação cobrada, inclusive as novas tentativas. Estes exemplos não fazem novas tentativas automaticamente. Verifique o status da cobrança antes de enviar outra requisição.

Antes de executar: acesso e tratamento de erros

Execute estes exemplos no seu servidor. Defina GENDERAPI_API_KEY no ambiente do processo com a sua chave de API existente. Confirme que meta.access.mode é api_key: uma chave não reconhecida pode levar ao teste por IP.

Respostas JSON com HTTP 4xx e 5xx preservam o corpo do erro e retornam um código de saída diferente de zero. Verifique code, action e meta.usage.billing_status antes de fazer uma nova tentativa. Em respostas de lote com HTTP 200, verifique também data ou error de cada item.

Guia de erros e novas tentativas →

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": "Beatriz",
      "country": "BR"
    },
    {
      "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+ em um shell POSIX. Execute no seu terminal. Documentação do ambiente de execução

// 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": "Beatriz",
      "country": "BR"
    },
    {
      "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+; fetch nativo. Salve como example.mjs e execute node example.mjs. Documentação do ambiente de execução

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\":\"Beatriz\",\"country\":\"BR\"},{\"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+; biblioteca padrão. Salve como example.py e execute python3 example.py. Documentação do ambiente de execução

<?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":"Beatriz","country":"BR"},{"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+ com a extensão cURL. Salve como example.php e execute php example.php. Documentação do ambiente de execução

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\":\"Beatriz\",\"country\":\"BR\"},{\"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+; cliente HTTP padrão. Salve como GenderApiExample.java e execute java GenderApiExample.java. Documentação do ambiente de execução

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\":\"Beatriz\",\"country\":\"BR\"},{\"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.
}

Aplicação de console .NET 8+. Use como Program.cs em um projeto de console e depois execute dotnet run. Documentação do ambiente de execução

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\":\"Beatriz\",\"country\":\"BR\"},{\"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+; biblioteca padrão. Salve como main.go e execute go run main.go. Documentação do ambiente de execução

Interpretar uma resposta de lote

Este exemplo combina dois resultados reais obtidos em 1º de outubro de 2026, uma correspondência no conjunto de dados e um resultado desconhecido, com uma falha ilustrativa do provedor. Ele mostra uma resposta HTTP 200 com sucesso parcial, não a saída esperada da requisição em lote acima. Os dois itens bem-sucedidos custam 1 crédito cada; o item com falha tem cobrança zero confirmada.

{
  "data": [
    {
      "index": 0,
      "id": "known",
      "charged_credits": 1,
      "data": {
        "input": {
          "type": "name",
          "value": "Beatriz",
          "country": "BR"
        },
        "name": "beatriz",
        "gender": "female",
        "country": "BR",
        "confidence": 0.9921450737005431,
        "confidence_kind": "observed_frequency",
        "sample_count": 10312,
        "source": "dataset",
        "result_status": "identified",
        "reason": null,
        "country_source": "dataset",
        "match": {
          "name": "beatriz",
          "method": "normalized",
          "scope": "country",
          "country": "BR"
        }
      }
    },
    {
      "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
    }
  }
}

Campos dos resultados do lote

Campo	Tipo	Pode ser null	Exemplo	Descrição
`data`	`array<object>`	Não	`[…]`	Resultados ordenados. Cada item contém uma previsão ou um erro; verifique todos os itens.
`data[].index`	`integer`	Não	`0`	Posição no array items enviado, começando em zero.
`data[].id`	`string`	Não	`"contact-1"`	Seu identificador de entrada, presente apenas quando fornecido.
`data[].charged_credits`	`integer`	Não	`1`	Cobrança líquida do item após reembolsos confirmados. Não a considere definitiva se a cobrança geral não estiver confirmada.
`data[].data`	`object`	Não	`{…}`	Presente em itens bem-sucedidos, inclusive resultados desconhecidos. Usa os campos de previsão documentados no guia de respostas.
`data[].error`	`object`	Não	`{…}`	Presente em itens com falha, no lugar de data. Usa os campos de Problem Details documentados no guia de erros.

Campos do resumo do lote

Campo	Tipo	Pode ser null	Exemplo	Descrição
`meta.summary.total`	`integer`	Não	`3`	Número total de itens no lote.
`meta.summary.succeeded`	`integer`	Não	`2`	Itens bem-sucedidos, inclusive previsões desconhecidas.
`meta.summary.identified`	`integer`	Não	`1`	Itens bem-sucedidos com gênero diferente de null.
`meta.summary.unknown`	`integer`	Não	`1`	Itens bem-sucedidos com gênero null; esses resultados são cobrados.
`meta.summary.failed`	`integer`	Não	`1`	Itens com falha. total = succeeded + failed; succeeded = identified + unknown.

Metadados de acesso, cobrança e requisição

Campo	Tipo	Pode ser null	Exemplo	Descrição
`meta.request_id`	`string`	Não	`"550e8400-e29b-41d4-a716-446655440000"`	Identificador único desta tentativa HTTP; também enviado em X-Request-ID.
`meta.duration_ms`	`integer`	Não	`42`	Tempo de processamento da requisição em milissegundos.
`meta.access.mode`	`string`	Não	`"api_key"`	api_key, ip_trial ou unauthenticated. Verifique api_key ao usar uma conta paga.
`meta.access.reason`	`string`	Sim	`null`	Motivo do uso do teste por IP: api_key_missing, api_key_invalid ou api_key_not_found; caso contrário, null.
`meta.usage.charged_credits`	`integer`	Sim	`1`	Créditos líquidos cobrados. Zero antes da cobrança ou após reembolso integral confirmado; null se a cobrança não estiver confirmada.
`meta.usage.remaining_credits`	`integer`	Sim	`99`	Saldo ao concluir a operação. Pode ser negativo; null se indisponível ou se a cobrança não estiver confirmada.
`meta.usage.billing_status`	`string`	Não	`"confirmed"`	not_charged, confirmed ou unconfirmed. Verifique antes de repetir uma previsão com falha.
`meta.usage.resets_at`	`string`	Sim	`"2026-09-27T12:00:00.000Z"`	Momento da renovação do teste por IP em UTC (ISO 8601); null para contas com chave de API ou quando desconhecido.
`meta.usage.limit`	`integer`	Sim	`10`	Cota do teste por IP; null para contas com chave de API.
`meta.usage.period_seconds`	`integer`	Sim	`86400`	Janela do teste por IP em segundos; null para contas com chave de API.

Planejar créditos e novas tentativas em lote

Autentique-se com sua chave de API existente no cabeçalho Bearer e envie Content-Type: application/json. Cada lote enviado é uma nova operação. Ao fazer uma nova tentativa após uma falha parcial, envie apenas os itens com falha depois de verificar a cobrança; reenviar itens bem-sucedidos gera uma nova cobrança.

Por padrão, itens de lote usam a IA desativada (off) e custam 1 crédito por item bem-sucedido. fallback explícito também custa 1 no total, incluindo a IA. always custa 2. forceToGenderize custa 1 para um resultado encontrado no conjunto de dados ou 2 se a IA for usada. Resultados desconhecidos bem-sucedidos são cobrados. Um saldo inicial positivo, mesmo de 1 crédito, basta para iniciar o lote; a cobrança final pode deixar o saldo negativo.

Processar uma lista de contatos sem perder nenhuma linha

O endpoint de lote aceita listas só de nomes, listas só de endereços de e-mail e entradas mistas. Com uma chave de API, divida o trabalho em lotes de no máximo 50 itens; o teste por IP permite no máximo 10 por requisição. Acompanhe a sua posição no trabalho e atribua a cada item um id único dentro do lote. O index retornado começa em zero dentro do lote enviado, não da lista de contatos inteira.

Passo	O que salvar ou verificar	Por que isso importa
1. Prepare cada lote	Guarde a linha de origem e o id do item; defina country e as opções de IA para cada item.	Não presuma que um nome é único entre todos os contatos.
2. Leia a resposta inteira	Salve meta.request_id e associe cada item de data[] pelo id ou pelo index.	Uma resposta HTTP 200 pode conter tanto previsões bem-sucedidas quanto erros em itens individuais.
3. Salve os resultados bem-sucedidos	Guarde as previsões identificadas e desconhecidas, incluindo valores JSON null e os campos de evidência.	Um resultado desconhecido foi concluído e cobrado; não é uma linha com falha para reenviar automaticamente.
4. Reconcilie erros e créditos	Verifique cada error e meta.usage.billing_status antes de decidir enviar uma nova requisição.	Depois que a cobrança for confirmada, faça uma nova tentativa apenas com os itens com falha cujo erro justifique isso. Itens bem-sucedidos seriam cobrados novamente.
5. Adie novas tentativas incertas	Salve o ID da requisição se a cobrança não estiver confirmada ou se um erro de rede deixar o resultado desconhecido.	Não reenvie o lote inteiro às cegas; siga primeiro as orientações sobre erros e cobrança.

Escolher um modo de previsão para cada contato

Esta requisição executável usa três regras diferentes: apenas o conjunto de dados para um nome completo, o fallback de IA comum para um endereço de e-mail e o fallback de IA com interpretação de apelidos para um nome de usuário. São entradas de exemplo, não a promessa de que os três contatos receberão um gênero. Escolha uma linguagem de programação acima do código e defina GENDERAPI_API_KEY antes de executar o exemplo.

Sem forceToGenderize, a IA fica em off por padrão nos itens de lote, ao contrário das consultas individuais. Informe fallback explicitamente se quiser usar o fallback de IA comum. Tanto off quanto o fallback comum custam 1 crédito por item bem-sucedido; always ignora o conjunto de dados e custa 2. forceToGenderize custa 1 para um resultado encontrado no conjunto de dados ou 2 no total se a IA for usada. Resultados desconhecidos bem-sucedidos também são cobrados. Não combine forceToGenderize com off ou always.