> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Enriquecimiento de identidad global: API de verificación

> Didit consulta redes de identidad globales para enriquecer y verificar identidades. Pago por consulta desde $0.20, sin contratos ni mínimos.

Permite identificar personas (nombres, fecha de nacimiento, direcciones, teléfonos, correos electrónicos, números de identificación nacional) y calcular una puntuación de coincidencia de nombre a partir de un correo electrónico o un número de teléfono, o ambos, mediante una red global de información de riesgo. Se cobra por solicitud. Didit ofrece este servicio a través de `POST /v3/database-validation/` para que puedas contrastar los datos enviados con la red de identidad conectada y recibir resultados de coincidencia normalizados. Se trata de una red de enriquecimiento de terceros, no de un registro gubernamental oficial: no presentes sus resultados como una verificación basada en fuentes primarias.

## Cobertura

* **Cobertura:** 50+ mercados
* **País:** Global
* **ID del servicio:** `glb_identity_enrichment`
* **Dominio de datos:** Identidad
* **Categoría:** IdentityEnrichment

## Datos de entrada

| Campo | Obligatorio | Ejemplo |
| - | -: | - |
| `email` | No | `john.doe@example.com` |
| `phone` | No | `+15550101000` |
| `first_name` | No | `John` |
| `last_name` | No | `Doe` |
| `full_name` | No | `John Doe` |
| `country_of_residence` | No | `US` |
| `vendor_data` | No | `user-1234` |

* **Datos de entrada obligatorios:** —
* **Datos de entrada opcionales:** `email`, `phone`, `first_name`, `last_name`, `full_name`, `country_of_residence`, `vendor_data`
* **Consentimiento:** Obligatorio
* **Disponibilidad en flujos:** Solo API independiente
* **Cobertura:** 50+ mercados
* **Precio:** \$0.20 por consulta exitosa

Este servicio no se ofrece como paso de Validación de base de datos dentro de un flujo. Eso limita dónde se ejecuta la comprobación, no lo que puedes enviarle: invócalo mediante la API independiente, donde proporcionas los datos de entrada directamente.

## Parámetros del cuerpo

**issuing\_state** `string` *required* (default: GLB)

Código de país ISO 3166-1 alfa-3 de este servicio de base de datos.

Ejemplo: `GLB`

**services** `string` *required* (default: glb\_identity\_enrichment)

Array que contiene el ID de este servicio. Fijar el servicio limita la solicitud a esta base de datos concreta.

Ejemplo: `glb_identity_enrichment`

**consent** `boolean` *required* (default: true)

Consentimiento explícito del usuario final para este servicio.

Ejemplo: `true`

**email** `string` (default: [john.doe@example.com](mailto:john.doe@example.com))

Dirección de correo electrónico.

Ejemplo: `john.doe@example.com`

**phone** `string` (default: +15550101000)

Número de teléfono en formato internacional.

Ejemplo: `+15550101000`

**first\_name** `string` (default: John)

Nombre de pila que se va a validar.

Ejemplo: `John`

**last\_name** `string` (default: Doe)

Apellido que se va a validar.

Ejemplo: `Doe`

**full\_name** `string`

Nombre legal completo que se va a validar.

Ejemplo: `John Doe`

**country\_of\_residence** `string` (default: US)

País de residencia opcional en formato ISO 3166-1 alfa-2. Solo se usa para acotar la búsqueda de identidad.

Ejemplo: `US`

**vendor\_data** `string` (default: user-1234)

Tu referencia estable de usuario para esta persona, como tu ID de usuario interno. Didit la usa para vincular las comprobaciones independientes al mismo usuario final y reducir el ruido en la detección de duplicados.

Ejemplo: `user-1234`

## Reglas de entrada y notas de validación

* Proporciona al menos uno de `email` o `phone`: son las claves de búsqueda. Una solicitud sin ninguno de los dos no puede realizar una búsqueda de enriquecimiento y se rechaza antes de consultar la fuente (no se cobra).
* Añade un nombre siempre que lo tengas: la fuente puntúa la búsqueda en función de él. Envía `first_name` + `last_name`: son los campos que compara el mapa `validation` de la respuesta. Una solicitud que solo envía `full_name` la fuente sigue asignándole una puntuación, pero la respuesta incluye un `validation` vacío y un `match_type` de nivel superior nulo.
* `country_of_residence` es un código ISO 3166-1 alfa-2 que se usa para acotar la búsqueda.
* Se cobra toda búsqueda completada, incluida la que no encuentra ninguna persona (`persons_found: 0`). Solo es gratuita una solicitud rechazada antes de la búsqueda, es decir, cuando no se proporciona ni `email` ni `phone`.

## Cómo invocarlo

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=GLB" \
  -F "services=glb_identity_enrichment" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "email=john.doe@example.com" \
  -F "phone=+15550101000" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "country_of_residence=US"
```

```python Python theme={null}
from didit import Didit

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="GLB",
    services=["glb_identity_enrichment"],
    consent=True,
    first_name="John",
    last_name="Doe",
    phone="+15550101000",
    email="john.doe@example.com",
    country_of_residence="US",
    vendor_data="user-1234",
)
print(result)
```

```javascript Node.js theme={null}
import Didit from "@didit-protocol/sdk-node";

// Reads DIDIT_API_KEY.
const didit = new Didit();

const result = await didit.databaseValidation.validate({
  issuing_state: "GLB",
  services: ["glb_identity_enrichment"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  phone: "+15550101000",
  email: "john.doe@example.com",
  country_of_residence: "US",
  vendor_data: "user-1234",
});
console.log(result);
```

```go Go theme={null}
ctx := context.Background()
// Reads DIDIT_API_KEY.
client := didit.NewClient()

result, err := client.DatabaseValidation.Validate(ctx, didit.DatabaseValidationValidateParams{
	IssuingState:       "GLB",
	Services:           didit.Some([]string{"glb_identity_enrichment"}),
	Consent:            didit.Bool(true),
	FirstName:          didit.String("John"),
	LastName:           didit.String("Doe"),
	Phone:              didit.String("+15550101000"),
	Email:              didit.String("john.doe@example.com"),
	CountryOfResidence: didit.String("US"),
	VendorData:         didit.String("user-1234"),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
import java.util.List;
import me.didit.Didit;
import me.didit.types.DatabaseValidationValidateParams;

// Reads DIDIT_API_KEY.
Didit client = new Didit();

var result = client.databaseValidation().validate(DatabaseValidationValidateParams.builder()
        .issuingState("GLB")
        .services(List.of("glb_identity_enrichment"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .phone("+15550101000")
        .email("john.doe@example.com")
        .countryOfResidence("US")
        .vendorData("user-1234")
        .build());
System.out.println(result);
```

```php PHP theme={null}
<?php

require 'vendor/autoload.php';

use Didit\DiditClient;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'GLB',
    'services' => ['glb_identity_enrichment'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'phone' => '+15550101000',
    'email' => 'john.doe@example.com',
    'country_of_residence' => 'US',
    'vendor_data' => 'user-1234',
]);
print_r($result->toArray());
```

```ruby Ruby theme={null}
require "didit"

# Reads DIDIT_API_KEY.
didit = Didit::Client.new

result = didit.database_validation.validate(
  issuing_state: "GLB",
  services: ["glb_identity_enrichment"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  phone: "+15550101000",
  email: "john.doe@example.com",
  country_of_residence: "US",
  vendor_data: "user-1234"
)
puts result.to_h
```

```csharp .NET theme={null}
using System;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.DatabaseValidation.ValidateAsync(new DatabaseValidationValidateParams
{
    IssuingState = "GLB",
    Services = new string[] { "glb_identity_enrichment" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    Phone = "+15550101000",
    Email = "john.doe@example.com",
    CountryOfResidence = "US",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Toda llamada exitosa devuelve HTTP `200`. El campo **`outcome_code`** te indica lo que realmente ocurrió: distingue, por ejemplo, una no coincidencia biométrica real (`BIOMETRIC_NO_MATCH`) de una selfie que no se pudo leer (`BIOMETRIC_IMAGE_UNUSABLE`). El `status` que se muestra es el estado predeterminado de la función; las [acciones de coincidencia parcial y sin coincidencia](https://docs.didit.me/es/core-technology/database-validation/database-validation-warnings.md) que hayas configurado pueden anularlo.

**`MATCH`**: el correo electrónico o el teléfono se asoció a una persona, y el nombre de la mejor coincidencia coincide con el nombre que enviaste.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "GLB",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "glb_identity_enrichment",
      "service_name": "Global - Identity Enrichment",
      "source_data": {
        "first_name": "John",
        "last_name": "Doe",
        "persons_found": 1
      },
      "validation": {
        "full_name": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`**: el correo electrónico o el teléfono se asoció a una persona, pero el nombre de la mejor coincidencia solo coincide en parte con el nombre que enviaste.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "GLB",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "glb_identity_enrichment",
      "service_name": "Global - Identity Enrichment",
      "source_data": {
        "first_name": "John",
        "last_name": "Dow",
        "persons_found": 1
      },
      "validation": {
        "full_name": "partial_match"
      }
    }
  ]
}
```

**`NO_MATCH`**: el correo electrónico o el teléfono se asoció a una persona, pero el nombre de la mejor coincidencia no coincide con el nombre que enviaste.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "GLB",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "glb_identity_enrichment",
      "service_name": "Global - Identity Enrichment",
      "source_data": {
        "first_name": "Jane",
        "last_name": "Roe",
        "persons_found": 1
      },
      "validation": {
        "full_name": "no_match"
      }
    }
  ]
}
```

**`INCONCLUSIVE`**: el correo electrónico o el teléfono se asoció a una persona, pero no se devolvió ninguna puntuación de nombre, por ejemplo porque la solicitud no incluía ningún nombre. No se afirma nada, así que `validation` está vacío, `match_type` es null y la comprobación se envía a revisión. Envía `first_name` + `last_name` para obtener un resultado con puntuación: esos son los campos que lee la comparación de `validation`, y una solicitud que solo incluye `full_name` obtiene un `outcome_code` con puntuación, pero `validation` sigue vacío.

```json 200 OK — INCONCLUSIVE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "GLB",
  "match_type": null,
  "validations": [
    {
      "outcome_code": "INCONCLUSIVE",
      "service_id": "glb_identity_enrichment",
      "service_name": "Global - Identity Enrichment",
      "source_data": {
        "persons_found": 1
      },
      "validation": {}
    }
  ]
}
```

**`DOCUMENT_NOT_FOUND`**: el correo electrónico o el teléfono no se asoció a ninguna persona (`persons_found: 0`). No hay ningún nombre que comparar, así que `validation` está vacío y `match_type` es null; el resultado es un negativo definitivo y sigue la acción de sin coincidencia que hayas configurado. La consulta se cobra igualmente.

```json 200 OK — DOCUMENT_NOT_FOUND theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "GLB",
  "match_type": null,
  "validations": [
    {
      "outcome_code": "DOCUMENT_NOT_FOUND",
      "service_id": "glb_identity_enrichment",
      "service_name": "Global - Identity Enrichment",
      "source_data": {
        "persons_found": 0
      },
      "validation": {}
    }
  ]
}
```

## Datos devueltos

Los campos exactos que aparecen en `source_data` dependen de lo que devuelva el registro. El ejemplo generado para `glb_identity_enrichment` documenta actualmente esta estructura normalizada:

* `first_name`
* `last_name`
* `persons_found`

## Precios y SLA

Las consultas de Global - Identity Enrichment solo se facturan cuando Didit recibe un resultado concluyente de la fuente de validación.

* **Precio por llamada:** \$0.20 USD.
* **Facturación:** por consulta exitosa. No se te cobra cuando no se puede acceder al registro, cuando faltan campos obligatorios ni cuando la solicitud se rechaza antes de llegar a la fuente.
* **Latencia:** p95 típico \< 2 s.
* **Disponibilidad:** 99.9% por trimestre por parte de Didit; la disponibilidad de las fuentes externas varía según el país y el conjunto de datos.

## Continúa leyendo

* [Visión general de la validación de base de datos global](https://docs.didit.me/es/getting-started/database-validation-pricing.md)
* [Visión general de la validación de base de datos](https://docs.didit.me/es/core-technology/database-validation/overview.md)
* [Códigos de resultado](https://docs.didit.me/es/core-technology/database-validation/database-validation-outcome-codes.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.