# Bestem køn ud fra japanske navne

> Prøv japanske navne i GenderAPI.io V2. Læs om korte dele med kanji, mulige læsninger, landekonteksten JP, AI-fallback, og hvordan du håndterer ukendte resultater.

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

Last reviewed: 2026-09-29

## Skjul ikke usikkerheden om stavemåde og læsning

Send stavemåden fra posten i din applikation: med kanji, med kana eller med latinsk skrift. V2 accepterer Unicode, men garanterer ikke, at forskellige læsninger eller stavemåder fører til en ækvivalent nøgle i datasættet. Opslaget omsætter ikke kanji til en læsning og skiller ikke efternavnet fra fornavnet, hvis det fulde navn er skrevet uden mellemrum.

For de almindelige japanske tegn i eksemplerne springer det nuværende kandidatfilter dele med ét eller to tegn over. I demoværdien 葵 高橋 springes begge dele, der er adskilt af et mellemrum, over. Den almindelige fallback kan sende hele den oprindelige værdi til AI; en forespørgsel, der kun bruger datasættet, lader resultatet forblive ukendt med reason: no_name_candidate.

Hvis du fjerner mellemrummet, opstår der en anden kandidat og ikke en pålidelig løsning på opdelingsproblemet. Bevar det faktiske input, og kontrollér de returnerede data for source og match. En mulig læsning, en navnekonvention eller landekonteksten JP bekræfter ikke en persons kønsidentitet.

| Eksempel på input | Hvad det viser | Hvad du kontrollerer |
| --- | --- | --- |
| `葵 高橋` | Separate korte dele | Ingen af delene når den minimumslængde, filtret kræver for disse tegn. AI-fallback kan alligevel fortolke den oprindelige værdi. |
| `高橋葵` | Fuldt navn uden mellemrum | Én kandidat; opslaget afgør ikke, hvor efternavnet slutter. |
| `あおい` | Eksempel med kana på tre tegn | Kan blive en kandidat på grund af længden, men det betyder ikke, at der findes en post, eller at der returneres et køn. |
| `Aoi Takahashi` | Input med latinsk skrift | De enkelte dele kan indgå. Det fastlægger ikke én oprindelig stavemåde og garanterer ikke, at det tilsigtede fornavn vælges. |

## Vælg landekonteksten JP bevidst

Live-demoen sender country: JP (Japan). API'et vælger ikke dette land ud fra den skrift, navnet er skrevet med. Brug en kendt, relevant landekontekst i din integration, eller udelad country. Gør ikke denne eksempelværdi til en standard for alle poster.

For hver kandidat vælger opslaget den landespecifikke post, hvis den findes, og ellers den globale post. Derefter vælges den tilgængelige kandidat med det højeste lagrede samlede antal. Matchets faktiske omfang fremgår af data.match.scope og data.match.country. En landespecifik post med lige store frekvenser erstattes ikke automatisk af det globale resultat; hvis fallback er slået til, kan AI bruges i stedet.

data.input.country beskriver den landekontekst, der blev sendt i forespørgslen. data.country og data.country_source beskriver den returnerede tilknytning til et land og dens oprindelse. Det er forskellige felter, og de siger intet om nationalitet, etnisk oprindelse eller bopæl.

- [Landekontekst og match](https://www.genderapi.io/da/docs/v2/gender-from-name#country-evidence-workflow)

## Send en V2-forespørgsel med et navn fra din applikation

Angiv din eksisterende nøgle i GENDERAPI_API_KEY, og kør eksemplet på din server. Forespørgslen slår den almindelige automatiske AI-fallback eksplicit til. Den viser, hvordan forespørgslen er opbygget, ikke en målt nøjagtighed eller en bekræftet dækning. Angiv options.ai_mode: off, hvis du vil have en forudsigelse, der kun bruger datasættet.

Kør eksemplerne på din server. Sæt GENDERAPI_API_KEY i procesmiljøet til din eksisterende API-nøgle. Bekræft, at meta.access.mode er api_key: En nøgle, der ikke genkendes, kan føre til IP-prøveadgangen.

Hver forespørgsel om en forudsigelse er en ny operation, der koster kreditter, også når den gentages. Eksemplerne prøver ikke automatisk igen. Kontrollér opkrævningsstatus, før du sender en ny forespørgsel.

JSON-svar med HTTP 4xx og 5xx bevarer fejlens body og returnerer en exitstatus, der ikke er nul. Kontrollér code, action og meta.usage.billing_status, før du prøver igen.

**cURL**

cURL 7.76+ i en POSIX-shell. Kør i din terminal.

```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+, indbygget fetch. Gem som example.mjs, og kø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. Gem som example.py, og kø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-udvidelsen. Gem som example.php, og kø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-klienten. Gem som GenderApiExample.java, og kø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**

Konsolapplikation med .NET 8+. Brug som Program.cs i et konsolprojekt, og kør derefter 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. Gem som main.go, og kø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)
    }
}
```

- [Parametre for forespørgsler med navne](https://www.genderapi.io/da/docs/v2/gender-from-name)
- [Sådan angiver du API-nøglen](https://www.genderapi.io/da/docs/v2/authentication)

## Gem resultatet sammen med evidensen

En udledt sammenhæng er ikke det køn, en person selv har oplyst. Gem det oprindelige input, den returnerede evidens og det, personen selv har oplyst, hver for sig. Et ukendt resultat er et gyldigt resultat og bør ikke blive til en gættet kategori i din applikation.

| Felt | Sådan bruger du det |
| --- | --- |
| `data.gender / data.result_status` | Brug kun male eller female, når status er identified. Bevar den native JSON-værdi null, når resultatet er ukendt. |
| `data.name / data.match` | Kontrollér det returnerede navn og den valgte kandidat. Et match på en delstreng beviser ikke, at inputtet tilhører en person med det navn. |
| `data.confidence / data.confidence_kind` | Konfidensen ligger på en skala fra 0 til 1 eller er null. observed_frequency bygger på lagrede frekvenser, mens model_reported er en værdi angivet af AI. Vurdér tærskelværdier separat for hver type. |
| `data.source / data.sample_count` | Skeln mellem dataset, ai og none. AI-resultater har ingen lagret stikprøvestørrelse. En stikprøvestørrelse er ikke en målt nøjagtighed. |
| `meta.access.mode` | Kontrollér i en integration med konto, at api_key returneres. Manglende eller ukendte nøgler kan i stedet bruge den delte IP-prøveadgang. |
| `meta.usage` | Læs charged_credits og billing_status. Et gennemført ukendt resultat koster kreditter. Et mistet svar beviser ikke, at forespørgslen var gratis. |

- [Svarfelter og ukendte resultater](https://www.genderapi.io/da/docs/v2/responses)
- [Nøjagtighed og konfidens forklaret](https://www.genderapi.io/da/accuracy-methodology)
- [Datakilder og databasens daterede profil](https://www.genderapi.io/da/data-provenance)

## Beslut, hvornår AI skal bruges

forceToGenderize er valgfrit for navne, e-mailadresser og brugernavne. Når det er slået til, skal du udelade ai_mode eller bruge fallback. off og always kan ikke kombineres med denne indstilling og returnerer 422. En positiv startsaldo er nok til at starte en forespørgsel, også selvom den endelige opkrævning gør saldoen negativ.

Kaldenavnstilstanden kan returnere et køn sammen med name: null. Den kan også give et ukendt resultat. Hverken den almindelige automatiske AI-fallback eller fortolkningen af kaldenavne garanterer et korrekt svar eller en værdi, der ikke er null.

| Indstilling i forespørgslen | Adfærd | Kreditter for en gennemført forespørgsel |
| --- | --- | --- |
| options.ai_mode: off | Bruger kun datasættet. | 1, også for et ukendt resultat |
| options.ai_mode: fallback | Slår først op i datasættet og bruger derefter almindelig AI, hvis der ikke returneres et køn. Det er standarden for enkeltforespørgsler. | 1 i alt, inklusive automatisk AI-fallback |
| options.ai_mode: always | Bruger AI direkte. | 2 |
| forceToGenderize: true | Slår først op i datasættet og lader derefter AI fortolke et personligt kaldenavn eller alias, også uden et egentligt fornavn. | 1 for et resultat fra datasættet, 2 i alt, hvis AI bruges |

- [AI-indstillinger og fortolkning af kaldenavne](https://www.genderapi.io/da/docs/v2/ai-options)
- [Kreditter og forbrug](https://www.genderapi.io/da/docs/v2/credits-and-usage)

## Behandl en liste med navne uden at miste konteksten

Send op til 50 elementer med en API-nøgle eller 10 med IP-prøveadgangen via POST /api/v2/gender/batch. Giv hvert element et unikt id, og bevar den oprindelige værdi for hver række. Hvert element kan have sine egne indstillinger for land og AI; udelad landet, hvis det ikke er kendt.

I modsætning til enkeltforespørgsler, der som standard bruger fallback, bruger elementer i en batch som standard kun datasættet. Angiv options.ai_mode: fallback for hvert element, der har brug for AI. Kontrollér hvert resultat, også efter HTTP 200, gem ukendte resultater, og kontrollér fejl og opkrævning, før du sender igen. Hvert gennemført almindeligt element koster 1 kredit; én HTTP-forespørgsel med en batch svarer ikke til én kredit pr. forudsigelse.

- [Batcheksempler og delvise fejl](https://www.genderapi.io/da/docs/v2/batch#batch-application-workflow)
- [Håndter ukendte resultater i din applikation](https://www.genderapi.io/da/docs/v2/responses#application-decisions)

## Vid, hvad du sender

Live-demoen sender kun den indtastede værdi til GenderAPI.io, når du selv sender den. Hvis AI bruges, videregives type, value og den sendte landekontekst til den tjeneste, der er konfigureret til forudsigelser. Hvis du kun vil have en forudsigelse fra datasættet, skal du i din integration angive options.ai_mode: off uden forceToGenderize.

Privatlivspolitikken, databehandleraftalen og listen over underdatabehandlere beskriver de offentliggjorte vilkår for behandlingen. Et resultat er en udledt sammenhæng, og det, en person selv oplyser, har forrang. Brug det ikke som grundlag for beslutninger, der har betydelige konsekvenser for en person.

- [Privatlivspolitik](https://www.genderapi.io/da/privacy-policy)
- [Databehandleraftale](https://www.genderapi.io/da/data-processing-agreement)
- [Underdatabehandlere](https://www.genderapi.io/da/subprocessors)

## Hvorfor har eksemplet 葵 高橋 brug for AI-fallback?

Begge dele er for korte til det nuværende kandidatfilter. En forespørgsel, der kun bruger datasættet, returnerer derfor unknown med reason: no_name_candidate. Fallback kan sende hele den oprindelige værdi til AI, men et svar fra AI er ikke garanteret.

## Fastslår V2 den nøjagtige læsning af et japansk navn?

V2 tilbyder ikke en verificeret tjeneste til at fastslå læsninger. Opslaget omsætter ikke kanji til kana og garanterer ikke et ækvivalent resultat for en romaniseret stavemåde. Gem inputtet, og kontrollér den returnerede evidens, som resultatet bygger på.

## Er der offentliggjort en uafhængig evaluering af nøjagtigheden for denne gruppe navne?

Denne side offentliggør ikke en sådan evaluering. At input accepteres, at lagrede frekvenser vises, eller at der returneres en konfidensværdi, er ikke en uafhængig måling af nøjagtigheden. Metodebeskrivelsen forklarer, hvilke data der er tilgængelige, og hvilke målinger der endnu ikke er offentliggjort.

## Koster et resultat uden forudsigelse kreditter?

Et gennemført ukendt resultat opkræves. Den almindelige tilstand med datasættet eller med fallback koster 1 kredit i alt. Med forceToGenderize koster forespørgslen 1 kredit, hvis resultatet kommer fra datasættet, eller 2 i alt, hvis AI bruges, også ved et ukendt resultat. Fejl følger separate opkrævningsregler; kontrollér meta.usage.