# Finn kjønn fra japanske navn

> Prøv japanske navn i GenderAPI.io V2. Se hvordan korte navnedeler med kanji, lesemåter, landkonteksten JP og KI-reserve fungerer, og hvordan du beholder ukjente resultater.

Canonical HTML: https://www.genderapi.io/nb/determine-gender-from-japanese-names

Last reviewed: 2026-09-29

## Hold usikkerheten om skrift og lesemåte synlig

Send stavemåten som finnes i posten din, for eksempel med kanji, kana eller latinske bokstaver. V2 godtar Unicode-inndata, men lover ikke at ulike lesemåter eller stavemåter gir en likeverdig nøkkel i datasettet. Oppslaget i datasettet gjør ikke kanji om til en lesemåte og deler ikke et sammenhengende fullt navn opp i etternavn og fornavn.

For de vanlige japanske tegnene som vises her, hopper det nåværende kandidatfilteret i datasettet over navnedeler med ett eller to tegn. I demoverdien 葵 高橋 hoppes begge navnedelene som er skilt med mellomrom, over. Vanlig KI-reserve kan spørre KI om hele den opprinnelige verdien; en forespørsel med bare datasettet beholder et ukjent resultat med reason: no_name_candidate.

Hvis du fjerner mellomrommet, får du en annen kandidat og ikke en pålitelig løsning på oppdelingen. Behold de faktiske inndataene, og kontroller source og match som returneres. En mulig lesemåte, en navnekonvensjon eller landkonteksten JP bekrefter ikke en persons kjønnsidentitet.

| Eksempel på inndata | Hva det viser | Hva du bør kontrollere |
| --- | --- | --- |
| `葵 高橋` | Korte navnedeler med mellomrom | Ingen av navnedelene når minstelengden som filteret krever for disse tegnene. KI-reserve kan likevel vurdere den opprinnelige verdien. |
| `高橋葵` | Eksempel på et sammenhengende fullt navn | Én kandidat; oppslaget i datasettet avgjør ikke hvor etternavnet slutter. |
| `あおい` | Eksempel med tre kana-tegn | Kan brukes som navnedel, men det betyr ikke at det finnes et lagret treff, og det viser ikke et resultat fra en faktisk forespørsel. |
| `Aoi Takahashi` | Inndata med latinske bokstaver | Hver navnedel kan vurderes. Det fastslår ikke én opprinnelig stavemåte og garanterer ikke at det tiltenkte fornavnet vinner. |

## Velg landkonteksten JP bevisst

Demoen i sanntid sender country: JP (Japan). API-et velger ikke dette landet ut fra skriften navnet er skrevet med. I integrasjonen din bruker du en kjent og relevant landkontekst, eller du utelater country; ikke gjør denne eksempelverdien til en standardverdi for alle poster.

For hver kandidat foretrekker oppslaget i datasettet en eksisterende landrad og vurderer ellers den globale raden. Deretter velges den tilgjengelige kandidaten med det høyeste lagrede totalantallet. Les data.match.scope og data.match.country for å se hvilket omfang treffet faktisk hadde. En landrad med likt antall for begge kjønn erstattes ikke automatisk av et globalt resultat; med fallback kan KI brukes i stedet.

data.input.country beskriver konteksten i forespørselen. data.country og data.country_source beskriver en tilknytning som returneres. Dette er ulike felt, og de fastslår ikke statsborgerskap, etnisitet eller bosted.

- [Landkontekst og treff i dokumentasjonen](https://www.genderapi.io/nb/docs/v2/gender-from-name#country-evidence-workflow)

## Send et japansk navn med V2

Kjør forespørselen på serveren din med GENDERAPI_API_KEY satt til den eksisterende nøkkelen din. Eksemplet aktiverer vanlig KI-reserve eksplisitt. Det viser hvordan en forespørsel ser ut, ikke en målt prediksjon eller en målt dekning. Bruk options.ai_mode: off hvis du bare vil bruke datasettet.

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.

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.

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.

**cURL**

cURL 7.76+ i et POSIX-skall. Kjør i terminalen.

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "type": "name",
  "value": "葵 高橋",
  "country": "JP",
  "options": {
    "ai_mode": "fallback"
  }
}'
```

**JavaScript / Node.js**

Node.js 22+; innebygd fetch. Lagre som example.mjs og kjør node example.mjs.

```javascript
// 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 = {
  "type": "name",
  "value": "葵 高橋",
  "country": "JP",
  "options": {
    "ai_mode": "fallback"
  }
};

const response = await fetch("https://api.genderapi.io/api/v2/gender", {
  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.
}
```

**Python**

Python 3.10+; standardbiblioteket. Lagre som example.py og kjør python3 example.py.

```python
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("{\"type\":\"name\",\"value\":\"葵 高橋\",\"country\":\"JP\",\"options\":{\"ai_mode\":\"fallback\"}}")

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",
    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.
```

**PHP**

PHP 8+ med cURL-utvidelsen. Lagre som example.php og kjør php example.php.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"type":"name","value":"葵 高橋","country":"JP","options":{"ai_mode":"fallback"}}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender');
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.
```

**Java**

Java 17+; standard HTTP-klient. Lagre som GenderApiExample.java og kjør java GenderApiExample.java.

```java
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 = "{\"type\":\"name\",\"value\":\"葵 高橋\",\"country\":\"JP\",\"options\":{\"ai_mode\":\"fallback\"}}";
        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"))
            .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.
    }
}
```

**C# / .NET**

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

```csharp
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");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"type\":\"name\",\"value\":\"葵 高橋\",\"country\":\"JP\",\"options\":{\"ai_mode\":\"fallback\"}}", 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.
}
```

**Go**

Go 1.22+; standardbiblioteket. Lagre som main.go og kjør go run main.go.

```go
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 := "{\"type\":\"name\",\"value\":\"葵 高橋\",\"country\":\"JP\",\"options\":{\"ai_mode\":\"fallback\"}}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender", 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)
    }
}
```

- [Parametere for forespørsler med navn](https://www.genderapi.io/nb/docs/v2/gender-from-name)
- [Konfigurer autentisering](https://www.genderapi.io/nb/docs/v2/authentication)

## Lagre resultatet sammen med grunnlaget

En utledet tilknytning er ikke det kjønnet en person selv har oppgitt. Lagre de opprinnelige inndataene, grunnlaget som ble returnert, og det personen selv har oppgitt, hver for seg. Et ukjent resultat er et gyldig resultat og bør ikke bli en gjettet kategori i applikasjonen din.

| Felt | Bruk |
| --- | --- |
| `data.gender / data.result_status` | Bruk male eller female bare sammen med identified. Ved et ukjent resultat beholder du den opprinnelige JSON-verdien null. |
| `data.name / data.match` | Kontroller det returnerte navnet og den valgte kandidaten. Et treff på en delstreng beviser ikke at inndataene tilhører en person med dette navnet. |
| `data.confidence / data.confidence_kind` | Konfidensen er en verdi fra 0 til 1 eller null. observed_frequency bygger på lagrede frekvenser; model_reported er en verdi fra KI. Evaluer tersklene separat for hver type. |
| `data.source / data.sample_count` | Skill mellom dataset, ai og none. KI-resultater har ingen lagret utvalgsstørrelse. En utvalgsstørrelse er ikke en målt nøyaktighet. |
| `meta.access.mode` | Kontroller at api_key rapporteres i en integrasjon med konto. Nøkler som mangler eller ikke gjenkjennes, kan i stedet bruke den delte IP-prøveperioden. |
| `meta.usage` | Les charged_credits og billing_status. Et vellykket ukjent resultat belastes. Et tapt svar beviser ikke at forespørselen var gratis. |

- [Svarfelt og ukjente resultater](https://www.genderapi.io/nb/docs/v2/responses)
- [Nøyaktighet og konfidens forklart](https://www.genderapi.io/nb/accuracy-methodology)
- [Datakilder og den daterte profilen til datasettet](https://www.genderapi.io/nb/data-provenance)

## Bestem når KI skal brukes

forceToGenderize er valgfritt for navn, e-postadresser og brukernavn. Når det er aktivert, utelater du ai_mode eller bruker fallback; off og always kan ikke kombineres med dette alternativet og gir 422. En positiv startsaldo er nok til å starte en forespørsel, selv om den endelige belastningen gjør saldoen negativ.

Kallenavnmodus kan returnere et kjønn sammen med name: null. Den kan også gi et ukjent resultat. Verken vanlig KI-reserve eller tolkning av kallenavn garanterer et riktig svar eller en verdi som ikke er null.

| Alternativ i forespørselen | Virkemåte | Kreditter for et vellykket oppslag |
| --- | --- | --- |
| options.ai_mode: off | Bruker bare datasettet. | 1, også for et ukjent resultat |
| options.ai_mode: fallback | Søker først i datasettet og bruker deretter vanlig KI hvis det ikke returneres et kjønn. Dette er standard for enkeltforespørsler. | 1 totalt, inkludert KI-reserve |
| options.ai_mode: always | Bruker KI direkte. | 2 |
| forceToGenderize: true | Søker først i datasettet og lar deretter KI tolke et personlig kallenavn eller alias, selv uten et ekte fornavn. | 1 for et resultat fra datasettet; 2 totalt hvis KI brukes |

- [KI-alternativer og tolkning av kallenavn](https://www.genderapi.io/nb/docs/v2/ai-options)
- [Kreditter og forbruk](https://www.genderapi.io/nb/docs/v2/credits-and-usage)

## Behandle en navneliste uten å miste konteksten

Bruk POST /api/v2/gender/batch for høyst 50 elementer med en registrert API-nøkkel eller 10 elementer i IP-prøveperioden. Gi hvert element en unik id, og behold den opprinnelige verdien for hver rad. Hvert element kan ha sitt eget land og sine egne KI-regler; utelat country når landet er ukjent.

I motsetning til enkeltforespørsler, der fallback er standard, bruker elementer i en samleforespørsel bare datasettet som standard. Angi options.ai_mode: fallback for hvert element som trenger KI. Kontroller hvert resultat, også etter HTTP 200, behold ukjente resultater, og gå gjennom feil for enkeltelementer og belastningen før du sender på nytt. Hvert vellykket vanlig element koster 1 kreditt; én HTTP-forespørsel med en samleforespørsel er ikke det samme som én kreditt for én prediksjon.

- [Eksempler på samleforespørsler og delvise feil](https://www.genderapi.io/nb/docs/v2/batch#batch-application-workflow)
- [Håndter ukjente resultater i applikasjonen](https://www.genderapi.io/nb/docs/v2/responses#application-decisions)

## Vit hva du sender

Demoen i sanntid sender verdien du skriver inn, til GenderAPI.io bare når du selv sender den. Hvis KI brukes, overføres type, value og landkonteksten som ble sendt, til tjenesten som er konfigurert for prediksjoner. For en prediksjon som bare bruker datasettet, angir du options.ai_mode: off uten forceToGenderize i integrasjonen din.

Personvernerklæringen, databehandleravtalen og listen over underdatabehandlere beskriver de publiserte vilkårene for behandlingen. Et resultat er en utledet tilknytning, og det en person selv oppgir, har forrang. Ikke bruk det som grunnlag for beslutninger som har store konsekvenser for en person.

- [Personvernerklæring](https://www.genderapi.io/nb/privacy-policy)
- [Databehandleravtale](https://www.genderapi.io/nb/data-processing-agreement)
- [Underdatabehandlere](https://www.genderapi.io/nb/subprocessors)

## Hvorfor trenger eksemplet 葵 高橋 KI-reserve?

Begge navnedelene er for korte for det nåværende kandidatfilteret i datasettet, så modusen med bare datasettet returnerer unknown med reason: no_name_candidate. KI-reserve kan forsøke hele den opprinnelige verdien, men et svar fra KI er ikke garantert.

## Fastslår V2 den nøyaktige lesemåten for et japansk navn?

V2 tilbyr ingen verifisert tjeneste for å fastslå lesemåter. Oppslaget i datasettet gjør ikke kanji om til kana og garanterer ikke likeverdige resultater for en romanisert stavemåte. Behold inndataene, og kontroller grunnlaget som returneres.

## Er nøyaktigheten målt for hvert japansk navn?

Denne siden publiserer ingen slik måling. At inndata godtas, lagrede antall og en konfidensverdi er ikke en uavhengig måling av nøyaktigheten. Se metodesiden for grunnlaget som finnes, og for målingene som ennå ikke er publisert.

## Belastes et ukjent resultat med kreditter?

Et vellykket ukjent resultat belastes. Vanlig modus med datasettet eller fallback koster 1 kreditt totalt. Med forceToGenderize koster et resultat fra datasettet 1 kreditt, og bruk av KI koster 2 totalt, også når KI gir et ukjent resultat. Feil har egne regler for belastning; kontroller meta.usage.