GenderAPI.io V2: namen, e-mailadressen en gebruikersnamen in batches

Namen, e-mailadressen en gebruikersnamen in batches

Parameter	Type	Verplicht	Standaardwaarde	Beschrijving
`items`	`array<object>`	Ja	`—`	1 tot 50 items voor voorspellingen; maximaal 10 met de IP-proefperiode. De resultaten behouden de invoervolgorde.
`items[].type`	`string`	Ja	`—`	Invoercategorie: name, email of username.
`items[].value`	`string`	Ja	`—`	Verplicht. 1–254 tekens; niet leeg en zonder besturingstekens. E-mailwaarden moeten een geldige e-mailsyntaxis hebben.
`items[].country`	`string`	Nee	`—`	Optionele ISO 3166-1 alpha-2-code in hoofdletters, bijvoorbeeld TR of US. Een landspecifieke zoekopdracht kan terugvallen op de wereldwijde dataset.
`items[].forceToGenderize`	`boolean`	Nee	`false`	Raadpleegt eerst de dataset en daarna AI met bijnaaminterpretatie als er geen resultaat is. Ondersteund voor name, email en username.
`items[].options`	`object`	Nee	`—`	Object met de AI-opties per invoer.
`items[].options.ai_mode`	`string`	Nee	`off`	Toegestane waarden: off, fallback, always. Laat dit veld bij forceToGenderize: true weg of gebruik fallback.
`items[].id`	`string`	Nee	`—`	Optionele identificatie van 1–64 tekens in de POST-JSON. Wordt naast het bijbehorende batchresultaat teruggegeven en moet uniek zijn binnen de batch. Wordt bij losse voorspellingen geaccepteerd maar niet teruggegeven. Niet ondersteund in GET-query's.

GenderAPI.io V2 accepteert namen, e-mailadressen en gebruikersnamen samen via POST https://api.genderapi.io/api/v2/gender/batch. Verstuur een items-array met 1–50 items bij toegang met een API-sleutel, of maximaal 10 met de IP-proefperiode. Elk item gebruikt type en value en kan eigen waarden hebben voor country, forceToGenderize en options. Id's zijn optioneel en moeten uniek zijn binnen de batch.

De resultaten behouden de invoervolgorde en bevatten index, uw optionele id, charged_credits en precies één van data en error. Een antwoord met HTTP 200 kan fouten van afzonderlijke items bevatten, dus controleer elk item. meta.summary vermeldt total, succeeded, identified, unknown en failed. Een onbekende voorspelling is een geslaagd item dat credits kost.

Mislukt de validatie of planning van het verzoek, dan wordt de batch geweigerd voordat er iets wordt afgeschreven. Mislukken alle uitgevoerde items, dan geeft de API een Problem-antwoord met een status buiten 2xx, een data-array en de oudere alias results. Mislukte items kosten niets na een bevestigde terugboeking. Is de afschrijving niet bevestigd, beschouw de kosten per item dan niet als definitief.

Kies een programmeertaal. Stel uw API-sleutel in, voer daarna het voorbeeld uit op uw server.

Elk voorspellingsverzoek is een nieuwe betaalde bewerking, ook als het een nieuwe poging is. Deze voorbeelden proberen het niet automatisch opnieuw. Controleer de afschrijvingsstatus voordat u een nieuw verzoek verstuurt.

Voordat u het uitvoert: toegang en foutafhandeling

Voer deze voorbeelden uit op uw server. Stel in de procesomgeving GENDERAPI_API_KEY in op uw bestaande API-sleutel. Controleer of meta.access.mode api_key is: een niet-herkende sleutel kan terugvallen op de IP-proefperiode.

Bij JSON-antwoorden met HTTP 4xx en 5xx blijft de body van de fout behouden en eindigt het voorbeeld met een afsluitcode die niet nul is. Controleer code, action en meta.usage.billing_status voordat u het opnieuw probeert. Controleer bij batchantwoorden met HTTP 200 ook data of error van elk item.

Handleiding voor fouten en nieuwe pogingen →

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": "Sanne",
      "country": "NL"
    },
    {
      "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 een POSIX-shell. Voer uit in uw terminal. Documentatie van de 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": "Sanne",
      "country": "NL"
    },
    {
      "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+; ingebouwde fetch. Sla op als example.mjs en voer node example.mjs uit. Documentatie van de 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\":\"Sanne\",\"country\":\"NL\"},{\"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+; standaardbibliotheek. Sla op als example.py en voer python3 example.py uit. Documentatie van de 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":"Sanne","country":"NL"},{"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+ met de cURL-extensie. Sla op als example.php en voer php example.php uit. Documentatie van de 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\":\"Sanne\",\"country\":\"NL\"},{\"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+; standaard HTTP-client. Sla op als GenderApiExample.java en voer java GenderApiExample.java uit. Documentatie van de 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\":\"Sanne\",\"country\":\"NL\"},{\"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.
}

.NET 8+-consoleapplicatie. Gebruik als Program.cs in een consoleproject en voer daarna dotnet run uit. Documentatie van de 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\":\"Sanne\",\"country\":\"NL\"},{\"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+; standaardbibliotheek. Sla op als main.go en voer go run main.go uit. Documentatie van de runtime

Een batchantwoord lezen

Dit voorbeeld combineert twee echte resultaten die op 1 oktober 2026 zijn opgehaald, een match in de dataset en een onbekend resultaat, met een illustratieve fout bij de provider. Het toont een HTTP 200-antwoord dat gedeeltelijk is geslaagd, niet de verwachte uitvoer van het batchverzoek hierboven. De twee geslaagde items kosten elk 1 credit; voor het mislukte item is een afschrijving van nul bevestigd.

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

Velden van batchresultaten

Veld	Type	Kan null zijn	Voorbeeld	Beschrijving
`data`	`array<object>`	Nee	`[…]`	Geordende resultaten. Elk item bevat een voorspelling of een fout; controleer alle items.
`data[].index`	`integer`	Nee	`0`	Positie in de verstuurde items-array, beginnend bij nul.
`data[].id`	`string`	Nee	`"contact-1"`	Uw identificatie van de invoer; alleen aanwezig als u die hebt opgegeven.
`data[].charged_credits`	`integer`	Nee	`1`	Netto afschrijving voor het item na bevestigde terugboekingen. Beschouw die niet als definitief als de totale afschrijving niet is bevestigd.
`data[].data`	`object`	Nee	`{…}`	Aanwezig bij een geslaagd item, ook bij onbekende resultaten. Gebruikt de voorspellingsvelden die in de handleiding over antwoorden worden beschreven.
`data[].error`	`object`	Nee	`{…}`	Aanwezig in plaats van data bij een mislukt item. Gebruikt de velden van Problem Details die in de handleiding over fouten worden beschreven.

Velden van de batchsamenvatting

Veld	Type	Kan null zijn	Voorbeeld	Beschrijving
`meta.summary.total`	`integer`	Nee	`3`	Totaal aantal items in de batch.
`meta.summary.succeeded`	`integer`	Nee	`2`	Geslaagde items, inclusief onbekende voorspellingen.
`meta.summary.identified`	`integer`	Nee	`1`	Geslaagde items met een geslacht anders dan null.
`meta.summary.unknown`	`integer`	Nee	`1`	Geslaagde items met gender null; deze resultaten worden afgeschreven.
`meta.summary.failed`	`integer`	Nee	`1`	Mislukte items. total = succeeded + failed; succeeded = identified + unknown.

Metadata over toegang, afschrijving en verzoek

Veld	Type	Kan null zijn	Voorbeeld	Beschrijving
`meta.request_id`	`string`	Nee	`"550e8400-e29b-41d4-a716-446655440000"`	Unieke identificatie van deze HTTP-poging; wordt ook verstuurd in X-Request-ID.
`meta.duration_ms`	`integer`	Nee	`42`	Verwerkingstijd van het verzoek in milliseconden.
`meta.access.mode`	`string`	Nee	`"api_key"`	api_key, ip_trial of unauthenticated. Controleer bij een betaald account of api_key wordt vermeld.
`meta.access.reason`	`string`	Ja	`null`	Reden om naar de IP-proefperiode over te schakelen: api_key_missing, api_key_invalid of api_key_not_found; anders null.
`meta.usage.charged_credits`	`integer`	Ja	`1`	Netto afgeschreven credits. Nul vóór de afschrijving of na een bevestigde volledige terugboeking; null als de afschrijving niet is bevestigd.
`meta.usage.remaining_credits`	`integer`	Ja	`99`	Saldo bij voltooiing van de bewerking. Kan negatief zijn; null als het niet beschikbaar is of de afschrijving niet is bevestigd.
`meta.usage.billing_status`	`string`	Nee	`"confirmed"`	not_charged, confirmed of unconfirmed. Controleer dit voordat u een mislukte voorspelling herhaalt.
`meta.usage.resets_at`	`string`	Ja	`"2026-09-27T12:00:00.000Z"`	Tijdstip waarop de IP-proefperiode wordt hersteld, in UTC (ISO 8601); null voor accounts met een API-sleutel of als het onbekend is.
`meta.usage.limit`	`integer`	Ja	`10`	Tegoed van de IP-proefperiode; null voor accounts met een API-sleutel.
`meta.usage.period_seconds`	`integer`	Ja	`86400`	Duur van de periode van de IP-proefperiode in seconden; null voor accounts met een API-sleutel.

Credits en nieuwe pogingen voor batches plannen

Authenticeer met uw bestaande API-sleutel in de Bearer-header en stuur Content-Type: application/json. Elke verstuurde batch is een nieuwe bewerking. Probeert u het opnieuw na een gedeeltelijke fout, verstuur dan alleen de mislukte items nadat u de afschrijving hebt gecontroleerd; geslaagde items die u opnieuw verstuurt, worden nogmaals afgeschreven.

Voor items in een batch staat AI standaard op off en kost elk geslaagd item 1 credit. Ook fallback, expliciet ingesteld, kost in totaal 1 credit, inclusief AI. always kost 2 credits. forceToGenderize kost 1 credit voor een resultaat uit de dataset of 2 als AI wordt gebruikt. Geslaagde onbekende resultaten worden afgeschreven. Een positief beginsaldo van 1 credit is genoeg om de batch te starten; de uiteindelijke afschrijving kan een negatief saldo opleveren.

Een contactenlijst verwerken zonder rijen kwijt te raken

Het batch-endpoint verwerkt lijsten met alleen namen, lijsten met alleen e-mailadressen en gemengde invoer. Verdeel het werk met een API-sleutel in batches van maximaal 50 items; de IP-proefperiode staat maximaal 10 items per verzoek toe. Houd bij waar u in het werk bent en geef elk item een id die uniek is binnen de batch. De teruggegeven index begint bij nul binnen de verstuurde batch, niet binnen de hele contactenlijst.

Stap	Wat u opslaat of controleert	Waarom dat belangrijk is
1. Bereid elke batch voor	Bewaar de bronrij en de id van het item; stel country en de AI-opties per item in.	Ga er niet van uit dat een naam uniek is binnen al uw contacten.
2. Lees het volledige antwoord	Sla meta.request_id op en koppel elk item van data[] via id of index.	Een HTTP 200-antwoord kan zowel geslaagde voorspellingen als fouten van afzonderlijke items bevatten.
3. Sla geslaagde resultaten op	Bewaar geïdentificeerde en onbekende voorspellingen, inclusief JSON-waarden null en de bewijsvelden.	Een onbekend resultaat is voltooid en afgeschreven; het is geen mislukte rij die automatisch opnieuw moet worden verstuurd.
4. Stem fouten en credits af	Controleer elke error en meta.usage.billing_status voordat u besluit een nieuw verzoek te versturen.	Probeer na bevestiging van de afschrijving alleen de mislukte items opnieuw waarvoor de fout dat rechtvaardigt. Geslaagde items zouden nogmaals worden afgeschreven.
5. Stel onzekere nieuwe pogingen uit	Sla de verzoek-ID op als de afschrijving niet is bevestigd of als een netwerkfout de uitkomst onbekend maakt.	Verstuur niet blindelings de hele batch opnieuw; volg eerst de richtlijnen voor fouten en afschrijvingen.

Per contact een voorspellingsmodus kiezen

Dit uitvoerbare verzoek gebruikt drie verschillende regels: alleen de dataset voor een volledige naam, de normale AI-fallback voor een e-mailadres en AI-fallback met bijnaaminterpretatie voor een gebruikersnaam. Het zijn voorbeeldinvoerwaarden, geen belofte dat alle drie de contacten een geslacht krijgen. Kies boven de code een programmeertaal en stel GENDERAPI_API_KEY in voordat u het voorbeeld uitvoert.

Zonder forceToGenderize staat AI voor items in een batch standaard op off, anders dan bij losse zoekopdrachten. Geef fallback expliciet op als u de normale AI-fallback wilt gebruiken. Zowel off als de normale fallback kosten 1 credit per geslaagd item; always slaat de dataset over en kost 2. forceToGenderize kost 1 voor een resultaat uit de dataset of in totaal 2 als AI wordt gebruikt. Ook geslaagde onbekende resultaten worden afgeschreven. Combineer forceToGenderize niet met off of always.