GenderAPI.io V2: Namn, e-postadresser och användarnamn i batch

Namn, e-postadresser och användarnamn i batch

Parameter	Typ	Obligatorisk	Standardvärde	Beskrivning
`items`	`array<object>`	Ja	`—`	1–50 prediktionsposter; högst 10 i IP-provperioden. Resultaten följer indataordningen.
`items[].type`	`string`	Ja	`—`	Indatakategori: name, email eller username.
`items[].value`	`string`	Ja	`—`	Krävs. 1–254 tecken, inte tomt och utan kontrolltecken. E-postvärden måste ha giltig e-postsyntax.
`items[].country`	`string`	Nej	`—`	Valfri ISO 3166-1 alpha-2-kod med versaler, till exempel TR eller US. En landsspecifik sökning kan falla tillbaka på den globala datamängden.
`items[].forceToGenderize`	`boolean`	Nej	`false`	Kontrollerar först datamängden och använder sedan AI med tolkning av smeknamn om inget resultat hittas. Stöds för name, email och username.
`items[].options`	`object`	Nej	`—`	Objekt med AI-alternativ för respektive indata.
`items[].options.ai_mode`	`string`	Nej	`off`	Tillåtna värden: off, fallback, always. Med forceToGenderize: true utelämnar du fältet eller använder fallback.
`items[].id`	`string`	Nej	`—`	Valfri identifierare med 1–64 tecken i POST-JSON. Returneras bredvid respektive batchresultat och måste vara unik inom en batch. Godtas men returneras inte för enskilda prediktioner. Stöds inte i GET-frågor.

GenderAPI.io V2 tar emot namn, e-postadresser och användarnamn tillsammans via POST https://api.genderapi.io/api/v2/gender/batch. Skicka en items-array med 1–50 poster vid åtkomst med API-nyckel, eller högst 10 i IP-provperioden. Varje post använder type och value och kan ha egna värden för country, forceToGenderize och options. ID:n är valfria och måste vara unika inom batchen.

Resultaten följer indataordningen och innehåller index, ditt valfria id, charged_credits och exakt ett av fälten data eller error. HTTP 200 kan innehålla fel för enskilda poster, så kontrollera varje post. meta.summary anger total, succeeded, identified, unknown och failed. En okänd prediktion är en lyckad post som debiteras.

Om valideringen eller planeringen av förfrågan misslyckas avvisas batchen före debitering. Om alla körda poster misslyckas returnerar API:et ett Problem-svar med en status utanför 2xx, en data-array och det äldre aliaset results. Misslyckade poster kostar ingenting efter en bekräftad återbetalning. Om debiteringen är obekräftad ska du inte utgå från att kostnaden för posterna är slutgiltig.

Välj ett programmeringsspråk. Konfigurera din API-nyckel, kör sedan exemplet på din server.

Varje prediktionsförfrågan är en ny debiterbar åtgärd, även vid nya försök. Exemplen gör inga automatiska nya försök. Kontrollera debiteringsstatus innan du skickar en ny förfrågan.

Innan du kör: åtkomst och felhantering

Kör exemplen på din server. Sätt GENDERAPI_API_KEY i processmiljön till din befintliga API-nyckel. Kontrollera att meta.access.mode är api_key: en nyckel som inte känns igen kan leda till IP-provperioden.

Vid JSON-svar med HTTP 4xx och 5xx behålls felinnehållet och exemplet avslutas med en slutstatus som inte är noll. Kontrollera code, action och meta.usage.billing_status innan du försöker igen. För batchsvar med HTTP 200 kontrollerar du dessutom data eller error i varje post.

Guide om fel och nya försö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": "Ingrid",
      "country": "SE"
    },
    {
      "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 ett POSIX-skal. Kör i terminalen. Dokumentation för körmiljön

// 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": "Ingrid",
      "country": "SE"
    },
    {
      "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+; inbyggd fetch. Spara som example.mjs och kör node example.mjs. Dokumentation för körmiljön

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\":\"Ingrid\",\"country\":\"SE\"},{\"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. Spara som example.py och kör python3 example.py. Dokumentation för körmiljön

<?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":"Ingrid","country":"SE"},{"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 tillägget cURL. Spara som example.php och kör php example.php. Dokumentation för körmiljön

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\":\"Ingrid\",\"country\":\"SE\"},{\"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+; inbyggd HTTP-klient. Spara som GenderApiExample.java och kör java GenderApiExample.java. Dokumentation för körmiljön

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

Konsolapplikation med .NET 8+. Använd som Program.cs i ett konsolprojekt och kör sedan dotnet run. Dokumentation för körmiljön

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\":\"Ingrid\",\"country\":\"SE\"},{\"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. Spara som main.go och kör go run main.go. Dokumentation för körmiljön

Tolka ett batchsvar

Det här exemplet kombinerar två verkliga resultat som hämtades den 1 oktober 2026, en träff i datamängden och ett okänt resultat, med ett illustrativt leverantörsfel. Det visar ett delvis lyckat svar med HTTP 200, inte det förväntade resultatet av batchförfrågan ovan. De två lyckade posterna kostar 1 kredit var; för den misslyckade posten är en debitering på noll bekräftad.

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

Fält i batchresultat

Fält	Typ	Kan vara null	Exempel	Beskrivning
`data`	`array<object>`	Nej	`[…]`	Ordnade resultat. Varje post innehåller en prediktion eller ett fel; kontrollera alla poster.
`data[].index`	`integer`	Nej	`0`	Position i den skickade items-arrayen, räknat från noll.
`data[].id`	`string`	Nej	`"contact-1"`	Din identifierare för indata; finns bara om den skickades med.
`data[].charged_credits`	`integer`	Nej	`1`	Postens nettodebitering efter bekräftade återbetalningar. Betrakta den inte som slutgiltig om den totala debiteringen är obekräftad.
`data[].data`	`object`	Nej	`{…}`	Finns för lyckade poster, även för okända resultat. Använder prediktionsfälten som beskrivs i guiden om svar.
`data[].error`	`object`	Nej	`{…}`	Finns för misslyckade poster i stället för data. Använder fälten i Problem Details som beskrivs i guiden om fel.

Fält i batchsammanfattningen

Fält	Typ	Kan vara null	Exempel	Beskrivning
`meta.summary.total`	`integer`	Nej	`3`	Totalt antal poster i batchen.
`meta.summary.succeeded`	`integer`	Nej	`2`	Lyckade poster, inklusive okända prediktioner.
`meta.summary.identified`	`integer`	Nej	`1`	Lyckade poster med ett kön som inte är null.
`meta.summary.unknown`	`integer`	Nej	`1`	Lyckade poster med gender null; dessa resultat debiteras.
`meta.summary.failed`	`integer`	Nej	`1`	Misslyckade poster. total = succeeded + failed; succeeded = identified + unknown.

Metadata om åtkomst, debitering och förfrågan

Fält	Typ	Kan vara null	Exempel	Beskrivning
`meta.request_id`	`string`	Nej	`"550e8400-e29b-41d4-a716-446655440000"`	Unik identifierare för det här HTTP-försöket; skickas även i X-Request-ID.
`meta.duration_ms`	`integer`	Nej	`42`	Bearbetningstid för förfrågan i millisekunder.
`meta.access.mode`	`string`	Nej	`"api_key"`	api_key, ip_trial eller unauthenticated. Kontrollera att api_key rapporteras när du använder ett betalt konto.
`meta.access.reason`	`string`	Ja	`null`	Orsak till att IP-provperioden användes: api_key_missing, api_key_invalid eller api_key_not_found; annars null.
`meta.usage.charged_credits`	`integer`	Ja	`1`	Debiterade krediter netto. 0 före debitering eller efter en bekräftad fullständig återbetalning; null när debiteringen är obekräftad.
`meta.usage.remaining_credits`	`integer`	Ja	`99`	Saldo när åtgärden slutförs. Kan vara negativt; null om saldot saknas eller debiteringen är obekräftad.
`meta.usage.billing_status`	`string`	Nej	`"confirmed"`	not_charged, confirmed eller unconfirmed. Kontrollera detta innan du gör ett nytt försök med en misslyckad prediktion.
`meta.usage.resets_at`	`string`	Ja	`"2026-09-27T12:00:00.000Z"`	Tidpunkt i UTC (ISO 8601) då IP-provperioden återställs; null för konton med API-nyckel eller om tidpunkten är okänd.
`meta.usage.limit`	`integer`	Ja	`10`	Kvot för IP-provperioden; null för konton med API-nyckel.
`meta.usage.period_seconds`	`integer`	Ja	`86400`	IP-provperiodens tidsfönster i sekunder; null för konton med API-nyckel.

Planera krediter och nya försök för batchar

Autentisera dig med din befintliga API-nyckel i Bearer-rubriken och skicka Content-Type: application/json. Varje skickad batch är en ny åtgärd. Om du gör ett nytt försök efter ett delvis fel skickar du bara de misslyckade posterna, efter att ha kontrollerat debiteringen; lyckade poster som skickas igen debiteras en gång till.

Poster i en batch har AI satt till off som standard och kostar 1 kredit per lyckad post. Ett uttryckligt fallback kostar också totalt 1, inklusive AI. always kostar 2. forceToGenderize kostar 1 för ett resultat som fastställs i datamängden eller 2 om AI används. Lyckade okända resultat debiteras. En enda kredit i positivt startsaldo räcker för att starta batchen; den slutliga debiteringen kan ge ett negativt saldo.

Bearbeta en kontaktlista utan att tappa bort någon rad

Batch-endpointen hanterar listor med bara namn, listor med bara e-postadresser och blandade indata. Dela upp ett jobb med API-nyckel i batchar om högst 50 poster; IP-provperioden tillåter högst 10 per förfrågan. Spara din egen position i jobbet och ge varje post ett id som är unikt inom batchen. Det returnerade index räknas från noll inom den skickade batchen, inte inom hela kontaktlistan.

Steg	Vad du sparar eller kontrollerar	Varför det spelar roll
1. Förbered varje batch	Behåll källraden och postens id; ange country och AI-alternativ per post.	Räkna inte med att ett namn är unikt bland alla kontakter.
2. Läs hela svaret	Spara meta.request_id och koppla varje post i data[] via id eller index.	HTTP 200 kan innehålla både lyckade prediktioner och fel för enskilda poster.
3. Spara lyckade resultat	Behåll identifierade och okända prediktioner, inklusive null-värden i JSON och fälten med underlag.	Ett okänt resultat är slutfört och debiteras; det är ingen misslyckad rad som ska skickas om automatiskt.
4. Stäm av fel och krediter	Kontrollera varje error och meta.usage.billing_status innan du bestämmer dig för en ny förfrågan.	När debiteringen är bekräftad gör du bara nya försök för misslyckade poster vars fel motiverar det. Lyckade poster skulle debiteras igen.
5. Skjut upp osäkra nya försök	Spara förfrågans ID när debiteringen är obekräftad eller ett nätverksfel gör utfallet okänt.	Skicka inte om hela batchen i blindo; följ först riktlinjerna om fel och debitering.

Välj ett prediktionsläge för varje kontakt

Den här körbara förfrågan använder tre olika regler: enbart datamängd för ett fullständigt namn, vanlig AI-reserv för en e-postadress och AI-reserv med tolkning av smeknamn för ett användarnamn. Det är exempel på indata, inget löfte om att alla tre kontakterna får ett kön. Välj ett programmeringsspråk ovanför koden och sätt GENDERAPI_API_KEY innan du kör exemplet.

Utan forceToGenderize har poster i en batch AI satt till off som standard, till skillnad från enskilda sökningar. Ange fallback uttryckligen om du vill använda vanlig AI-reserv. Både off och vanlig fallback kostar 1 kredit per lyckad post; always hoppar över datamängden och kostar 2. forceToGenderize kostar 1 för ett resultat som fastställs i datamängden eller totalt 2 om AI används. Även lyckade okända resultat debiteras. Kombinera inte forceToGenderize med off eller always.