# चीनी नामों से लिंग का अनुमान लगाएँ

> GenderAPI.io V2 के साथ चीनी नाम आज़माएँ। जानें कि छोटे टोकन, पूरे नाम का विभाजन, मूल अक्षर और CN देश का संदर्भ डेटासेट और AI के परिणामों पर कैसे असर डालते हैं।

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

Last reviewed: 2026-09-29

## Unicode इनपुट और पूरे नाम के विभाजन में अंतर समझें

आप चीनी नाम को Unicode टेक्स्ट के रूप में भेज सकते हैं; उसे पहले लैटिन अक्षरों में बदलना ज़रूरी नहीं है। मौजूदा डेटासेट खोज सिर्फ़ नॉर्मलाइज़ किए गए टोकन देखती है। बिना स्पेस वाला चीनी पूरा नाम अपने-आप सरनेम और दिए गए नाम में नहीं बँटता। इसलिए 王静怡 एक ही कैंडिडेट है; इसकी गारंटी नहीं है कि 静怡 खोजा जाएगा।

इन उदाहरणों के आम चीनी अक्षरों के लिए मौजूदा डेटासेट कैंडिडेट फ़िल्टर एक या दो अक्षरों वाले टोकन छोड़ देता है। छोटा दिया गया नाम मान्य इनपुट हो सकता है, फिर भी उससे कोई डेटासेट कैंडिडेट नहीं बनता। सामान्य AI फ़ॉलबैक फिर भी मूल भेजे गए मान पर विचार कर सकता है; सिर्फ़ डेटासेट वाला अनुरोध अज्ञात परिणाम बनाए रखता है।

Unicode NFKC नॉर्मलाइज़ेशन सरलीकृत और पारंपरिक चीनी के बीच कोई सामान्य रूपांतरण नहीं करता और लैटिन वर्तनी को किसी एक मूल चीनी नाम में वापस नहीं बदलता। भेजी गई लिपि वैसी ही रखें और लौटाया गया मिलान जाँचें। सिर्फ़ सरनेम की जगह, लिपि या रोमन वर्तनी के आधार पर किसी व्यक्ति के लिंग या देश का अंदाज़ा न लगाएँ।

| इनपुट का उदाहरण | यह क्या दर्शाता है | क्या जाँचें |
| --- | --- | --- |
| `王静怡` | बिना स्पेस वाला पूरा नाम | डेटासेट में एक ही कैंडिडेट। मौजूदा पार्सर सरनेम को अलग नहीं करता। |
| `静怡` | दो अक्षरों वाला दिया गया नाम | कैंडिडेट की लंबाई वाले फ़िल्टर की वजह से छोड़ दिया जाता है; AI फ़ॉलबैक मूल मान पर विचार कर सकता है। |
| `王 静怡` | स्पेस से अलग किए गए छोटे टोकन | स्पेस जोड़ने से लंबाई की सीमा नहीं हटती। उदाहरण के दोनों टोकन डेटासेट खोज के लिए बहुत छोटे हैं। |
| `Wang Jingyi` | लैटिन लिपि वाला इनपुट | इसे अलग मान माना जाता है और इसके अपने टोकन बनते हैं। इसकी गारंटी नहीं है कि यह मूल अक्षरों या उसी रिकॉर्ड से मिलेगा। |

## देश का संदर्भ CN सोच-समझकर चुनें

लाइव डेमो country: CN (चीन) भेजता है। API नाम की लिपि के आधार पर यह देश नहीं चुनता। अपने इंटीग्रेशन में देश का ज्ञात और प्रासंगिक संदर्भ इस्तेमाल करें या country छोड़ दें। इस उदाहरण वाले मान को हर रिकॉर्ड का डिफ़ॉल्ट न बनाएँ।

हर कैंडिडेट के लिए डेटासेट खोज देश-विशेष रिकॉर्ड मौजूद होने पर उसे चुनती है, वरना ग्लोबल रिकॉर्ड पर विचार करती है। इसके बाद सबसे ज़्यादा संग्रहीत कुल गिनती वाला उपलब्ध कैंडिडेट चुना जाता है। मिलान का असल दायरा data.match.scope और data.match.country में देखें। बराबर गिनती वाला देश-विशेष रिकॉर्ड अपने-आप ग्लोबल परिणाम से नहीं बदला जाता; फ़ॉलबैक चालू होने पर AI इस्तेमाल हो सकता है।

data.input.country अनुरोध में भेजा गया देश का संदर्भ बताता है। data.country और data.country_source लौटाया गया देश संबंध और उसका स्रोत बताते हैं। ये अलग-अलग फ़ील्ड हैं और इनसे नागरिकता, जातीयता या निवास साबित नहीं होता।

- [देश का संदर्भ और मिलान](https://www.genderapi.io/hi/docs/v2/gender-from-name#country-evidence-workflow)

## अपने ऐप्लिकेशन के नाम के साथ V2 अनुरोध भेजें

अपनी मौजूदा API कुंजी GENDERAPI_API_KEY में सेट करें और उदाहरण अपने सर्वर पर चलाएँ। यह अनुरोध सामान्य स्वचालित AI फ़ॉलबैक को साफ़ तौर पर चालू करता है। यह दिखाता है कि अनुरोध कैसे बनता है; यह मापी गई सटीकता या पक्का कवरेज नहीं दिखाता। सिर्फ़ डेटासेट वाले अनुमान के लिए options.ai_mode: off सेट करें।

ये उदाहरण अपने सर्वर पर चलाएँ। प्रोसेस एनवायरनमेंट में GENDERAPI_API_KEY को अपनी मौजूदा API कुंजी पर सेट करें। पक्का करें कि meta.access.mode का मान api_key है: पहचानी न गई कुंजी IP ट्रायल पर जा सकती है।

अनुमान का हर अनुरोध, दोबारा प्रयास सहित, शुल्क वाली नई प्रक्रिया है। ये उदाहरण अपने-आप दोबारा प्रयास नहीं करते। दूसरा अनुरोध भेजने से पहले बिलिंग स्टेटस देखें।

HTTP 4xx और 5xx वाले JSON रिस्पॉन्स में त्रुटि की बॉडी बनी रहती है और प्रोग्राम शून्य से अलग एग्ज़िट स्टेटस लौटाता है। दोबारा प्रयास से पहले code, action और meta.usage.billing_status देखें।

**cURL**

POSIX शेल में cURL 7.76+। अपने टर्मिनल में चलाएँ।

```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+; बिल्ट-इन fetch। example.mjs के रूप में सेव करें और 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+; स्टैंडर्ड लाइब्रेरी। example.py के रूप में सेव करें और 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**

cURL एक्सटेंशन के साथ PHP 8+। example.php के रूप में सेव करें और 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+; स्टैंडर्ड HTTP क्लाइंट। GenderApiExample.java के रूप में सेव करें और 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**

.NET 8+ कंसोल ऐप्लिकेशन। कंसोल प्रोजेक्ट में Program.cs के रूप में इस्तेमाल करें, फिर 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+; स्टैंडर्ड लाइब्रेरी। main.go के रूप में सेव करें और 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)
    }
}
```

- [नाम वाले अनुरोध के पैरामीटर](https://www.genderapi.io/hi/docs/v2/gender-from-name)
- [API कुंजी कैसे दें](https://www.genderapi.io/hi/docs/v2/authentication)

## परिणाम और उसके साक्ष्य को साथ रखें

अनुमानित संबंध किसी व्यक्ति का खुद बताया गया लिंग नहीं है। मूल इनपुट, लौटाए गए साक्ष्य और व्यक्ति की दी हुई जानकारी को अलग-अलग रखें। अज्ञात परिणाम एक मान्य परिणाम है; इसे आपके ऐप्लिकेशन में अंदाज़े से चुनी गई श्रेणी नहीं बनना चाहिए।

| फ़ील्ड | इसे कैसे इस्तेमाल करें |
| --- | --- |
| `data.gender / data.result_status` | male या female सिर्फ़ identified होने पर इस्तेमाल करें। परिणाम अज्ञात हो, तो JSON का असली null मान वैसे ही रखें। |
| `data.name / data.match` | लौटाया गया नाम और चुना गया कैंडिडेट जाँचें। सबस्ट्रिंग मिलान से यह साबित नहीं होता कि इनपुट उसी पहले नाम वाले व्यक्ति का है। |
| `data.confidence / data.confidence_kind` | कॉन्फिडेंस स्कोर 0–1 के पैमाने पर या null होता है। observed_frequency संग्रहीत गिनतियों से आता है; model_reported AI का स्कोर है। हर प्रकार के लिए सीमा का अलग आकलन करें। |
| `data.source / data.sample_count` | dataset, ai और none में अंतर करें। AI परिणामों में संग्रहीत सैंपल गिनती नहीं होती। सैंपल गिनती मापी गई सटीकता नहीं है। |
| `meta.access.mode` | अकाउंट वाले इंटीग्रेशन में पक्का करें कि मान api_key है। कुंजी न होने या पहचानी न जाने पर साझा IP ट्रायल इस्तेमाल हो सकता है। |
| `meta.usage` | charged_credits और billing_status पढ़ें। सफल अज्ञात परिणाम पर शुल्क लगता है। रिस्पॉन्स खो जाने से यह साबित नहीं होता कि अनुरोध मुफ़्त था। |

- [रिस्पॉन्स फ़ील्ड और अज्ञात परिणाम](https://www.genderapi.io/hi/docs/v2/responses)
- [सटीकता और कॉन्फिडेंस स्कोर की व्याख्या](https://www.genderapi.io/hi/accuracy-methodology)
- [डेटा स्रोत और तारीख वाली डेटाबेस प्रोफ़ाइल](https://www.genderapi.io/hi/data-provenance)

## तय करें कि AI कब इस्तेमाल करना है

नामों, ईमेल पतों और यूज़रनेम के लिए forceToGenderize वैकल्पिक है। इसे चालू करने पर ai_mode छोड़ दें या fallback इस्तेमाल करें; off और always का इससे टकराव होता है और 422 लौटता है। अनुरोध शुरू करने के लिए पॉज़िटिव शुरुआती बैलेंस काफ़ी है, भले ही अंतिम शुल्क के बाद बैलेंस शून्य से नीचे चला जाए।

निकनेम मोड name: null के साथ लिंग लौटा सकता है। यह अज्ञात परिणाम भी लौटा सकता है। न सामान्य AI फ़ॉलबैक और न ही निकनेम का अनुमान सही या non-null जवाब की गारंटी देता है।

| अनुरोध का विकल्प | व्यवहार | हर सफल अनुरोध पर क्रेडिट |
| --- | --- | --- |
| options.ai_mode: off | सिर्फ़ डेटासेट इस्तेमाल करें। | 1, अज्ञात परिणाम पर भी |
| options.ai_mode: fallback | पहले डेटासेट, फिर लिंग न मिलने पर सामान्य AI। एकल अनुरोध का डिफ़ॉल्ट यही है। | कुल 1, AI फ़ॉलबैक सहित |
| options.ai_mode: always | सीधे AI से पूछें। | 2 |
| forceToGenderize: true | पहले डेटासेट, फिर AI को निजी निकनेम या छद्मनाम समझने की अनुमति, असली पहले नाम के बिना भी। | डेटासेट से परिणाम मिलने पर 1; AI इस्तेमाल होने पर कुल 2 |

- [AI विकल्प और निकनेम का अनुमान](https://www.genderapi.io/hi/docs/v2/ai-options)
- [क्रेडिट और उपयोग](https://www.genderapi.io/hi/docs/v2/credits-and-usage)

## नामों की सूची प्रोसेस करते समय संदर्भ सुरक्षित रखें

आइटम POST /api/v2/gender/batch से भेजें: API कुंजी के साथ ज़्यादा से ज़्यादा 50 और IP ट्रायल में ज़्यादा से ज़्यादा 10। हर आइटम को एक यूनिक id दें और हर पंक्ति का मूल मान सुरक्षित रखें। हर आइटम का अपना देश और AI विकल्प हो सकता है; देश पता न हो, तो उसे छोड़ दें।

एकल अनुरोध में डिफ़ॉल्ट रूप से फ़ॉलबैक होता है, जबकि बैच के आइटम डिफ़ॉल्ट रूप से सिर्फ़ डेटासेट इस्तेमाल करते हैं। जिन आइटम के लिए AI चाहिए, उन पर अलग से options.ai_mode: fallback सेट करें। HTTP 200 मिलने पर भी हर परिणाम जाँचें, अज्ञात परिणाम सुरक्षित रखें और दोबारा भेजने से पहले त्रुटियाँ और बिलिंग देखें। हर सफल सामान्य आइटम पर 1 क्रेडिट लगता है; बैच वाला एक HTTP अनुरोध हर अनुमान के लिए एक ही क्रेडिट के बराबर नहीं है।

- [बैच के उदाहरण और आंशिक विफलताएँ](https://www.genderapi.io/hi/docs/v2/batch#batch-application-workflow)
- [अपने ऐप्लिकेशन में अज्ञात परिणाम संभालें](https://www.genderapi.io/hi/docs/v2/responses#application-decisions)

## समझें कि आप क्या भेजते हैं

लाइव डेमो डाला गया मान GenderAPI.io को सिर्फ़ तभी भेजता है जब आप उसे सबमिट करते हैं। AI इस्तेमाल होने पर भेजा गया type, value और देश का संदर्भ कॉन्फ़िगर की गई अनुमान सेवा को भेजा जाता है। सिर्फ़ डेटासेट वाले अनुमान के लिए अपने इंटीग्रेशन में forceToGenderize के बिना options.ai_mode: off इस्तेमाल करें।

प्राइवेसी पॉलिसी, डेटा प्रोसेसिंग समझौता और सबप्रोसेसर सूची प्रकाशित प्रोसेसिंग शर्तों का विवरण देते हैं। परिणाम एक अनुमानित संबंध है; व्यक्ति की दी हुई जानकारी को प्राथमिकता दें। किसी व्यक्ति के बारे में महत्वपूर्ण फ़ैसलों का आधार इसे न बनाएँ।

- [प्राइवेसी पॉलिसी](https://www.genderapi.io/hi/privacy-policy)
- [डेटा प्रोसेसिंग समझौता](https://www.genderapi.io/hi/data-processing-agreement)
- [सबप्रोसेसर सूची](https://www.genderapi.io/hi/subprocessors)

## सिर्फ़ डेटासेट वाले मोड में दो अक्षरों वाला चीनी नाम अज्ञात क्यों रह सकता है?

मौजूदा कैंडिडेट फ़िल्टर उन टोकन को छोड़ देता है जिनकी JavaScript स्ट्रिंग लंबाई 2 या उससे कम है। यहाँ दिखाए गए चीनी अक्षरों के लिए दो अक्षरों वाला नाम मान्य इनपुट है, लेकिन डेटासेट कैंडिडेट नहीं बनता। AI फ़ॉलबैक मूल मान पर विचार कर सकता है।

## क्या V2 चीनी सरनेम और दिए गए नाम को अपने-आप अलग करता है?

डेटासेट खोज बिना स्पेस वाले चीनी पूरे नाम को नहीं बाँटती। AI पूरे मान से कोई नाम निकाल सकता है, लेकिन कोई भी तरीका सही दिए गए नाम की गारंटी नहीं देता। रिस्पॉन्स में source और match जाँचें।

## क्या इस तरह के नामों के लिए सटीकता का कोई स्वतंत्र मूल्यांकन प्रकाशित है?

इस पेज पर ऐसा कोई मूल्यांकन प्रकाशित नहीं है। इनपुट का स्वीकार होना, संग्रहीत गिनती दिखना या कॉन्फिडेंस स्कोर लौटना सटीकता का स्वतंत्र माप नहीं है। कार्यप्रणाली वाले पेज पर बताया गया है कि कौन-सा साक्ष्य उपलब्ध है और कौन-से माप अभी प्रकाशित नहीं हुए हैं।

## अनुमान न मिलने पर भी क्या क्रेडिट लगता है?

हाँ, सफल अज्ञात परिणाम पर भी शुल्क लगता है। सामान्य मोड (सिर्फ़ डेटासेट या फ़ॉलबैक) में कुल 1 क्रेडिट लगता है। forceToGenderize के साथ डेटासेट से परिणाम मिलने पर 1 क्रेडिट और AI इस्तेमाल होने पर कुल 2 क्रेडिट लगते हैं, अज्ञात परिणाम पर भी। त्रुटियों पर बिलिंग के अलग नियम लागू होते हैं; meta.usage जाँचें।