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

# Vérification DNI (RENAPER) Argentine - API Didit

> Vérification DNI (RENAPER) en Argentine via Didit : base de données officielle. Dès $0.20 par appel, sans contrat ni minimum.

Vérifie le DNI argentin auprès du registre d'état civil officiel RENAPER, avec une correspondance faciale biométrique par rapport à la photo enregistrée. Couverture de 100% de la population. Didit expose ce service via `POST /v3/database-validation/` afin de vérifier les données soumises auprès de la source faisant autorité et de recevoir des résultats de correspondance normalisés. Format de saisie : `document_number` accepte le DNI argentin (7 à 8 chiffres, préfixe M/F facultatif).

## Couverture

* **Couverture :** 100%
* **Pays :** Argentine
* **Identifiant du service :** `arg_renaper`
* **Domaine de données :** Identité
* **Catégorie :** NationalIDRegistry

RENAPER est le registre qui délivre chaque DNI argentin. Chaque numéro de DNI figure donc dans ses fichiers, y compris les DNI délivrés aux résidents étrangers. La correspondance faciale compare le selfie à la photo que RENAPER détient pour ce DNI.

## Entrées

| Champ | Obligatoire | Exemple |
| - | -: | - |
| `document_number` | Oui | `11111111` |
| `selfie` | Oui | `@./selfie.jpg` |
| `gender` | Oui | `M` |
| `first_name` | Non | `John` |
| `last_name` | Non | `Doe` |
| `date_of_birth` | Non | `1990-01-01` |
| `vendor_data` | Non | `user-1234` |

* **Entrées obligatoires :** `document_number`, `selfie`, `gender`
* **Entrées facultatives :** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consentement :** non requis
* **Disponibilité dans le workflow :** disponible dans un workflow
* **Couverture :** 100%
* **Prix :** \$0.20 par requête réussie

## Paramètres du corps de requête

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

Code pays ISO 3166-1 alpha-3 de ce service de base de données.

Exemple : `ARG`

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

Tableau contenant l'identifiant de ce service. Épingler le service limite la requête à cette base de données précise.

Exemple : `arg_renaper`

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

Numéro de document extrait ou fourni par l'utilisateur.

Exemple : `11111111`

**selfie** `file` *required*

Fichier image de selfie à téléverser pour la validation biométrique en base de données. Formats acceptés : JPEG, PNG ou WebP.

Exemple : `@./selfie.jpg`

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

Valeur du genre, lorsque la base de données l'exige.

Valeurs autorisées : `M` (homme), `F` (femme), `X` (autre ou inconnu).

Exemple : `M`

**first\_name** `string`

Prénom à valider.

Exemple : `John`

**last\_name** `string`

Nom de famille à valider.

Exemple : `Doe`

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

Date de naissance au format `YYYY-MM-DD`.

Exemple : `1990-01-01`

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

Votre référence utilisateur stable pour cette personne, par exemple votre identifiant utilisateur interne. Didit s'en sert pour relier les vérifications autonomes au même utilisateur final et réduire le bruit de détection des doublons.

Exemple : `user-1234`

## Règles de saisie et notes de validation

* DNI argentin (7 à 8 chiffres, préfixe M/F facultatif)
* `document_number` doit comporter entre 7 et 9 caractères.
* `document_number` doit correspondre à `[MFmf]?\d{7,8}`.

## Comment l'appeler

```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));
```

Chaque appel réussi renvoie un HTTP `200`. Le champ **`outcome_code`** indique ce qui s'est réellement passé, en distinguant par exemple une véritable non-correspondance biométrique (`BIOMETRIC_NO_MATCH`) d'un selfie impossible à lire (`BIOMETRIC_IMAGE_UNUSABLE`). Le `status` affiché est le statut par défaut de la fonctionnalité ; vos [actions Partial Match / No Match](https://docs.didit.me/fr/core-technology/database-validation/database-validation-warnings.md) configurées peuvent le remplacer.

**`MATCH`** : le registre a confirmé l'identité, et chaque champ vérifié correspond.

```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`** : le registre n'a renvoyé aucune correspondance pour les données soumises.

```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`** : le score de correspondance faciale était inférieur au seuil d'acceptation : le selfie ne correspond pas à la personne figurant sur la photo du registre.

```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`** : le selfie n'a pas pu être traité (vide, sans visage, qualité insuffisante, ou registre incapable de le lire). Invitez l'utilisateur à reprendre le 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"
      }
    }
  ]
}
```

## Données renvoyées

Les champs exacts présents dans `source_data` dépendent de ce que renvoie le registre. L'exemple généré pour `arg_renaper` documente actuellement cette forme normalisée :

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

## Tarifs et SLA

Argentine : les requêtes de vérification du DNI (RENAPER) ne sont facturées que lorsque Didit reçoit un résultat concluant de la source de validation.

* **Prix par appel :** \$0.20 USD.
* **Facturation :** par requête réussie. Vous n'êtes pas facturé lorsque le registre est injoignable, lorsque des champs obligatoires manquent ou lorsque la requête est rejetée avant d'atteindre la source.
* **Latence :** p95 typique \< 2 s.
* **Disponibilité :** 99.9% par trimestre côté Didit ; la disponibilité des sources en aval varie selon le pays et le jeu de données.

## Score de correspondance faciale

`face_match_score` est la similarité calculée par RENAPER entre le selfie et la photo enregistrée pour le DNI. Il est transmis sous la forme d'un nombre entier de 0 à 100, dans une chaîne, par exemple `"92"`. Ce n'est pas une probabilité comprise entre 0 et 1.

La vérification renvoie `BIOMETRIC_NO_MATCH` lorsque RENAPER indique que le visage ne correspond pas, ou lorsque le score est inférieur à 50. À partir de 50, le visage est accepté, et le nom et la date de naissance enregistrés sont alors comparés aux données que vous avez transmises.

La photo enregistrée peut dater de plusieurs années. Un utilisateur légitime peut donc obtenir un score faible après un changement important de son apparence. Envisagez de soumettre `BIOMETRIC_NO_MATCH` à un examen manuel plutôt que de le refuser directement, avec les [actions Partial Match / No Match](https://docs.didit.me/fr/core-technology/database-validation/database-validation-warnings.md).

## Quand RENAPER ne répond pas

Si RENAPER est injoignable ou répond par une erreur, le résultat est `REGISTRY_UNAVAILABLE` : aucune information sur la personne n'a été vérifiée, et l'appel n'est pas facturé. La même requête peut aboutir si vous la renvoyez plus tard. Consultez [Codes de résultat](https://docs.didit.me/fr/core-technology/database-validation/database-validation-outcome-codes.md) pour savoir comment la traiter.

## Documents lus par un workflow

Dans un workflow, le numéro de DNI et le genre proviennent de l'étape Vérification d'identité, qui lit la carte DNI argentine et le DNI numérique. Les résidents étrangers disposent de la même carte DNI et sont vérifiés de la même manière.

Le DNI sous forme de livret (*libreta*) n'est pas un document pris en charge par la Vérification d'identité : un utilisateur qui ne possède que ce document ne peut pas terminer cette étape. Vous pouvez tout de même contrôler directement son numéro de DNI avec `POST /v3/database-validation/`.

## Utilisation dans un workflow

Ajoutez le service à une étape Validation en base de données après la Vérification d'identité. Par exemple, avec [`POST /v3/workflows/`](https://docs.didit.me/fr/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 une étape de détection du vivant la précède, RENAPER compare le selfie en direct. Sans elle, Didit envoie à la place le portrait imprimé sur le document d'identité. Cela confirme la photo du document, mais pas que la personne face à la caméra en est bien le titulaire. Un identifiant de service que le workflow ne peut pas exécuter est rejeté avec un code `400` qui le nomme : l'étape n'est donc jamais enregistrée sans le contrôle demandé. Consultez [Configurations des fonctionnalités du workflow](https://docs.didit.me/fr/management-api/workflows/feature-configs.md#validation-en-base-de-données) pour tous les paramètres de Validation en base de données.

## Pour aller plus loin

* [Vue d'ensemble de Validation en base de données pour l'Argentine](https://docs.didit.me/api-reference/database-validation/argentina.md)
* [Vue d'ensemble de Validation en base de données](https://docs.didit.me/fr/core-technology/database-validation/overview.md)
* [Codes de résultat](https://docs.didit.me/fr/core-technology/database-validation/database-validation-outcome-codes.md)


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