GenderAPI.io V2 : lots de noms, d'adresses e-mail et de noms d'utilisateur

Lots de noms, d'adresses e-mail et de noms d'utilisateur

Paramètre	Type	Obligatoire	Valeur par défaut	Description
`items`	`array<object>`	Oui	`—`	Entre 1 et 50 éléments ; 10 maximum pour l'essai par IP. L'ordre d'entrée est conservé.
`items[].type`	`string`	Oui	`—`	Catégorie d'entrée : name, email ou username.
`items[].value`	`string`	Oui	`—`	Obligatoire. 1 à 254 caractères ; non vide et sans caractères de contrôle. Une valeur de type email doit respecter la syntaxe d'une adresse e-mail valide.
`items[].country`	`string`	Non	`—`	Code ISO 3166-1 alpha-2 facultatif, en majuscules, par exemple TR ou US. La recherche propre à un pays peut se rabattre sur le jeu de données global.
`items[].forceToGenderize`	`boolean`	Non	`false`	Consulte d'abord le jeu de données, puis l'IA adaptée aux surnoms si aucun résultat n'est trouvé. Compatible avec name, email et username.
`items[].options`	`object`	Non	`—`	Objet contenant les options d'IA propres à chaque entrée.
`items[].options.ai_mode`	`string`	Non	`off`	Valeurs autorisées : off, fallback, always. Avec forceToGenderize: true, omettez ce champ ou utilisez fallback.
`items[].id`	`string`	Non	`—`	Identifiant facultatif de 1 à 64 caractères dans le corps JSON POST. Renvoyé avec chaque résultat de lot et unique au sein d'un lot. Accepté mais non renvoyé pour les prédictions individuelles. Non pris en charge dans les requêtes GET.

GenderAPI.io V2 accepte des éléments de type nom, e-mail et nom d'utilisateur dans un même lot sur POST https://api.genderapi.io/api/v2/gender/batch. Envoyez un tableau items de 1 à 50 éléments avec une clé API, ou de 10 éléments au maximum avec l'essai par IP. Chaque élément utilise type et value et peut avoir ses propres country, forceToGenderize et options. Les id sont facultatifs et doivent être uniques au sein du lot.

Les résultats conservent l'ordre d'entrée et comprennent index, votre id facultatif, charged_credits et exactement un champ parmi data ou error. Une réponse HTTP 200 peut contenir des échecs par élément : examinez donc chaque élément. meta.summary indique total, succeeded, identified, unknown et failed. Une prédiction inconnue est un élément réussi et facturable.

Un échec de validation ou de planification de la requête rejette le lot avant tout débit. Si tous les éléments exécutés échouent, l'API renvoie une réponse Problem hors 2xx avec un tableau data et l'alias hérité results. Les éléments échoués ne coûtent rien après un remboursement confirmé. Si la facturation n'est pas confirmée, ne considérez pas les montants par élément comme définitifs.

Choisissez un langage de programmation. Configurez votre clé API, puis exécutez l'exemple sur votre serveur.

Chaque requête de prédiction est une nouvelle opération facturable, y compris les nouvelles tentatives. Ces exemples ne réessaient pas automatiquement. Vérifiez le statut de facturation avant d'envoyer une autre requête.

Avant l'exécution : accès et gestion des erreurs

Exécutez ces exemples sur votre serveur. Définissez GENDERAPI_API_KEY dans l'environnement du processus avec votre clé API existante. Vérifiez que meta.access.mode vaut api_key : une clé non reconnue peut basculer vers l'essai par IP.

Pour les réponses JSON HTTP 4xx et 5xx, les exemples conservent le corps de l'erreur et renvoient un code de sortie non nul. Vérifiez code, action et meta.usage.billing_status avant de réessayer. Pour une réponse de lot HTTP 200, examinez aussi data ou error dans chaque élément.

Guide des erreurs et des nouvelles tentatives →

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": "Juliette",
      "country": "FR"
    },
    {
      "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+ dans un shell POSIX. À exécuter dans votre terminal. Documentation de l'environnement d'exécution

// 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": "Juliette",
      "country": "FR"
    },
    {
      "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 intégré. Enregistrez sous example.mjs et exécutez node example.mjs. Documentation de l'environnement d'exécution

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\":\"Juliette\",\"country\":\"FR\"},{\"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+ ; bibliothèque standard. Enregistrez sous example.py et exécutez python3 example.py. Documentation de l'environnement d'exécution

<?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":"Juliette","country":"FR"},{"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+ avec l'extension cURL. Enregistrez sous example.php et exécutez php example.php. Documentation de l'environnement d'exécution

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\":\"Juliette\",\"country\":\"FR\"},{\"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. Enregistrez sous GenderApiExample.java et exécutez java GenderApiExample.java. Documentation de l'environnement d'exécution

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

Application console .NET 8+. Utilisez-le comme Program.cs dans un projet console, puis exécutez dotnet run. Documentation de l'environnement d'exécution

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\":\"Juliette\",\"country\":\"FR\"},{\"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+ ; bibliothèque standard. Enregistrez sous main.go et exécutez go run main.go. Documentation de l'environnement d'exécution

Lire une réponse de lot

Cet exemple combine deux résultats réels obtenus le 1er octobre 2026, une correspondance dans le jeu de données et un résultat inconnu, avec un échec du fournisseur donné à titre d'illustration. Il montre une réponse HTTP 200 en réussite partielle, et non le résultat attendu de la requête de lot ci-dessus. Les deux éléments réussis coûtent chacun 1 crédit ; l'élément échoué a un débit nul confirmé.

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

Champs des résultats par lot

Champ	Type	Peut valoir null	Exemple	Description
`data`	`array<object>`	Non	`[…]`	Résultats ordonnés. Chaque élément contient une prédiction ou une erreur ; vérifiez chaque élément.
`data[].index`	`integer`	Non	`0`	Position dans le tableau items envoyé, à partir de zéro.
`data[].id`	`string`	Non	`"contact-1"`	Votre identifiant d'entrée, présent uniquement s'il a été fourni.
`data[].charged_credits`	`integer`	Non	`1`	Débit net de l'élément après remboursements confirmés. Ne le considérez pas comme définitif si la facturation globale n'est pas confirmée.
`data[].data`	`object`	Non	`{…}`	Présent pour un élément réussi, y compris un résultat inconnu. Utilise les champs de prédiction du guide des réponses.
`data[].error`	`object`	Non	`{…}`	Présent pour un élément échoué à la place de data. Utilise les champs Problem Details du guide des erreurs.

Champs du résumé du lot

Champ	Type	Peut valoir null	Exemple	Description
`meta.summary.total`	`integer`	Non	`3`	Nombre total d'éléments du lot.
`meta.summary.succeeded`	`integer`	Non	`2`	Éléments réussis, y compris les prédictions inconnues.
`meta.summary.identified`	`integer`	Non	`1`	Éléments réussis dont le genre n'est pas null.
`meta.summary.unknown`	`integer`	Non	`1`	Éléments réussis dont le genre est null ; ces résultats sont facturés.
`meta.summary.failed`	`integer`	Non	`1`	Éléments échoués. total = succeeded + failed; succeeded = identified + unknown.

Accès, facturation et métadonnées de la requête

Champ	Type	Peut valoir null	Exemple	Description
`meta.request_id`	`string`	Non	`"550e8400-e29b-41d4-a716-446655440000"`	Identifiant unique de cette tentative HTTP ; également envoyé dans X-Request-ID.
`meta.duration_ms`	`integer`	Non	`42`	Durée de traitement de la requête en millisecondes.
`meta.access.mode`	`string`	Non	`"api_key"`	api_key, ip_trial ou unauthenticated. Vérifiez api_key lorsque vous utilisez un compte payant.
`meta.access.reason`	`string`	Oui	`null`	Motif du passage à l'essai : api_key_missing, api_key_invalid ou api_key_not_found ; null sinon.
`meta.usage.charged_credits`	`integer`	Oui	`1`	Crédits nets débités. Zéro avant débit ou après remboursement intégral confirmé ; null si la facturation n'est pas confirmée.
`meta.usage.remaining_credits`	`integer`	Oui	`99`	Solde à la fin de l'opération. Peut être négatif ; null si indisponible ou si la facturation n'est pas confirmée.
`meta.usage.billing_status`	`string`	Non	`"confirmed"`	not_charged, confirmed ou unconfirmed. Vérifiez ce champ avant de relancer une prédiction échouée.
`meta.usage.resets_at`	`string`	Oui	`"2026-09-27T12:00:00.000Z"`	Réinitialisation de l'essai par IP en UTC (ISO 8601) ; null pour les comptes avec clé API ou si inconnue.
`meta.usage.limit`	`integer`	Oui	`10`	Crédits de l'essai par IP ; null pour les comptes avec clé API.
`meta.usage.period_seconds`	`integer`	Oui	`86400`	Durée de l'essai par IP en secondes ; null pour les comptes avec clé API.

Planifier les crédits et les nouvelles tentatives d'un lot

Authentifiez-vous avec votre clé API existante via l'en-tête Bearer et envoyez Content-Type: application/json. Chaque lot soumis est une nouvelle opération. Pour relancer un lot partiellement échoué, vérifiez la facturation puis ne soumettez que les éléments échoués ; renvoyer des éléments réussis les facture de nouveau.

Par défaut, les éléments d'un lot utilisent off et coûtent 1 crédit par élément réussi. Un fallback explicite coûte également 1 crédit au total, IA comprise. always coûte 2 crédits. forceToGenderize coûte 1 crédit pour un résultat résolu par le jeu de données, ou 2 si l'IA est utilisée. Les résultats inconnus réussis sont facturés. Un seul crédit positif au départ suffit pour lancer le lot ; le débit final peut rendre le solde négatif.

Traiter une liste de contacts sans perdre la trace d'aucune ligne

Le point de terminaison de lots accepte des listes de noms, des listes d'adresses e-mail ou des entrées mixtes. Découpez un traitement avec clé API en lots de 50 éléments au maximum ; l'essai par IP autorise au plus 10 éléments par requête. Conservez votre propre position dans la liste et attribuez à chaque élément un id unique au sein de son lot. L'index renvoyé commence à zéro et correspond au lot envoyé, et non à la liste complète.

Étape	À enregistrer ou à vérifier	Pourquoi c'est important
1. Préparer chaque lot	Conservez la ligne d'origine et l'id de l'élément ; définissez country et les options d'IA pour chaque élément.	Un même nom peut correspondre à plusieurs contacts.
2. Lire toute la réponse	Enregistrez meta.request_id et rapprochez chaque entrée de data[] grâce à id ou index.	Une réponse HTTP 200 peut contenir à la fois des prédictions réussies et des erreurs par élément.
3. Enregistrer les résultats réussis	Conservez les prédictions identified et unknown, y compris les valeurs JSON null et les champs d'indices.	unknown est un résultat terminé et facturé ; ce n'est pas une ligne échouée à relancer automatiquement.
4. Rapprocher erreurs et crédits	Examinez chaque error et meta.usage.billing_status avant de décider d'envoyer une autre requête.	Lorsque la facturation est confirmée, ne relancez que les éléments échoués dont l'erreur justifie une nouvelle tentative. Les éléments réussis seraient facturés de nouveau.
5. Suspendre les relances incertaines	Conservez l'identifiant de requête lorsque la facturation est unconfirmed ou qu'une panne réseau laisse l'issue incertaine.	Ne renvoyez pas aveuglément tout le lot ; suivez d'abord les consignes sur les erreurs et la facturation.

Choisir un mode d'inférence pour chaque contact

Cette requête exécutable applique trois règles différentes : jeu de données seul pour un nom complet, repli ordinaire sur l'IA pour une adresse e-mail et repli adapté aux surnoms pour un nom d'utilisateur. Il s'agit d'un exemple d'entrée, et non d'une promesse que les trois contacts recevront un genre. Choisissez un langage au-dessus du code et définissez GENDERAPI_API_KEY avant de l'exécuter.

Sans forceToGenderize, les éléments d'un lot utilisent off par défaut, contrairement aux recherches individuelles. Définissez explicitement fallback pour activer le repli ordinaire sur l'IA. off et le repli ordinaire coûtent tous deux 1 crédit par élément réussi ; always ignore le jeu de données et coûte 2 crédits. forceToGenderize coûte 1 crédit pour un résultat résolu par le jeu de données, ou 2 au total si l'IA est utilisée. Les résultats inconnus réussis sont également facturés. Ne combinez pas forceToGenderize avec off ou always.