Gênero pelo nome com a API V2

Antes de enviar a requisição

Envie JSON para POST https://api.genderapi.io/api/v2/gender. Use sua chave de API existente em Authorization: Bearer YOUR_API_KEY e Content-Type: application/json. Cada requisição é processada de forma independente.

Escolha sua linguagem no exemplo de código. Defina GENDERAPI_API_KEY no ambiente do processo antes de executá-lo. Chaves ausentes ou não reconhecidas podem usar o teste por IP compartilhado; por isso, confirme que meta.access.mode é api_key ao integrar uma conta.

Gênero a partir de um nome

Parâmetro	Tipo	Obrigatório	Padrão	Descrição
`type`	`string`	Sim	`—`	Categoria de entrada: name, email ou username.
`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.
`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.
`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.
`options`	`object`	Não	`—`	Objeto com as opções de IA de cada entrada.
`options.ai_mode`	`string`	Não	`fallback`	Valores permitidos: off, fallback, always. Com forceToGenderize: true, omita este campo ou use fallback.
`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.

Use type: name para um primeiro nome ou um nome completo. Uma resposta bem-sucedida ainda pode conter gender: null. Requisições individuais consultam primeiro o conjunto de dados e, por padrão, recorrem à IA quando não é possível determinar um gênero.

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.

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' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "type": "name",
  "value": "João",
  "country": "BR"
}'

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 = {
  "type": "name",
  "value": "João",
  "country": "BR"
};

const response = await fetch("https://api.genderapi.io/api/v2/gender", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
  signal: AbortSignal.timeout(30_000),
  redirect: "error",
});
const raw = await response.text();
if (!(response.headers.get("content-type") ?? "").includes("json")) {
  throw new Error(`HTTP ${response.status}: expected JSON; request ID ${response.headers.get("x-request-id")}`);
}
const result = JSON.parse(raw); // Also accepts application/problem+json.
if (!response.ok) {
  console.error(`HTTP ${response.status}`, result);
  process.exitCode = 1; // A retry is a new operation; inspect billing first.
} else {
  console.log(JSON.stringify(result, null, 2));
  // For batches, inspect every item: HTTP 200 may contain item errors.
}

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("{\"type\":\"name\",\"value\":\"João\",\"country\":\"BR\"}")

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

request = urllib.request.Request(
    "https://api.genderapi.io/api/v2/gender",
    method="POST",
    data=json.dumps(body).encode("utf-8"),
    headers={
        "Authorization": "Bearer " + api_key,
        "Content-Type": "application/json",
    },
)
opener = urllib.request.build_opener(NoRedirect())
try:
    response = opener.open(request, timeout=30)
except urllib.error.HTTPError as error:
    response = error  # Keep the Problem Details body on non-2xx responses.
with response:
    status = response.status
    raw = response.read().decode("utf-8")
    if "json" not in response.headers.get("Content-Type", ""):
        raise RuntimeError(f"HTTP {status}: expected a JSON response")
    result = json.loads(raw)
print(json.dumps(result, indent=2), file=sys.stderr if status >= 300 else sys.stdout)
if not 200 <= status < 300:
    sys.exit(1)  # Inspect code, action and billing before retrying.
# For batches, inspect every item even when HTTP status is 200.

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('{"type":"name","value":"João","country":"BR"}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($body, JSON_THROW_ON_ERROR),
]);
$raw = curl_exec($ch);
if ($raw === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE) ?: '';
curl_close($ch);
if (strpos($contentType, 'json') === false) {
    throw new RuntimeException("HTTP $status: expected a JSON response");
}
$result = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
$output = json_encode($result, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR) . PHP_EOL;
if ($status < 200 || $status >= 300) {
    fwrite(STDERR, $output); // Preserve the Problem Details body.
    exit(1);
}
echo $output;
// For batches, inspect every item; HTTP 200 can contain item errors.

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 = "{\"type\":\"name\",\"value\":\"João\",\"country\":\"BR\"}";
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NEVER)
            .build();
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.genderapi.io/api/v2/gender"))
            .timeout(Duration.ofSeconds(30))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8))
            .build();
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        if (!response.headers().firstValue("content-type").orElse("").contains("json")) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": expected JSON");
        }
        // JSON text; parse with your application's JSON library when integrating.
        if (response.statusCode() < 200 || response.statusCode() >= 300) {
            System.err.println(response.body()); // Includes Problem Details.
            System.exit(1);
        }
        System.out.println(response.body());
        // For batches, inspect each item's data or error, including on HTTP 200.
    }
}

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");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"type\":\"name\",\"value\":\"João\",\"country\":\"BR\"}", 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 := "{\"type\":\"name\",\"value\":\"João\",\"country\":\"BR\"}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender", strings.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + apiKey)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{
        Timeout: 30 * time.Second,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        },
    }
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    raw, err := io.ReadAll(response.Body)
    if err != nil { return err }
    if !strings.Contains(response.Header.Get("Content-Type"), "json") || !json.Valid(raw) {
        return fmt.Errorf("HTTP %d: expected a JSON response", response.StatusCode)
    }
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, raw)
    }
    fmt.Println(string(raw))
    // For batches, inspect every item even on HTTP 200.
    return nil
}

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err) // Keep Problem Details for error handling.
        os.Exit(1)
    }
}

Go 1.22+; biblioteca padrão. Salve como main.go e execute go run main.go. Documentação do ambiente de execução

Exemplo de resposta

Esta é uma resposta real obtida em 1º de outubro de 2026 com uma chave de API; apenas o saldo da conta foi substituído. Ela não é uma medida de precisão, e uma requisição real pode retornar um resultado diferente. Requisições com chave de API informam meta.access.mode: api_key e retornam null nos campos de cota exclusivos do teste; requisições pelo teste por IP informam ip_trial. Leia data para a inferência e meta.usage para o resultado da cobrança da operação.

{
  "data": {
    "input": {
      "type": "name",
      "value": "João",
      "country": "BR"
    },
    "name": "joão",
    "gender": "male",
    "country": "BR",
    "confidence": 0.995472640699399,
    "confidence_kind": "observed_frequency",
    "sample_count": 25622,
    "source": "dataset",
    "result_status": "identified",
    "reason": null,
    "country_source": "dataset",
    "match": {
      "name": "joão",
      "method": "normalized",
      "scope": "country",
      "country": "BR"
    }
  },
  "meta": {
    "request_id": "ddd9cbc6-6728-4ecb-b6ec-4d4c706daf83",
    "duration_ms": 21,
    "access": {
      "mode": "api_key",
      "reason": null
    },
    "usage": {
      "charged_credits": 1,
      "remaining_credits": 49999,
      "billing_status": "confirmed",
      "resets_at": null,
      "limit": null,
      "period_seconds": null
    }
  }
}

Campos da resposta e confiança

Campos da resposta de previsão

Campo	Tipo	Pode ser null	Exemplo	Descrição
`data.input`	`object`	Não	`{"type":"name","value":"João","country":"BR"}`	Tipo de entrada, valor e país. forceToGenderize é incluído quando for true.
`data.name`	`string`	Sim	`"joão"`	Nome próprio correspondente ou extraído; null quando não houver nenhum.
`data.gender`	`string`	Sim	`"male"`	male, female ou JSON null. É uma inferência, não uma identidade pessoal verificada.
`data.result_status`	`string`	Não	`"identified"`	identified quando um gênero é retornado; caso contrário, unknown.
`data.reason`	`string`	Sim	`null`	null para resultados identified. Motivos de resultado desconhecido: not_found, no_name_candidate, ambiguous ou insufficient_evidence.
`data.confidence`	`number`	Sim	`0.95`	Valor de 0 a 1 ou null. Um gênero null tem confiança null.
`data.confidence_kind`	`string`	Sim	`"observed_frequency"`	observed_frequency: contagem dominante no conjunto de dados / total. model_reported: valor da IA, não uma probabilidade calibrada. null quando indisponível.
`data.sample_count`	`integer`	Sim	`1200`	Tamanho da amostra no conjunto de dados ou null. A IA não inventa uma contagem de amostras.
`data.source`	`string`	Não	`"dataset"`	dataset, ai ou none.
`data.country`	`string`	Sim	`"BR"`	Associação de país vinda do conjunto de dados (dataset) ou ai_association, ou null. Não indica nacionalidade, residência nem etnia.
`data.country_source`	`string`	Sim	`"dataset"`	Origem da associação ao país: dataset, ai_association ou null.
`data.match`	`object`	Não	`{"name":"joão","method":"normalized","scope":"country","country":"BR"}`	Nome correspondente no conjunto de dados, método (normalized, token, substring ou model_inference), escopo country/global e país da correspondência. Evidências indisponíveis são null.

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.

Contexto de país e nomes desconhecidos

Informe o país somente quando tiver um contexto relevante. A API pode selecionar uma linha do conjunto de dados específica do país ou recorrer a uma linha global. data.match.scope mostra qual foi selecionada; o país retornado não indica onde a pessoa mora.

Por padrão, requisições individuais usam o fallback de IA por 1 crédito no total. Para usar apenas o conjunto de dados, envie options: {"ai_mode": "off"}. Entradas sem resultado podem retornar gender: null e continuam sendo cobradas quando a operação é bem-sucedida. Um nome completo pode corresponder a uma de suas partes; data.match registra o candidato selecionado e o método de correspondência.

Para valores de nome que parecem apelidos, forceToGenderize: true permite uma inferência sem um nome real: um resultado encontrado no conjunto de dados custa 1 crédito; caso contrário, a IA com interpretação de apelidos custa 2 créditos no total. Um saldo inicial positivo é suficiente, e o saldo resultante pode ficar negativo.

Consultar um nome completo sem presumir que a primeira palavra é a que conta

Envie o nome original em Unicode. A correspondência com o conjunto de dados usa normalização NFKC, letras minúsculas e extração das partes do nome; você não precisa converter o nome para ASCII. Entre os candidatos disponíveis, a API escolhe a entrada do conjunto de dados com a maior contagem total armazenada. O candidato pode ser uma parte posterior do nome, então não presuma que a primeira palavra ou o primeiro nome foi escolhido.

Esta requisição usa apenas o conjunto de dados, o que facilita verificar as evidências selecionadas. Leia data.input.value para o nome completo enviado, data.match.name para o candidato consultado e data.match.method para o método de correspondência. O exemplo não promete um gênero específico nem uma determinada parte do nome selecionada. Os candidatos do conjunto de dados precisam ter mais de dois caracteres, e entradas curtas podem ficar sem resultado. Use o fallback de IA comum quando a previsão adicional for adequada à sua aplicação.