# Finn kjønn fra arabiske navn

> Prøv navn med arabisk skrift i GenderAPI.io V2. Se hvordan diakritiske tegn, treff på fulle navn, landkontekst, KI-reserve og ukjente resultater fungerer før du integrerer.

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

Last reviewed: 2026-09-29

## Behold den arabiske stavemåten, og kontroller navnet som ble funnet

Send navnet med den opprinnelige stavemåten i Unicode. Inndatafeltet nedenfor bruker arabisk tekst fra høyre mot venstre, mens denne veiledningen og JSON-svaret leses fra venstre mot høyre. API-et kan ta imot teksten uten at du først omskriver den til latinske bokstaver; at teksten godtas, er ikke et løfte om dekning i datasettet.

Oppslaget i datasettet bruker Unicode-normaliseringen NFKC og deler teksten opp i navnedeler. Det har ingen generell regel som fjerner arabiske diakritiske tegn eller likestiller ulike stavemåter. Vokaltegn og andre forskjeller i stavemåten kan derfor påvirke hvilken lagret nøkkel som blir funnet. Behold den opprinnelige verdien i stedet for å behandle alle varianter som den samme personen.

Et fullt navn kan gi flere kandidater. Den tilgjengelige oppføringen med det høyeste lagrede totalantallet velges, så det første ordet er ikke nødvendigvis fornavnet som returneres. Kontroller data.name og data.match.name før du bruker et resultat til å berike en post.

| Eksempel på inndata | Hva det viser | Hva du bør kontrollere |
| --- | --- | --- |
| `ليلى الخطيب` | Eksempel på et fullt navn | Flere navnedeler kan vurderes. Kontroller den valgte kandidaten; eksemplet viser ikke et resultat fra en faktisk forespørsel. |
| `ليلى / لَيْلَى` | Stavemåte uten og med vokaltegn | Send den faktiske stavemåten. Det er ikke garantert at begge tegnstrengene gir den samme lagrede oppføringen. |
| `Layla / Leila` | Stavemåter med latinske bokstaver | Dette er separate inndataverdier. V2 lover ikke at translitterasjoner automatisk likestilles. |
| `country: SA` | Eksempelkontekst: Saudi-Arabia | Denne konteksten er ikke en standardverdi for alle arabisktalende samfunn. Utelat country når landet er ukjent. |

## Velg landkonteksten SA bevisst

Demoen i sanntid sender country: SA (Saudi-Arabia). 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 arabisk 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": "SA",
  "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": "SA",
  "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\":\"SA\",\"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":"SA","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\":\"SA\",\"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\":\"SA\",\"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\":\"SA\",\"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)

## Godtar V2 arabisk tekst med diakritiske tegn?

V2 godtar navn i Unicode, også arabisk tekst. Normaliseringen i datasettet fjerner vanligvis ikke arabiske vokaltegn, så stavemåter med og uten vokaltegn kan gi ulike treff eller et ukjent resultat.

## Fastslår verktøyet nasjonaliteten til en arabisktalende person?

Nei. SA er landkonteksten som er valgt eksplisitt for denne demonstrasjonen. Skriften, en tilknytning til navnet og et returnert landfelt sier ikke noe om nasjonalitet eller bosted.

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