GenderAPI.io V2: navn, e-postadresser og brukernavn i samleforespørsler

Navn, e-postadresser og brukernavn i samleforespørsler

Parameter	Type	Påkrevd	Standardverdi	Beskrivelse
`items`	`array<object>`	Ja	`—`	Mellom 1 og 50 elementer for prediksjon; høyst 10 i IP-prøveperioden. Resultatene følger rekkefølgen i inndataene.
`items[].type`	`string`	Ja	`—`	Inndatakategori: name, email eller username.
`items[].value`	`string`	Ja	`—`	Påkrevd. 1–254 tegn; ikke tom og uten kontrolltegn. E-postverdier må ha gyldig e-postsyntaks.
`items[].country`	`string`	Nei	`—`	Valgfri ISO 3166-1 alpha-2-kode med store bokstaver, for eksempel TR eller US. Et landspesifikt oppslag kan falle tilbake til det globale datasettet.
`items[].forceToGenderize`	`boolean`	Nei	`false`	Søk først i datasettet, deretter med KI som tolker kallenavn hvis det ikke finnes et resultat. Støttes for name, email og username.
`items[].options`	`object`	Nei	`—`	Objekt for KI-alternativer per inndata.
`items[].options.ai_mode`	`string`	Nei	`off`	Tillatte verdier: off, fallback, always. Med forceToGenderize: true utelater du feltet eller bruker fallback.
`items[].id`	`string`	Nei	`—`	Valgfri identifikator på 1–64 tegn i POST-JSON. Returneres sammen med hvert resultat i en samleforespørsel og må være unik innenfor samleforespørselen. Godtas, men returneres ikke for enkeltprediksjoner. Støttes ikke i GET-spørringer.

POST /gender/batch godtar en items-matrise med 1–50 elementer ved tilgang med API-nøkkel, eller høyst 10 i IP-prøveperioden. Du kan sende bare navn, bare e-postadresser, bare brukernavn eller en blanding av alle tre. Hvert element har egne verdier for country, forceToGenderize og options. ID-er er valgfrie og må være unike.

Resultatene følger rekkefølgen i inndataene og inneholder index, din valgfrie id, charged_credits og nøyaktig ett av data eller error. HTTP 200 kan inneholde feil for enkeltelementer, så kontroller hvert element. meta.summary rapporterer total, succeeded, identified, unknown og failed. En ukjent prediksjon er et vellykket element som belastes.

Hvis valideringen eller planleggingen av forespørselen mislykkes, avvises hele samleforespørselen før belastning. Hvis alle elementene som kjøres, mislykkes, returnerer API-et et Problem-svar som ikke er 2xx, med en data-matrise og det eldre aliaset results. Mislykkede elementer koster null etter en bekreftet refusjon. Hvis belastningen ikke er bekreftet, må du ikke anta at belastningen per element er endelig.

Velg et programmeringsspråk. Konfigurer API-nøkkelen, og kjør deretter eksemplet på serveren din.

Hver prediksjonsforespørsel er en ny operasjon som belastes, også nye forsøk. Disse eksemplene prøver ikke automatisk på nytt. Sjekk belastningsstatusen før du sender en ny forespørsel.

Før du kjører: tilgang og feilhåndtering

Kjør disse eksemplene på serveren din. Sett GENDERAPI_API_KEY i prosessmiljøet til din eksisterende API-nøkkel. Bekreft at meta.access.mode er api_key: en nøkkel som ikke gjenkjennes, kan føre til IP-prøveperioden.

Ved JSON-svar med HTTP 4xx og 5xx beholdes feilinnholdet, og eksemplet avsluttes med en exit-status som ikke er null. Sjekk code, action og meta.usage.billing_status før du prøver på nytt. Ved HTTP 200-svar på samleforespørsler må du også kontrollere data eller error for hvert element.

Veiledning om feil og nye forsøk →

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": "Sigrid",
      "country": "NO"
    },
    {
      "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+ i et POSIX-skall. Kjør i terminalen. Dokumentasjon for kjøretidsmiljøet

// 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": "Sigrid",
      "country": "NO"
    },
    {
      "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+; innebygd fetch. Lagre som example.mjs og kjør node example.mjs. Dokumentasjon for kjøretidsmiljøet

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\":\"Sigrid\",\"country\":\"NO\"},{\"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+; standardbiblioteket. Lagre som example.py og kjør python3 example.py. Dokumentasjon for kjøretidsmiljøet

<?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":"Sigrid","country":"NO"},{"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+ med cURL-utvidelsen. Lagre som example.php og kjør php example.php. Dokumentasjon for kjøretidsmiljøet

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\":\"Sigrid\",\"country\":\"NO\"},{\"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+; standard HTTP-klient. Lagre som GenderApiExample.java og kjør java GenderApiExample.java. Dokumentasjon for kjøretidsmiljøet

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

Konsollapplikasjon i .NET 8+. Bruk som Program.cs i et konsollprosjekt, og kjør deretter dotnet run. Dokumentasjon for kjøretidsmiljøet

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\":\"Sigrid\",\"country\":\"NO\"},{\"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+; standardbiblioteket. Lagre som main.go og kjør go run main.go. Dokumentasjon for kjøretidsmiljøet

Les svaret på en samleforespørsel

Dette eksemplet kombinerer to ekte resultater hentet 1. oktober 2026, et treff i datasettet og et ukjent resultat, med en illustrerende feil hos leverandøren. Det viser et delvis vellykket HTTP 200-svar, ikke det forventede resultatet av samleforespørselen ovenfor. De to vellykkede elementene koster 1 kreditt hver; det mislykkede elementet har en bekreftet belastning på null.

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

Felt i resultater for samleforespørsler

Felt	Type	Kan være null	Eksempel	Beskrivelse
`data`	`array<object>`	Nei	`[…]`	Ordnede resultater. Hvert element inneholder en prediksjon eller en feil; kontroller hvert element.
`data[].index`	`integer`	Nei	`0`	Posisjon i den innsendte items-matrisen, regnet fra null.
`data[].id`	`string`	Nei	`"contact-1"`	Din identifikator for inndataene; finnes bare når den er sendt med.
`data[].charged_credits`	`integer`	Nei	`1`	Netto belastning for elementet etter bekreftede refusjoner. Ikke regn den som endelig hvis den samlede belastningen ikke er bekreftet.
`data[].data`	`object`	Nei	`{…}`	Finnes for et vellykket element, også ved ukjente resultater. Bruker prediksjonsfeltene som er beskrevet i veiledningen om svar.
`data[].error`	`object`	Nei	`{…}`	Finnes for et mislykket element i stedet for data. Bruker feltene fra Problem Details som er beskrevet i veiledningen om feil.

Felt i sammendraget for samleforespørsler

Felt	Type	Kan være null	Eksempel	Beskrivelse
`meta.summary.total`	`integer`	Nei	`3`	Totalt antall elementer i samleforespørselen.
`meta.summary.succeeded`	`integer`	Nei	`2`	Vellykkede elementer, inkludert ukjente prediksjoner.
`meta.summary.identified`	`integer`	Nei	`1`	Vellykkede elementer med et kjønn som ikke er null.
`meta.summary.unknown`	`integer`	Nei	`1`	Vellykkede elementer med kjønn null; disse resultatene belastes.
`meta.summary.failed`	`integer`	Nei	`1`	Mislykkede elementer. total = succeeded + failed; succeeded = identified + unknown.

Metadata om tilgang, belastning og forespørsel

Felt	Type	Kan være null	Eksempel	Beskrivelse
`meta.request_id`	`string`	Nei	`"550e8400-e29b-41d4-a716-446655440000"`	Unik ID for dette HTTP-forsøket; sendes også i X-Request-ID.
`meta.duration_ms`	`integer`	Nei	`42`	Behandlingstid for forespørselen i millisekunder.
`meta.access.mode`	`string`	Nei	`"api_key"`	api_key, ip_trial eller unauthenticated. Kontroller at verdien er api_key når du bruker en betalt konto.
`meta.access.reason`	`string`	Ja	`null`	Årsak til at IP-prøveperioden ble brukt: api_key_missing, api_key_invalid eller api_key_not_found; ellers null.
`meta.usage.charged_credits`	`integer`	Ja	`1`	Netto belastede kreditter. 0 før belastning eller etter en bekreftet full refusjon; null når belastningen ikke er bekreftet.
`meta.usage.remaining_credits`	`integer`	Ja	`99`	Saldo når operasjonen er fullført. Kan være negativ; null når saldoen ikke er tilgjengelig eller belastningen ikke er bekreftet.
`meta.usage.billing_status`	`string`	Nei	`"confirmed"`	not_charged, confirmed eller unconfirmed. Sjekk dette før du prøver en mislykket prediksjon på nytt.
`meta.usage.resets_at`	`string`	Ja	`"2026-09-27T12:00:00.000Z"`	Tidspunkt for tilbakestilling av IP-prøveperioden i UTC (ISO 8601); null for kontoer med API-nøkkel eller når tidspunktet er ukjent.
`meta.usage.limit`	`integer`	Ja	`10`	Kvoten i IP-prøveperioden; null for kontoer med API-nøkkel.
`meta.usage.period_seconds`	`integer`	Ja	`86400`	Lengden på IP-prøveperioden i sekunder; null for kontoer med API-nøkkel.

Planlegg kreditter og nye forsøk for samleforespørsler

Autentiser med din eksisterende API-nøkkel med Bearer, og send Content-Type: application/json. Hver samleforespørsel som sendes, er en ny operasjon. Hvis du prøver en delvis mislykket samleforespørsel på nytt, sender du bare de mislykkede elementene etter at du har sjekket belastningen; elementer som allerede lyktes, belastes igjen hvis de sendes på nytt.

Elementer i en samleforespørsel bruker som standard off og koster 1 kreditt per vellykket element. Et eksplisitt fallback koster også 1 totalt, inkludert KI. Modusen always koster 2. forceToGenderize koster 1 for et resultat fra datasettet eller 2 hvis KI brukes. Vellykkede ukjente resultater belastes. Én positiv startkreditt er nok til å starte samleforespørselen; den endelige belastningen kan gi negativ saldo.

Behandle en kontaktliste uten å miste noen rader

Endepunktet for samleforespørsler håndterer lister med bare navn, lister med bare e-postadresser og blandede inndata. Med en API-nøkkel deler du arbeidet i samleforespørsler på høyst 50 elementer; IP-prøveperioden tillater høyst 10 per forespørsel. Hold oversikt over hvor du er i arbeidet, og gi hvert element en id som er unik innenfor samleforespørselen. index i svaret regnes fra null innenfor samleforespørselen som ble sendt, ikke innenfor hele kontaktlisten.

Steg	Hva du lagrer eller kontrollerer	Hvorfor det er viktig
1. Forbered hver samleforespørsel	Behold kilderaden og id-en til elementet; angi country og KI-alternativer for hvert element.	Ikke anta at et navn er unikt på tvers av alle kontaktene.
2. Les hele svaret	Lagre meta.request_id, og koble hvert element i data[] via id eller index.	Et HTTP 200-svar kan inneholde både vellykkede prediksjoner og feil for enkeltelementer.
3. Lagre vellykkede resultater	Behold identifiserte og ukjente prediksjoner, inkludert JSON null-verdier og feltene med grunnlag.	Et ukjent resultat er fullført og belastet; det er ikke en mislykket rad som skal sendes automatisk på nytt.
4. Stem av feil og kreditter	Sjekk hver error og meta.usage.billing_status før du avgjør om en ny forespørsel skal sendes.	Når belastningen er bekreftet, prøver du bare på nytt med mislykkede elementer der feilen tilsier det. Vellykkede elementer ville blitt belastet igjen.
5. Utsett usikre nye forsøk	Lagre forespørsels-ID-en hvis belastningen ikke er bekreftet, eller hvis en nettverksfeil gjør utfallet ukjent.	Ikke send hele samleforespørselen på nytt i blinde; følg først veiledningen om feil og belastning.

Velg en prediksjonsmodus for hver kontakt

Denne kjørbare forespørselen bruker tre ulike regler: bare datasettet for et fullt navn, vanlig KI-reserve for en e-postadresse og KI-reserve med tolkning av kallenavn for et brukernavn. Dette er eksempeldata, ikke et løfte om at alle tre kontaktene får et kjønn. Velg et programmeringsspråk over koden, og sett GENDERAPI_API_KEY før du kjører eksemplet.

Uten forceToGenderize er KI satt til off som standard for elementer i en samleforespørsel, i motsetning til enkeltoppslag. Angi fallback eksplisitt hvis du vil bruke vanlig KI-reserve. Både off og vanlig fallback koster 1 kreditt per vellykket element; always hopper over datasettet og koster 2. forceToGenderize koster 1 for et resultat fra datasettet eller 2 totalt hvis KI brukes. Også vellykkede ukjente resultater belastes. Ikke kombiner forceToGenderize med off eller always.