# Estima el género a partir de nombres árabes

> Consulta nombres en escritura árabe con GenderAPI.io V2. Comprende los signos diacríticos, las coincidencias de nombres completos, el contexto de país y los resultados de IA o unknown.

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

Last reviewed: 2026-09-28

## Conserva la escritura árabe y revisa el nombre seleccionado

Envía el nombre con su escritura Unicode original. El campo de esta herramienta muestra el árabe de derecha a izquierda; la guía en español y el JSON mantienen la dirección de izquierda a derecha. No necesitas transliterar el nombre al alfabeto latino. Que la API acepte la entrada no garantiza que exista un registro en el conjunto de datos.

La búsqueda aplica normalización Unicode NFKC y divide el texto en componentes. No incorpora una regla general para eliminar los signos diacríticos árabes ni equiparar distintas grafías. Las vocales marcadas y otras diferencias de escritura pueden cambiar el registro encontrado. Conserva el valor original en lugar de considerar todas las variantes equivalentes.

Un nombre completo puede generar varios candidatos. Se selecciona el registro disponible con el mayor recuento almacenado; la primera palabra no tiene por qué ser el nombre devuelto. Revisa data.name y data.match.name antes de incorporar el resultado a un contacto.

| Ejemplo de entrada | Qué muestra | Qué comprobar |
| --- | --- | --- |
| `ليلى الخطيب` | Ejemplo de nombre completo | Pueden evaluarse varios componentes. Revisa la coincidencia seleccionada; el ejemplo no garantiza un resultado concreto. |
| `ليلى / لَيْلَى` | Escritura sin signos vocálicos y con ellos | Envía la grafía real. No se garantiza que ambas cadenas coincidan con el mismo registro. |
| `Layla / Leila` | Grafías en alfabeto latino | Son entradas distintas. V2 no garantiza una equivalencia automática entre transliteraciones. |
| `country: SA` | Contexto de ejemplo: Arabia Saudí | No es el valor predeterminado para todas las comunidades de habla árabe. Omite country si desconoces el país. |

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

La demo envía country: SA (Arabia Saudí). 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": "SA",
  "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": "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+; 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\":\"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+ 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":"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+; 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\":\"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**

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\":\"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+; 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\":\"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)
    }
}
```

- [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)

## ¿V2 acepta nombres árabes con signos diacríticos?

Acepta nombres Unicode, incluidos los escritos en árabe. La normalización del conjunto de datos no elimina los signos diacríticos árabes de forma general. Las grafías con y sin ellos pueden coincidir con registros distintos o devolver unknown.

## ¿La herramienta identifica la nacionalidad de una persona que habla árabe?

No. SA es el contexto de país elegido explícitamente para esta demo. La escritura, una asociación de nombre o el país de la respuesta no verifican la nacionalidad ni la residencia.

## ¿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.