# Estima el género a partir de nombres de la India

> Consulta nombres utilizados en la India con GenderAPI.io V2. Conserva la escritura original, elige el contexto IN cuando corresponda e interpreta las coincidencias, la IA y los resultados unknown.

Canonical HTML: https://www.genderapi.io/es/determine-gender-from-indian-names

Last reviewed: 2026-09-28

## No supongas un único sistema de escritura ni un orden fijo del nombre

Esta demo utiliza un ejemplo en devanagari y el contexto de país IN. Es un caso ilustrativo; no representa todos los nombres utilizados en la India. La API acepta texto Unicode, por lo que puedes enviar la escritura original de tu registro sin convertirla al alfabeto latino.

La búsqueda utiliza componentes normalizados. No realiza una conversión general entre sistemas de escritura ni garantiza que la grafía latina coincida con el mismo registro que la original. Conserva la entrada junto con el nombre devuelto. Aceptar un sistema de escritura no demuestra una exactitud medida de forma independiente para cada idioma o comunidad.

No supongas que el primer o el último componente cumplen siempre la misma función. V2 selecciona el candidato disponible con el mayor recuento almacenado; no garantiza una posición concreta del nombre de pila. Las iniciales, los componentes cortos y la ausencia de registros pueden impedir una estimación. El respaldo de IA puede evaluar el valor completo enviado.

| Ejemplo de entrada | Qué muestra | Qué comprobar |
| --- | --- | --- |
| `प्रिया शर्मा` | Nombre completo en devanagari | Varios componentes pueden ser candidatos. Revisa el nombre y la coincidencia devueltos en lugar de dar por hecho que se selecciona el primero. |
| `Priya Sharma` | Ejemplo en alfabeto latino | Es una grafía distinta; no se garantiza la misma coincidencia entre sistemas de escritura. |
| `A. Kumar` | Inicial y componente del nombre | La inicial de una letra no es un candidato de búsqueda. Una coincidencia del otro componente no confirma el nombre de pila previsto. |
| `country: IN` | Contexto de ejemplo: India | Utilízalo si tu registro contiene información de país relevante, no simplemente porque el nombre aparezca en esta guía. |

## Utiliza el contexto de país IN cuando corresponda

La demo envía country: IN (India). La API no elige ese país a partir de la escritura del nombre. En tu integración, utiliza un contexto de país conocido y relevante, u omite country. No conviertas este ejemplo en el valor predeterminado de todos tus registros.

Para cada candidato, la búsqueda utiliza el registro específico del país si existe; si no, consulta el global. Después selecciona el candidato disponible con el mayor recuento almacenado. Comprueba el alcance real con data.match.scope y data.match.country. Un empate de recuentos en el registro del país no activa automáticamente el registro global; si fallback está habilitado, puede recurrirse a la IA.

data.input.country es el contexto enviado en la solicitud. data.country y data.country_source describen la asociación de país de la respuesta y su origen. Son campos diferentes; no verifican ciudadanía, origen étnico ni residencia.

- [Contexto de país y coincidencias](https://www.genderapi.io/es/docs/v2/gender-from-name#country-evidence-workflow)

## Envía una consulta de nombre V2 desde tu aplicación

Configura GENDERAPI_API_KEY con tu clave existente y ejecuta el ejemplo en tu servidor. La solicitud activa explícitamente el respaldo estándar de IA. Ilustra el formato de la petición, no una exactitud medida ni una cobertura demostrada. Para utilizar solo el conjunto de datos, selecciona options.ai_mode: off.

Ejecuta estos ejemplos en tu servidor. Configura GENDERAPI_API_KEY en el entorno de proceso con tu clave API existente. Confirma que meta.access.mode es api_key: una clave no reconocida puede recurrir a la prueba IP.

Cada solicitud de predicción es una nueva operación facturable, incluidos los reintentos. Estos ejemplos no se reintentan automáticamente. Comprueba el estado de facturación antes de enviar otra solicitud.

Las respuestas HTTP 4xx y 5xx JSON conservan el cuerpo del error y devuelven un estado de salida distinto de cero. Comprueba code, action y meta.usage.billing_status antes de volver a intentarlo.

**cURL**

cURL 7.76+ en un shell POSIX. Ejecuta en tu 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": "IN",
  "options": {
    "ai_mode": "fallback"
  }
}'
```

**JavaScript / Node.js**

Node.js 22+; fetch integrado. Guarda como example.mjs y ejecuta 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": "IN",
  "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+; biblioteca estándar. Guarda como example.py y ejecuta 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\":\"IN\",\"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+ con la extensión cURL. Guarda como example.php y ejecuta 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":"IN","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+; cliente estándar HTTP. Guarda como GenderApiExample.java y ejecuta 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\":\"IN\",\"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**

Aplicación de consola .NET 8+. Úsalo como Program.cs en un proyecto de consola, luego ejecuta 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\":\"IN\",\"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+; biblioteca estándar. Guarda como main.go y ejecuta 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\":\"IN\",\"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)
    }
}
```

- [Parámetros de consulta de nombres](https://www.genderapi.io/es/docs/v2/gender-from-name)
- [Configura tu clave API](https://www.genderapi.io/es/docs/v2/authentication)

## Interpreta el resultado junto con sus evidencias

Una asociación inferida no equivale al género declarado por la persona. Conserva por separado el dato original, las evidencias de la respuesta y la información facilitada por la persona. unknown es un resultado válido; no lo conviertas en una categoría inventada.

| Campo | Cómo utilizarlo |
| --- | --- |
| `data.gender / data.result_status` | Utiliza male o female solo cuando el resultado sea identified. Conserva el valor JSON null cuando sea unknown. |
| `data.name / data.match` | Revisa el nombre devuelto y el candidato seleccionado. Una coincidencia parcial no demuestra que el dato pertenezca a una persona con ese nombre. |
| `data.confidence / data.confidence_kind` | La confianza se expresa entre 0 y 1, o como null. observed_frequency procede de recuentos almacenados; model_reported es una puntuación de IA. Evalúa los umbrales por separado para cada tipo. |
| `data.source / data.sample_count` | Distingue dataset, ai y none. Los resultados de IA no tienen un recuento de muestras almacenadas. El tamaño de la muestra no es una medida de exactitud. |
| `meta.access.mode` | Comprueba api_key en una integración de cuenta. Si falta la clave o no se reconoce, puede utilizarse la prueba compartida por IP. |
| `meta.usage` | Revisa charged_credits y billing_status. Un resultado unknown completado correctamente consume créditos. No recibir la respuesta no demuestra que la consulta haya sido gratuita. |

- [Campos de respuesta y resultados desconocidos](https://www.genderapi.io/es/docs/v2/responses)
- [Exactitud y confianza](https://www.genderapi.io/es/accuracy-methodology)
- [Fuentes de datos y perfil del conjunto de datos](https://www.genderapi.io/es/data-provenance)

## Elige cuándo utilizar la IA

forceToGenderize es opcional para nombres, correos electrónicos y nombres de usuario. Si lo activas, omite ai_mode o utiliza fallback; combinarlo con off o always devuelve un error 422. Basta con un saldo inicial positivo para iniciar la consulta, aunque el cargo final deje el saldo por debajo de cero.

El análisis de alias puede devolver un género con name: null. También puede devolver unknown. Ni el respaldo estándar de IA ni el análisis de alias garantizan una respuesta correcta o distinta de null.

| Opción de la solicitud | Comportamiento | Créditos por consulta completada |
| --- | --- | --- |
| options.ai_mode: off | Consulta únicamente el conjunto de datos. | 1 crédito, incluido unknown |
| options.ai_mode: fallback | Consulta primero el conjunto de datos y recurre a la IA estándar si no obtiene un género. Es el modo predeterminado de las consultas individuales. | 1 crédito en total, incluido el respaldo de IA |
| options.ai_mode: always | Consulta directamente a la IA. | 2 créditos |
| forceToGenderize: true | Consulta primero el conjunto de datos; si no encuentra un género, permite interpretar el significado de un alias personal, aunque no contenga un nombre real. | 1 crédito si el conjunto de datos resuelve la consulta; 2 en total si se utiliza IA |

- [Opciones de IA y análisis de alias](https://www.genderapi.io/es/docs/v2/ai-options)
- [Créditos y uso](https://www.genderapi.io/es/docs/v2/credits-and-usage)

## Procesa una lista de nombres sin perder su contexto

Envía hasta 50 elementos con una clave de cuenta o 10 en la prueba por IP mediante POST /api/v2/gender/batch. Asigna id únicos y conserva la entrada original de cada fila. Cada elemento puede tener sus propias opciones de país e IA. Omite el país cuando lo desconozcas.

A diferencia de las consultas individuales, cuyo modo predeterminado es fallback, los elementos de un lote utilizan solo el conjunto de datos por defecto. Activa options.ai_mode: fallback en cada elemento que requiera IA. Revisa todos los resultados aunque recibas HTTP 200 y conserva unknown. Comprueba los errores y la facturación antes de reenviar. Cada elemento estándar completado cuesta 1 crédito; una solicitud HTTP de lote no equivale a un único crédito de predicción.

- [Ejemplos de lotes y errores parciales](https://www.genderapi.io/es/docs/v2/batch#batch-application-workflow)
- [Resultados unknown en tu aplicación](https://www.genderapi.io/es/docs/v2/responses#application-decisions)

## Comprende cómo se procesa el dato que envías

La herramienta envía el valor a GenderAPI.io solo cuando pulsas Analizar. Si interviene la IA, el servicio de inferencia configurado recibe type, value y el contexto de país enviado. Para consultar únicamente el conjunto de datos, utiliza options.ai_mode: off sin forceToGenderize en tu integración.

La Política de Privacidad, el acuerdo de tratamiento y la lista de subencargados describen las condiciones publicadas. El resultado es una asociación inferida; da prioridad a la información que facilite la persona. No lo utilices como fundamento de decisiones con consecuencias importantes para alguien.

- [Política de Privacidad](https://www.genderapi.io/es/privacy-policy)
- [Acuerdo de tratamiento de datos](https://www.genderapi.io/es/data-processing-agreement)
- [Subencargados del tratamiento](https://www.genderapi.io/es/subprocessors)

## ¿La herramienta acepta únicamente nombres en hindi?

La demo utiliza un ejemplo en devanagari, pero la API acepta nombres en texto Unicode. Esto no implica cobertura completa ni exactitud medida para todos los idiomas utilizados en la India.

## ¿La grafía latina produce el mismo resultado que la original?

No se garantiza. La búsqueda actual no establece una equivalencia general entre transliteraciones. Conserva cada grafía enviada junto con su fuente, coincidencia y confianza.

## ¿Se publica una evaluación independiente de exactitud para este grupo de nombres?

Esta página no publica esa evaluación. Aceptar una entrada, mostrar recuentos almacenados o devolver una puntuación de confianza no constituye una prueba independiente de exactitud. Consulta la metodología para conocer las evidencias disponibles y las mediciones aún no publicadas.

## ¿Se consumen créditos si no se obtiene una estimación?

Un resultado unknown completado correctamente consume créditos. El modo estándar de conjunto de datos o fallback cuesta 1 crédito en total. Con forceToGenderize se cobra 1 crédito si se resuelve con el conjunto de datos, o 2 en total si se utiliza IA, incluido unknown. Los errores tienen reglas de facturación distintas; revisa meta.usage.