# यूज़रनेम और निकनेम से लिंग का अनुमान

> V2 से यूज़रनेम और निकनेम का विश्लेषण करें: forceToGenderize, हर आइटम के लिए AI, अज्ञात परिणाम और दोहराए गए अनुरोधों की लागत।

Canonical HTML: https://www.genderapi.io/hi/blog/upnaam-aur-username-se-ling-pehchan

Last reviewed: 2026-09-29

## प्रकाशन की जानकारी

पहली बार प्रकाशित: 2025-06-04T13:00:00.000Z

अंतिम समीक्षा: 2026-09-29T00:00:00.000Z

## क्या यूज़रनेम से लिंग का अनुमान लगाया जा सकता है?

असली पहला नाम न होने पर GenderAPI यूज़रनेम, निकनेम या डिस्प्ले नाम में मौजूद नाम के संकेतों का विश्लेषण कर सकता है। API के एकल या बैच अनुरोध, या Excel/CSV वर्कफ़्लो इस्तेमाल करें, और परिणाम को सत्यापित पहचान नहीं, बल्कि अनुमान मानें।

## निकनेम पहचान का सत्यापन नहीं है

@alice_smith में नाम का कोई हिस्सा मिल सकता है। prenses के लिए forceToGenderize इस्तेमाल करने पर नाम null रहते हुए भी अनुमान मिल सकता है। user47291 का परिणाम अज्ञात रह सकता है। ये सिर्फ़ उदाहरण इनपुट हैं; हम इनके लिए कोई लिंग परिणाम पहले से तय नहीं करते।

## यूज़रनेम से लिंग का अनुमान कैसे लगाया जाता है?

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

- यूज़रनेम: निकनेम या डिस्प्ले नाम
- संकेतों का विश्लेषण: नाम और संदर्भ
- अनुमान: लिंग और confidence

## अपने डेटा के लिए सही तरीका चुनें

- [एकल अनुरोध REST API से एक यूज़रनेम का विश्लेषण करें। API गाइड देखें →](https://www.genderapi.io/hi/docs/v2/gender-from-username)
- [बैच अनुरोध एक संरचित अनुरोध में कई आइटम भेजें। बैच गाइड देखें →](https://www.genderapi.io/hi/docs/v2/batch)
- [Excel/CSV वर्कफ़्लो इंटीग्रेशन बनाए बिना फ़ाइलें प्रोसेस करें। टूल खोलें →](https://app.genderapi.io/csv)

## Excel या CSV फ़ाइल में यूज़रनेम का विश्लेषण चार चरणों में करें

### Excel/CSV टूल खोलें

GenderAPI का फ़ाइल अपलोड टूल खोलें और प्रोसेस की जाने वाली फ़ाइल अपलोड करें।

### स्रोत कॉलम चुनें

वह कॉलम मैप करें जिसमें यूज़रनेम, निकनेम या डिस्प्ले नाम हैं।

### निकनेम की व्याख्या चालू करें

उपनामों और सोशल मीडिया नामों की व्याख्या करने वाला विकल्प चालू करें।

### पहले नमूना जाँचें, फिर एक्सपोर्ट करें

पहले रिकॉर्ड के एक प्रतिनिधि नमूने की समीक्षा करें, फिर पूरी फ़ाइल प्रोसेस करके संवर्धित डेटा डाउनलोड करें।

नए अकाउंट में हर दिन 200 मुफ़्त क्रेडिट मिलते हैं, ताकि पूरी फ़ाइल प्रोसेस करने से पहले आप नमूने पर वर्कफ़्लो आज़मा सकें।

अपलोड की गई Excel और CSV फ़ाइलें पाँच दिनों के भीतर सक्रिय सिस्टम से हटा दी जाती हैं; परिणाम एक्सपोर्ट करने के बाद आप पहले हटाने का अनुरोध कर सकते हैं। एक्सेस-प्रतिबंधित रोलिंग बैकअप में डेटा अधिकतम 15 अतिरिक्त दिनों तक रह सकता है। विवरण के लिए [प्राइवेसी पॉलिसी](https://www.genderapi.io/hi/privacy-policy) देखें।

## असली पहला नाम न हो, तो इसे सहायक संकेत की तरह इस्तेमाल करें

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

- [ईमेल पते से पहला नाम और लिंग संकेत निकालें](https://www.genderapi.io/hi/blog/extract-names-from-email-addresses)
- [Excel और CSV फ़ाइलों की बल्क प्रोसेसिंग](https://www.genderapi.io/hi/blog/excel-%E0%A4%A4%E0%A4%A5%E0%A4%BE-csv-%E0%A4%AE%E0%A5%87%E0%A4%82-%E0%A4%A8%E0%A4%BE%E0%A4%AE%E0%A5%8B%E0%A4%82-%E0%A4%95%E0%A4%BE-%E0%A4%B2%E0%A4%BF%E0%A4%82%E0%A4%97-%E0%A4%95%E0%A5%88%E0%A4%B8%E0%A5%87-%E0%A4%AA%E0%A4%B9%E0%A4%9A%E0%A4%BE%E0%A4%A8%E0%A5%87-gender-api-%E0%A4%95%E0%A5%87-%E0%A4%B8%E0%A4%BE%E0%A4%A5)

## परिणाम को सत्यापित पहचान न मानें

हर निकनेम में असली पहला नाम नहीं होता, सांस्कृतिक जुड़ाव अलग-अलग होते हैं और एक ही शब्द के अलग भाषाओं में अलग अर्थ हो सकते हैं। संकेत काफ़ी न हो, तो कमज़ोर डेटा से पक्का निष्कर्ष बनाने के बजाय खाली परिणाम स्वीकार करें।

V2 के confidence और स्रोत फ़ील्ड साथ में सेव करें, अपने डेटा पर प्रदर्शन मापें, और इस संकेत के आधार पर किसी व्यक्ति के बारे में बड़े असर वाले फ़ैसले न लें, जैसे रोज़गार, ऋण या स्वास्थ्य से जुड़े फ़ैसले।

## स्रोत डेटा और अनुमान को अलग-अलग सेव करें

मूल रिकॉर्ड का पहचानकर्ता सुरक्षित रखें। API कोई प्रोफ़ाइल नहीं खोलता, अकाउंट के मालिक की पुष्टि नहीं करता और किसी की पहचान सत्यापित नहीं करता। देश का संदर्भ तभी भेजें जब वह भरोसेमंद जानकारी से आया हो; उसे डोमेन या वेबसाइट की भाषा से अनुमानित न करें।

यूज़रनेम को type: username के साथ भेजें, प्रोफ़ाइल का URL नहीं। डेटासेट में खोज शुरुआती @ हटाती है, टेक्स्ट को सामान्य रूप में लाती है और विभाजक चिह्नों व अंकों के आधार पर संभावित नाम बनाती है। सामान्य अनुरोध आगे और पीछे के भाग से सीमित संख्या में अतिरिक्त मिलान जोड़ सकता है; forceToGenderize ये अतिरिक्त हिस्से इस्तेमाल नहीं करता। कई पंक्तियाँ मिलने पर सबसे ज़्यादा दर्ज उपस्थिति वाली पंक्ति चुनी जाती है। ईमेल पतों के लिए type: email और असली नामों के लिए type: name इस्तेमाल करें।

| उदाहरण इनपुट | फ़ील्ड या विकल्प | व्याख्या |
| --- | --- | --- |
| @alice_smith | data.name / data.match | मूल यूज़रनेम सुरक्षित रखें; मिले हुए हिस्से को सत्यापित पहला नाम न मानें। |
| prenses | forceToGenderize: true | असली पहले नाम के बिना भी निकनेम की व्याख्या की अनुमति देता है। लिंग मिल सकता है जबकि data.name null रहे; ऐसे उपयोगकर्ता के लिए कोई नाम न गढ़ें। |
| user47291 | data.result_status: unknown | अस्पष्ट या अपर्याप्त इनपुट का परिणाम अज्ञात रह सकता है। यह अनुरोध को अपने-आप दोबारा भेजने का कारण नहीं है। |

### प्रोसेसिंग मोड और क्रेडिट की लागत चुनें

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

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

### बैच अनुरोध में हर आइटम के विकल्प सेट करें

उदाहरण इनपुट किसी तय अनुमान की गारंटी नहीं देते। GENDERAPI_API_KEY को सर्वर के वातावरण में सेट करें और कुंजी को सार्वजनिक क्लाइंट कोड में न रखें। V1 और V2 एक ही अकाउंट की API कुंजी और एक ही बैलेंस इस्तेमाल करते हैं। कुंजी /api/v2/usage से जाँचें और पुष्टि करें कि meta.access.mode का मान api_key है।

अपनी प्रोग्रामिंग भाषा चुनें। [अपनी API कुंजी सेट करें](https://www.genderapi.io/hi/docs/v2/authentication#environment-setup), फिर अपने सर्वर पर उदाहरण चलाएँ।

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

### चलाने से पहले: एक्सेस और त्रुटियों को संभालना

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

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

**cURL**

POSIX शेल में cURL 7.76+। अपने टर्मिनल में चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://curl.se/docs/manpage.html)

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender/batch' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
}'
```

**JavaScript / Node.js**

Node.js 22+; बिल्ट-इन fetch। example.mjs के रूप में सेव करें और node example.mjs चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://nodejs.org/api/globals.html#fetch)

```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 = {
  "items": [
    {
      "id": "profile-001",
      "type": "username",
      "value": "@alice_smith",
      "options": {
        "ai_mode": "off"
      }
    },
    {
      "id": "profile-002",
      "type": "username",
      "value": "alexriver",
      "options": {
        "ai_mode": "fallback"
      }
    },
    {
      "id": "profile-003",
      "type": "username",
      "value": "prenses",
      "country": "TR",
      "forceToGenderize": true
    }
  ]
};

const response = await fetch("https://api.genderapi.io/api/v2/gender/batch", {
  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 चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://docs.python.org/3/library/urllib.request.html)

```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("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}")

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/batch",
    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 चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://www.php.net/manual/en/book.curl.php)

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"items":[{"id":"profile-001","type":"username","value":"@alice_smith","options":{"ai_mode":"off"}},{"id":"profile-002","type":"username","value":"alexriver","options":{"ai_mode":"fallback"}},{"id":"profile-003","type":"username","value":"prenses","country":"TR","forceToGenderize":true}]}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender/batch');
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 चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://docs.oracle.com/en/java/javase/17/docs/api/java.net.http/java/net/http/HttpClient.html)

```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 = "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}";
        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/batch"))
            .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 चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://learn.microsoft.com/en-us/dotnet/fundamentals/networking/http/httpclient)

```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/batch");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}", 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 चलाएँ। [रनटाइम दस्तावेज़ीकरण](https://pkg.go.dev/net/http)

```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 := "{\"items\":[{\"id\":\"profile-001\",\"type\":\"username\",\"value\":\"@alice_smith\",\"options\":{\"ai_mode\":\"off\"}},{\"id\":\"profile-002\",\"type\":\"username\",\"value\":\"alexriver\",\"options\":{\"ai_mode\":\"fallback\"}},{\"id\":\"profile-003\",\"type\":\"username\",\"value\":\"prenses\",\"country\":\"TR\",\"forceToGenderize\":true}]}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender/batch", 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/errors-and-retries)

### सूची के परिणाम और दोहराए गए अनुरोध संभालें

POST /api/v2/gender/batch API कुंजी के साथ अधिकतम 50 आइटम और IP ट्रायल में अधिकतम 10 आइटम स्वीकार करता है। हर आइटम के लिए type, value और options अलग से दें। सामान्य AI फ़ॉलबैक चाहिए, तो हर आइटम में fallback साफ़ तौर पर सेट करें। id एक ही बैच में अद्वितीय होना चाहिए; index भेजे गए बैच में शून्य से शुरू होता है। अपने काम का पहचानकर्ता और स्रोत पंक्ति का पहचानकर्ता अलग से सेव करें।

HTTP 200 का मतलब यह नहीं है कि सभी आइटम पूरे हो गए। identified, unknown और error परिणामों को अलग-अलग संभालें; meta.summary.succeeded में identified और unknown दोनों गिने जाते हैं। data.gender, source, confidence_kind, confidence, match और reason को साथ मिलाकर देखें। AI स्कोर और डेटासेट की आवृत्ति को एक जैसा न मानें।

अगर meta.usage.billing_status का मान confirmed है, तो केवल उन्हीं प्रक्रिया त्रुटियों को दोबारा भेजें जिनके लिए यह अनुमति है। अगर स्थिति unconfirmed है या रिस्पॉन्स नहीं मिला, तो रुकें और बिलिंग जाँचें। उसी आइटम को दोबारा भेजना, पूरे हुए unknown परिणाम सहित, एक नई शुल्क वाली प्रक्रिया है; पूरी सूची को बिना सोचे दोबारा कभी न भेजें।

[बैच अनुरोध के नियम](https://www.genderapi.io/hi/docs/v2/batch) · [रिस्पॉन्स फ़ील्ड](https://www.genderapi.io/hi/docs/v2/responses) · [AI विकल्प](https://www.genderapi.io/hi/docs/v2/ai-options) · [सटीकता और confidence का आकलन](https://www.genderapi.io/hi/accuracy-methodology) · [प्राइवेसी पॉलिसी](https://www.genderapi.io/hi/privacy-policy)

Excel ऐड-इन, Google Sheets ऐड-ऑन और दूसरे तैयार इंटीग्रेशन अपने कनेक्शन और परिणाम फ़ॉर्मेट इस्तेमाल कर सकते हैं। यह न मानें कि उनका आउटपुट इसी V2 JSON ढाँचे पर चलता है; संबंधित इंटीग्रेशन की मौजूदा गाइड देखें।

## यूज़रनेम या निकनेम से लिंग

### क्या यूज़रनेम से लिंग का अनुमान लगाया जा सकता है?

V2 में forceToGenderize चालू करने पर पहले डेटासेट में खोज होती है; अगर लिंग तय नहीं होता, तो AI असली पहले नाम के बिना भी निकनेम की व्याख्या कर सकता है। परिणाम फिर भी unknown हो सकता है और यह सत्यापित पहचान नहीं है। सामान्य AI फ़ॉलबैक के लिए इस्तेमाल करने लायक असली पहला नाम चाहिए।

### कौन-से यूज़रनेम सबसे उपयोगी परिणाम देते हैं?

जिन मानों में असली पहला नाम, पहचाना जा सकने वाला निकनेम या नाम का साफ़ हिस्सा हो, वे ज़्यादा उपयोगी संकेत दे सकते हैं। बेतरतीब अक्षरों और ब्रांड नामों का हमेशा परिणाम नहीं मिलता।

### क्या API से एक यूज़रनेम का विश्लेषण किया जा सकता है?

हाँ। एकल अनुरोध वाला एंडपॉइंट एक आइटम का विश्लेषण करता है। कई आइटम के लिए अलग बैच अनुरोध एंडपॉइंट है।

### क्या Excel या CSV फ़ाइल अपलोड की जा सकती है?

हाँ। फ़ाइल टूल में आप यूज़रनेम या डिस्प्ले नाम वाला कॉलम चुन सकते हैं और निकनेम की व्याख्या चालू कर सकते हैं।

### V2 के confidence और स्रोत फ़ील्ड साथ में क्यों सेव करने चाहिए?

V2 में data.confidence का मान 0 से 1 के बीच होता है। इस मान को source और confidence_kind के साथ पढ़ें, क्योंकि AI स्कोर और डेटासेट की आवृत्ति अलग-अलग चीज़ें मापते हैं। unknown परिणाम और reason फ़ील्ड सुरक्षित रखें।

### क्या परिणाम ग्राहक सेगमेंटेशन के लिए ठीक हैं?

कुल स्तर के विश्लेषण और डेटा संवर्धन में ये सहायक संकेत हो सकते हैं, लेकिन किसी व्यक्ति के लिए बड़े असर वाला फ़ैसला अकेले इन पर नहीं लेना चाहिए, न ही इनसे किसी की पहचान तय करनी चाहिए।

### क्या इसे मुफ़्त में आज़माया जा सकता है?

नए GenderAPI अकाउंट में हर दिन 200 मुफ़्त क्रेडिट मिलते हैं, जिनसे आप API या फ़ाइल के ज़रिए प्रतिनिधि नमूनों की जाँच कर सकते हैं।
