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

# Verifica DNI Argentina (RENAPER) - API

> Verifica DNI in Argentina (RENAPER) con Didit: controllo su database ufficiale. A consumo da $0.20, senza contratti né minimi.

Verifica il DNI argentino rispetto al registro anagrafico ufficiale RENAPER, con confronto facciale biometrico rispetto alla foto archiviata. Copertura del 100% della popolazione. Didit espone questo servizio tramite `POST /v3/database-validation/`, così puoi verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di corrispondenza normalizzati. Formato di input: `document_number` accetta il DNI argentino (7-8 cifre, prefisso M/F facoltativo).

## Copertura

* **Copertura:** 100%
* **Paese:** Argentina
* **ID servizio:** `arg_renaper`
* **Dominio dati:** Identità
* **Categoria:** NationalIDRegistry

RENAPER è il registro che emette ogni DNI argentino, quindi ogni numero di DNI è presente negli archivi, compresi i DNI rilasciati a residenti stranieri. Il confronto facciale mette a confronto il selfie con la foto che RENAPER conserva per quel DNI.

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `document_number` | Sì | `11111111` |
| `selfie` | Sì | `@./selfie.jpg` |
| `gender` | Sì | `M` |
| `first_name` | No | `John` |
| `last_name` | No | `Doe` |
| `date_of_birth` | No | `1990-01-01` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `document_number`, `selfie`, `gender`
* **Input facoltativi:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consenso:** Non richiesto
* **Disponibilità nel workflow:** Disponibile nel workflow
* **Copertura:** 100%
* **Prezzo:** \$0.20 per query riuscita

## Parametri del body

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

Codice paese ISO 3166-1 alpha-3 per questo servizio di database.

Esempio: `ARG`

**services** `string` *required* (default: arg\_renaper)

Array contenente l'ID di questo servizio. Specificare il servizio limita la richiesta a questo database specifico.

Esempio: `arg_renaper`

**document\_number** `string` *required* (default: 11111111)

Numero del documento estratto o fornito dall'utente.

Esempio: `11111111`

**selfie** `file` *required*

File immagine del selfie da caricare per la validazione biometrica su database. Formati accettati: JPEG, PNG o WebP.

Esempio: `@./selfie.jpg`

**gender** `string` *required* (default: M)

Valore del genere, quando richiesto dal database.

Valori consentiti: `M` (maschio), `F` (femmina), `X` (altro o sconosciuto).

Esempio: `M`

**first\_name** `string`

Nome da validare.

Esempio: `John`

**last\_name** `string`

Cognome da validare.

Esempio: `Doe`

**date\_of\_birth** `string`

Data di nascita nel formato `YYYY-MM-DD`.

Esempio: `1990-01-01`

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

Il tuo riferimento utente stabile per questa persona, ad esempio il tuo ID utente interno. Didit lo utilizza per collegare le verifiche autonome allo stesso utente finale e ridurre i falsi rilevamenti di duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* DNI argentino (7-8 cifre, prefisso M/F facoltativo)
* `document_number` deve essere lungo 7-9 caratteri.
* `document_number` deve corrispondere a `[MFmf]?\d{7,8}`.

## Come effettuare la chiamata

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=ARG" \
  -F "services=arg_renaper" \
  -F "vendor_data=user-1234" \
  -F "document_number=11111111" \
  -F "selfie=@./selfie.jpg" \
  -F "gender=M"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="ARG",
    services=["arg_renaper"],
    document_number="11111111",
    gender="M",
    vendor_data="user-1234",
    selfie=open("selfie.jpg", "rb"),
)
print(result)
```

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

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

const result = await didit.databaseValidation.validate({
  issuing_state: "ARG",
  services: ["arg_renaper"],
  document_number: "11111111",
  gender: "M",
  vendor_data: "user-1234",
  selfie: await fileFromPath("selfie.jpg"),
});
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:   "ARG",
	Services:       didit.Some([]string{"arg_renaper"}),
	DocumentNumber: didit.String("11111111"),
	Gender:         didit.Some(didit.DatabaseValidationValidateParamsGender("M")),
	VendorData:     didit.String("user-1234"),
	Selfie:         didit.Some(didit.FileFromPath("selfie.jpg")),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
import java.nio.file.Path;
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("ARG")
        .services(List.of("arg_renaper"))
        .documentNumber("11111111")
        .gender(DatabaseValidationValidateParams.Gender.of("M"))
        .vendorData("user-1234")
        .selfie(Path.of("selfie.jpg"))
        .build());
System.out.println(result);
```

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

require 'vendor/autoload.php';

use Didit\DiditClient;
use Didit\File;

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

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'ARG',
    'services' => ['arg_renaper'],
    'document_number' => '11111111',
    'gender' => 'M',
    'vendor_data' => 'user-1234',
    'selfie' => File::fromPath('selfie.jpg'),
]);
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: "ARG",
  services: ["arg_renaper"],
  document_number: "11111111",
  gender: "M",
  vendor_data: "user-1234",
  selfie: Pathname("selfie.jpg")
)
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 = "ARG",
    Services = new string[] { "arg_renaper" },
    DocumentNumber = "11111111",
    Gender = new DatabaseValidationValidateParamsGender("M"),
    VendorData = "user-1234",
    Selfie = FileUpload.FromPath("selfie.jpg"),
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è realmente accaduto, distinguendo, ad esempio, una reale mancata corrispondenza biometrica (`BIOMETRIC_NO_MATCH`) da un selfie che non è stato possibile leggere (`BIOMETRIC_IMAGE_UNUSABLE`). Lo `status` mostrato è lo stato predefinito della funzionalità; le tue [azioni Partial Match / No Match](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) configurate possono sostituirlo.

**`MATCH`**: Il registro ha confermato l'identità e tutti i campi verificati corrispondono.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "ARG",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "face_match_score": "92",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "tax_id": "SAMPLE-12345",
        "tax_id_type": "SAMPLE-12345"
      },
      "validation": {
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`NO_MATCH`**: Il registro non ha restituito alcuna corrispondenza per i dati inviati.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_NO_MATCH`**: Il punteggio di confronto facciale è inferiore alla soglia di accettazione, quindi il selfie non appartiene alla stessa persona della foto del registro.

```json 200 OK — BIOMETRIC_NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_NO_MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_IMAGE_UNUSABLE`**: Il selfie non può essere elaborato (vuoto, senza volto, di bassa qualità, oppure il registro non è riuscito a leggerlo). Chiedi all'utente di rifare il selfie.

```json 200 OK — BIOMETRIC_IMAGE_UNUSABLE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_IMAGE_UNUSABLE",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

## Dati restituiti

I campi esatti esposti in `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `arg_renaper` documenta attualmente questa struttura normalizzata:

* `date_of_birth`
* `face_match_score`
* `first_name`
* `full_name`
* `identification_number`
* `last_name`
* `tax_id`
* `tax_id_type`

## Prezzi e SLA

Argentina: le query di verifica del DNI (RENAPER) vengono fatturate solo quando Didit riceve un risultato conclusivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.20 USD.
* **Fatturazione:** per query riuscita. Non viene addebitato alcun costo quando il registro non è raggiungibile, quando mancano campi obbligatori o quando la richiesta viene rifiutata prima di raggiungere la fonte.
* **Latenza:** p95 tipico inferiore a 2 s.
* **Disponibilità:** 99.9% per trimestre lato Didit; la disponibilità della fonte a valle varia in base al paese e al dataset.

## Puntuación de coincidencia facial

`face_match_score` es la similitud que RENAPER calcula entre el selfie y la foto registrada del DNI, enviada como un número entero de 0 a 100 dentro de una cadena, por ejemplo `"92"`. No es una probabilidad entre 0 y 1.

La verificación devuelve `BIOMETRIC_NO_MATCH` cuando RENAPER indica que el rostro no coincide, o cuando la puntuación es inferior a 50. Con 50 o más, el rostro se acepta y luego se comparan el nombre y la fecha de nacimiento registrados con los datos que enviaste.

La foto registrada puede tener varios años, así que un usuario legítimo puede obtener una puntuación baja tras un cambio importante de apariencia. Considera enviar `BIOMETRIC_NO_MATCH` a revisión manual en lugar de rechazarlo directamente, con las [acciones de Partial Match / No Match](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md).

## Cuando RENAPER no responde

Si no se puede contactar con RENAPER o responde con un error, el resultado es `REGISTRY_UNAVAILABLE`: no se verificó nada sobre la persona y la llamada no se factura. La misma solicitud puede tener éxito si la reintentas más tarde. Consulta [Códigos de resultado](https://docs.didit.me/it/core-technology/database-validation/database-validation-outcome-codes.md) para saber cómo gestionarlo.

## Documentos que lee un flujo de verificación

Dentro de un flujo de verificación, el número de DNI y el género provienen del paso de Verificación de identidad, que lee la tarjeta DNI argentina y el DNI digital. Los residentes extranjeros tienen la misma tarjeta DNI y se verifican de la misma manera.

El DNI antiguo en formato libreta (*libreta*) no es un documento admitido por la Verificación de identidad, así que un usuario que solo tenga ese documento no puede completar ese paso. Aun así, puedes consultar directamente su número de DNI con `POST /v3/database-validation/`.

## Uso en un flujo de verificación

Añade el servicio a un paso de Validación de base de datos después de la Verificación de identidad. Por ejemplo, con [`POST /v3/workflows/`](https://docs.didit.me/it/management-api/workflows/create):

```json theme={null}
{
  "workflow_label": "Argentina KYC with RENAPER",
  "features": [
    {"feature": "OCR"},
    {"feature": "LIVENESS", "config": {"face_liveness_method": "PASSIVE"}},
    {
      "feature": "DATABASE_VALIDATION",
      "config": {"database_validation_countries": {"ARG": {"services": ["arg_renaper"]}}}
    }
  ]
}
```

Si el flujo tiene un paso de Prueba de vida antes, RENAPER compara el selfie en vivo. Sin ese paso, Didit envía en su lugar el retrato impreso en el documento de identidad, lo que confirma la foto del documento pero no que la persona frente a la cámara sea su titular. Un ID de servicio que el flujo no puede ejecutar se rechaza con un `400` que lo nombra, de modo que el paso nunca se guarda sin la verificación que pediste. Consulta [Configuración de funciones del flujo de verificación](https://docs.didit.me/it/management-api/workflows/feature-configs.md#validazione-su-database) para ver todos los ajustes de Validación de base de datos.

## Seguir leyendo

* [Visión general de Validación de base de datos en Argentina](https://docs.didit.me/api-reference/database-validation/argentina.md)
* [Visión general de Validación de base de datos](https://docs.didit.me/it/core-technology/database-validation/overview.md)
* [Códigos de resultado](https://docs.didit.me/it/core-technology/database-validation/database-validation-outcome-codes.md)


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