GenderAPI.io V2: nomi, indirizzi email e nomi utente in batch

Nomi, indirizzi email e nomi utente in batch

Parametro	Tipo	Obbligatorio	Valore predefinito	Descrizione
`items`	`array<object>`	Sì	`—`	Da 1 a 50 elementi di previsione; al massimo 10 con la prova IP. I risultati mantengono l'ordine di input.
`items[].type`	`string`	Sì	`—`	Categoria di input: name, email o username.
`items[].value`	`string`	Sì	`—`	Obbligatorio. 1–254 caratteri; non vuoto e senza caratteri di controllo. I valori email devono avere una sintassi email valida.
`items[].country`	`string`	No	`—`	Codice ISO 3166-1 alpha-2 facoltativo, in maiuscolo, ad esempio TR o US. Una ricerca specifica per paese può ricorrere al set di dati globale.
`items[].forceToGenderize`	`boolean`	No	`false`	Consulta prima il set di dati, poi l'IA con interpretazione dei nickname se non c'è un risultato. Supportato per name, email e username.
`items[].options`	`object`	No	`—`	Oggetto con le opzioni IA per ciascun input.
`items[].options.ai_mode`	`string`	No	`off`	Valori ammessi: off, fallback, always. Con forceToGenderize: true, ometti questo campo o usa fallback.
`items[].id`	`string`	No	`—`	Identificatore facoltativo di 1–64 caratteri nel JSON POST. Viene restituito accanto al rispettivo risultato del batch e deve essere univoco all'interno del batch. Accettato ma non restituito per le previsioni singole. Non supportato nelle query GET.

GenderAPI.io V2 accetta insieme nomi, indirizzi email e nomi utente su POST https://api.genderapi.io/api/v2/gender/batch. Invia un array items con 1–50 elementi se accedi con una chiave API, o al massimo 10 con la prova IP. Ogni elemento usa type e value e può avere valori propri per country, forceToGenderize e options. Gli ID sono facoltativi e devono essere univoci all'interno del batch.

I risultati mantengono l'ordine di input e contengono index, il tuo id facoltativo, charged_credits ed esattamente uno tra data ed error. Una risposta HTTP 200 può contenere errori di singoli elementi, quindi controlla ogni elemento. meta.summary riporta total, succeeded, identified, unknown e failed. Una previsione sconosciuta è un elemento riuscito e a pagamento.

Se la convalida o la pianificazione della richiesta non riesce, il batch viene rifiutato prima dell'addebito. Se tutti gli elementi eseguiti non riescono, l'API restituisce una risposta Problem con uno stato diverso da 2xx, un array data e l'alias legacy results. Gli elementi non riusciti non costano nulla dopo un rimborso confermato. Se l'addebito non è confermato, non considerare definitivi i costi dei singoli elementi.

Scegli un linguaggio di programmazione. Configura la tua chiave API, poi esegui l'esempio sul tuo server.

Ogni richiesta di previsione è una nuova operazione a pagamento, anche quando è un nuovo tentativo. Questi esempi non riprovano automaticamente. Controlla lo stato dell'addebito prima di inviare un'altra richiesta.

Prima dell'esecuzione: accesso e gestione degli errori

Esegui questi esempi sul tuo server. Imposta GENDERAPI_API_KEY nell'ambiente del processo con la tua chiave API esistente. Verifica che meta.access.mode sia api_key: una chiave non riconosciuta può portare alla prova IP.

Per le risposte JSON con HTTP 4xx e 5xx, il corpo dell'errore viene conservato e l'esempio termina con un codice di uscita diverso da zero. Controlla code, action e meta.usage.billing_status prima di riprovare. Per le risposte batch con HTTP 200, controlla anche data o error di ogni elemento.

Guida a errori e nuovi tentativi →

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": "Francesca",
      "country": "IT"
    },
    {
      "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+ in una shell POSIX. Esegui nel terminale. Documentazione del runtime

// 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": "Francesca",
      "country": "IT"
    },
    {
      "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 integrato. Salva come example.mjs ed esegui node example.mjs. Documentazione del runtime

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\":\"Francesca\",\"country\":\"IT\"},{\"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+; libreria standard. Salva come example.py ed esegui python3 example.py. Documentazione del runtime

<?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":"Francesca","country":"IT"},{"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+ con l'estensione cURL. Salva come example.php ed esegui php example.php. Documentazione del runtime

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\":\"Francesca\",\"country\":\"IT\"},{\"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+; client HTTP standard. Salva come GenderApiExample.java ed esegui java GenderApiExample.java. Documentazione del runtime

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

Applicazione console .NET 8+. Usalo come Program.cs in un progetto console, poi esegui dotnet run. Documentazione del runtime

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\":\"Francesca\",\"country\":\"IT\"},{\"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+; libreria standard. Salva come main.go ed esegui go run main.go. Documentazione del runtime

Leggere una risposta batch

Questo esempio combina due risultati reali acquisiti il 1° ottobre 2026, una corrispondenza nel set di dati e un risultato sconosciuto, con un errore del provider a scopo illustrativo. Mostra una risposta HTTP 200 con successo parziale, non l'output atteso della richiesta batch precedente. I due elementi riusciti costano 1 credito ciascuno; per l'elemento non riuscito è confermato un addebito pari a zero.

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

Campi dei risultati batch

Campo	Tipo	Può essere null	Esempio	Descrizione
`data`	`array<object>`	No	`[…]`	Risultati ordinati. Ogni elemento contiene una previsione o un errore; controlla tutti gli elementi.
`data[].index`	`integer`	No	`0`	Posizione nell'array items inviato, a partire da zero.
`data[].id`	`string`	No	`"contact-1"`	Il tuo identificatore dell'input, presente solo se fornito.
`data[].charged_credits`	`integer`	No	`1`	Addebito netto dell'elemento dopo i rimborsi confermati. Non considerarlo definitivo se l'addebito complessivo non è confermato.
`data[].data`	`object`	No	`{…}`	Presente per un elemento riuscito, inclusi i risultati sconosciuti. Usa i campi di previsione descritti nella guida alle risposte.
`data[].error`	`object`	No	`{…}`	Presente al posto di data per un elemento non riuscito. Usa i campi Problem Details descritti nella guida agli errori.

Campi del riepilogo batch

Campo	Tipo	Può essere null	Esempio	Descrizione
`meta.summary.total`	`integer`	No	`3`	Numero totale di elementi nel batch.
`meta.summary.succeeded`	`integer`	No	`2`	Elementi riusciti, incluse le previsioni sconosciute.
`meta.summary.identified`	`integer`	No	`1`	Elementi riusciti con un genere diverso da null.
`meta.summary.unknown`	`integer`	No	`1`	Elementi riusciti con gender null; questi risultati vengono addebitati.
`meta.summary.failed`	`integer`	No	`1`	Elementi non riusciti. total = succeeded + failed; succeeded = identified + unknown.

Metadati di accesso, addebito e richiesta

Campo	Tipo	Può essere null	Esempio	Descrizione
`meta.request_id`	`string`	No	`"550e8400-e29b-41d4-a716-446655440000"`	Identificatore univoco di questo tentativo HTTP; inviato anche in X-Request-ID.
`meta.duration_ms`	`integer`	No	`42`	Tempo di elaborazione della richiesta in millisecondi.
`meta.access.mode`	`string`	No	`"api_key"`	api_key, ip_trial o unauthenticated. Con un account a pagamento verifica che venga riportato api_key.
`meta.access.reason`	`string`	Sì	`null`	Motivo del passaggio alla prova IP: api_key_missing, api_key_invalid o api_key_not_found; altrimenti null.
`meta.usage.charged_credits`	`integer`	Sì	`1`	Crediti netti addebitati. Zero prima dell'addebito o dopo un rimborso completo confermato; null se l'addebito non è confermato.
`meta.usage.remaining_credits`	`integer`	Sì	`99`	Saldo al termine dell'operazione. Può essere negativo; null se non disponibile o se l'addebito non è confermato.
`meta.usage.billing_status`	`string`	No	`"confirmed"`	not_charged, confirmed o unconfirmed. Controllalo prima di ripetere una previsione non riuscita.
`meta.usage.resets_at`	`string`	Sì	`"2026-09-27T12:00:00.000Z"`	Momento del ripristino della prova IP in UTC (ISO 8601); null per gli account con chiave API o se sconosciuto.
`meta.usage.limit`	`integer`	Sì	`10`	Quota della prova IP; null per gli account con chiave API.
`meta.usage.period_seconds`	`integer`	Sì	`86400`	Durata del periodo della prova IP in secondi; null per gli account con chiave API.

Pianificare crediti e nuovi tentativi per i batch

Autenticati con la tua chiave API esistente nell'intestazione Bearer e invia Content-Type: application/json. Ogni batch inviato è una nuova operazione. Se riprovi dopo un errore parziale, invia solo gli elementi non riusciti dopo aver controllato l'addebito; gli elementi riusciti inviati di nuovo vengono addebitati un'altra volta.

Negli elementi di un batch l'IA è off per impostazione predefinita e ogni elemento riuscito costa 1 credito. Anche fallback esplicito costa 1 credito in totale, IA inclusa. always costa 2 crediti. forceToGenderize costa 1 credito per un risultato trovato nel set di dati o 2 se viene usata l'IA. I risultati sconosciuti riusciti vengono addebitati. Per avviare il batch basta un saldo iniziale positivo di 1 credito; l'addebito finale può lasciare un saldo negativo.

Elaborare un elenco di contatti senza perdere nessuna riga

L'endpoint batch gestisce elenchi di soli nomi, elenchi di soli indirizzi email e input misti. Con una chiave API suddividi il lavoro in batch di al massimo 50 elementi; la prova IP ne consente al massimo 10 per richiesta. Tieni traccia della tua posizione nel lavoro e assegna a ogni elemento un id univoco all'interno del batch. L'index restituito parte da zero all'interno del batch inviato, non dell'intero elenco di contatti.

Passaggio	Cosa salvare o controllare	Perché è importante
1. Prepara ogni batch	Conserva la riga di origine e l'id dell'elemento; imposta country e le opzioni IA per ciascun elemento.	Non dare per scontato che un nome sia univoco tra tutti i contatti.
2. Leggi l'intera risposta	Salva meta.request_id e abbina ogni elemento di data[] tramite id o index.	Una risposta HTTP 200 può contenere sia previsioni riuscite sia errori di singoli elementi.
3. Salva i risultati riusciti	Conserva le previsioni identificate e sconosciute, compresi i valori JSON null e i campi delle evidenze.	Un risultato sconosciuto è completato e addebitato; non è una riga non riuscita da reinviare automaticamente.
4. Riconcilia errori e crediti	Controlla ogni error e meta.usage.billing_status prima di decidere se inviare una nuova richiesta.	Dopo la conferma dell'addebito, riprova solo gli elementi non riusciti il cui errore lo giustifica. Gli elementi riusciti verrebbero addebitati di nuovo.
5. Rimanda i nuovi tentativi incerti	Salva l'ID della richiesta se l'addebito non è confermato o se un errore di rete rende l'esito sconosciuto.	Non reinviare alla cieca l'intero batch; segui prima le indicazioni su errori e addebiti.

Scegliere una modalità di previsione per ogni contatto

Questa richiesta eseguibile usa tre regole diverse: solo set di dati per un nome completo, normale fallback IA per un indirizzo email e fallback IA con interpretazione dei nickname per un nome utente. Sono input di esempio, non la promessa che tutti e tre i contatti ricevano un genere. Scegli un linguaggio di programmazione sopra il codice e imposta GENDERAPI_API_KEY prima di eseguire l'esempio.

Senza forceToGenderize, negli elementi di un batch l'IA è impostata su off per impostazione predefinita, a differenza delle ricerche singole. Indica fallback in modo esplicito se vuoi usare il normale fallback IA. Sia off sia il normale fallback costano 1 credito per elemento riuscito; always salta il set di dati e costa 2. forceToGenderize costa 1 per un risultato trovato nel set di dati o 2 in totale se viene usata l'IA. Anche i risultati sconosciuti riusciti vengono addebitati. Non combinare forceToGenderize con off o always.