# Finn kjønn fra kinesiske navn

> Prøv kinesiske navn i GenderAPI.io V2. Se hvordan korte navnedeler, oppdeling av fulle navn, de opprinnelige tegnene og landkonteksten CN påvirker resultater fra datasettet og KI.

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

Last reviewed: 2026-09-29

## Skill mellom Unicode-inndata og oppdeling av navnet

Du kan sende et kinesisk navn som Unicode-tekst uten å gjøre det om til latinske bokstaver. Oppslaget i datasettet søker i dag etter normaliserte navnedeler; det deler ikke automatisk et sammenhengende kinesisk fullt navn opp i etternavn og fornavn. 王静怡 er derfor én kandidat og ikke et garantert oppslag på 静怡.

For de vanlige kinesiske tegnene i disse eksemplene hopper det nåværende kandidatfilteret i datasettet over navnedeler med ett eller to tegn. Et kort fornavn kan være gyldige inndata og likevel ikke gi noen kandidat i datasettet. Vanlig KI-reserve kan fortsatt vurdere den opprinnelige verdien som ble sendt; modusen med bare datasettet beholder et ukjent resultat.

Unicode-normaliseringen NFKC gir ingen generell konvertering mellom forenklet og tradisjonell kinesisk og fører ikke en latinsk stavemåte tilbake til ett bestemt kinesisk navn. Behold skriften som ble sendt, og kontroller treffet som returneres. Ikke utled en persons kjønn eller land bare fra plasseringen av etternavnet, skriften eller romaniseringen.

| Eksempel på inndata | Hva det viser | Hva du bør kontrollere |
| --- | --- | --- |
| `王静怡` | Sammenhengende fullt navn | Én kandidat i datasettet. Den nåværende tolkningen skiller ikke ut etternavnet. |
| `静怡` | Fornavn med to tegn | Hoppes over av lengdefilteret for kandidater i datasettet; KI-reserve kan vurdere den opprinnelige verdien. |
| `王 静怡` | Korte navnedeler med mellomrom | Et mellomrom løser ikke problemet med lengdefilteret. Begge navnedelene i eksemplet er for korte for oppslag i datasettet. |
| `Wang Jingyi` | Inndata med latinske bokstaver | Behandles som egne inndata og deles opp i egne navnedeler. Det er ikke garantert at de føres tilbake til de opprinnelige tegnene eller den samme oppføringen. |

## Velg landkonteksten CN bevisst

Demoen i sanntid sender country: CN (Kina). 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 kinesisk 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": "CN",
  "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": "CN",
  "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\":\"CN\",\"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":"CN","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\":\"CN\",\"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\":\"CN\",\"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\":\"CN\",\"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 kan et kinesisk navn med to tegn bli ukjent når bare datasettet brukes?

Det nåværende kandidatfilteret i datasettet hopper over navnedeler med en lengde på høyst to som JavaScript-tegnstreng. For de kinesiske tegnene som vises her, er et navn med to tegn gyldige inndata, men det blir ikke en kandidat i datasettet. KI-reserve kan vurdere de opprinnelige inndataene.

## Skiller V2 automatisk et kinesisk etternavn fra fornavnet?

Oppslaget i datasettet deler ikke opp et sammenhengende kinesisk fullt navn. KI kan utlede et navn fra hele verdien, men ingen av dem garanterer at det tiltenkte fornavnet velges. Kontroller source og match i svaret.

## Er nøyaktigheten målt for hvert kinesisk 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.