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

# Verificació de DNI a Argentina (RENAPER) - API

> Verificació de DNI a Argentina via RENAPER amb Didit: consulta a la base de dades oficial. Des de $0.20 per verificació, sense contractes ni mínims.

Verifica el DNI argentí amb el registre civil oficial de RENAPER, amb coincidència facial biomètrica amb la fotografia registrada. 100% de cobertura de la població. Didit ofereix aquest servei a través de `POST /v3/database-validation/` perquè puguis verificar les dades enviades amb la font autoritativa i rebre resultats de coincidència normalitzats. Format d'entrada: `document_number` accepta el DNI argentí (7-8 dígits, amb prefix M/F opcional).

## Cobertura

* **Cobertura:** 100%
* **País:** Argentina
* **ID del servei:** `arg_renaper`
* **Àmbit de dades:** Identitat
* **Categoria:** NationalIDRegistry

RENAPER és el registre que emet tots els DNI argentins, de manera que tots els números de DNI consten en el registre, inclosos els DNI emesos a residents estrangers. La coincidència facial compara la selfie amb la fotografia que RENAPER té per a aquest DNI.

## Entrades

| Camp | Obligatori | Exemple |
| - | -: | - |
| `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` |

* **Entrades obligatòries:** `document_number`, `selfie`, `gender`
* **Entrades opcionals:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consentiment:** No cal
* **Disponibilitat al flux de treball:** Disponible al flux de treball
* **Cobertura:** 100%
* **Preu:** \$0.20 per consulta satisfactòria

## Paràmetres del cos

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

Codi de país ISO 3166-1 alpha-3 per a aquest servei de base de dades.

Exemple: `ARG`

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

Matriu que conté l'ID d'aquest servei. Fixar el servei manté la sol·licitud limitada a aquesta base de dades exacta.

Exemple: `arg_renaper`

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

Número de document extret de l'usuari o proporcionat per l'usuari.

Exemple: `11111111`

**selfie** `file` *required*

Fitxer d'imatge de la selfie que cal pujar per a la validació biomètrica en bases de dades. Formats acceptats: JPEG, PNG o WebP.

Exemple: `@./selfie.jpg`

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

Valor de gènere, quan la base de dades el requereix.

Valors permesos: `M` (home), `F` (dona), `X` (altre o desconegut).

Exemple: `M`

**first\_name** `string`

Nom de pila que cal validar.

Exemple: `John`

**last\_name** `string`

Cognoms que cal validar.

Exemple: `Doe`

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

Data de naixement en format `YYYY-MM-DD`.

Exemple: `1990-01-01`

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

La teva referència estable d'usuari per a aquesta persona, com ara el teu ID intern d'usuari. Didit l'utilitza per enllaçar les comprovacions independents amb el mateix usuari final i reduir el soroll de detecció de duplicats.

Exemple: `user-1234`

## Regles d'entrada i notes de validació

* DNI argentí (7-8 dígits, amb prefix M/F opcional)
* `document_number` ha de tenir entre 7 i 9 caràcters.
* `document_number` ha de coincidir amb `[MFmf]?\d{7,8}`.

## Com fer la crida

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

Cada crida satisfactòria retorna HTTP `200`. El camp **`outcome_code`** indica què ha passat realment, distingint, per exemple, una no coincidència biomètrica real (`BIOMETRIC_NO_MATCH`) d'una selfie que no s'ha pogut llegir (`BIOMETRIC_IMAGE_UNUSABLE`). L'`status` que es mostra és l'estat per defecte de la funcionalitat; les [accions de Partial Match / No Match](https://docs.didit.me/ca/core-technology/database-validation/database-validation-warnings.md) que hagis configurat poden substituir-lo.

**`MATCH`**: El registre ha confirmat la identitat i tots els camps comprovats coincideixen.

```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`**: El registre no ha retornat cap coincidència per a les dades enviades.

```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`**: La puntuació de coincidència facial és inferior al llindar d'acceptació; la persona de la selfie no és la mateixa que la de la fotografia del 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`**: No s'ha pogut processar la selfie (buida, sense cara, de baixa qualitat, o el registre no l'ha pogut llegir). Demana a l'usuari que torni a fer la 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"
      }
    }
  ]
}
```

## Dades retornades

Els camps exactes que apareixen a `source_data` depenen del que retorni el registre. L'exemple generat per a `arg_renaper` documenta actualment aquesta forma normalitzada:

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

## Preus i SLA

Argentina: les consultes de verificació de DNI (RENAPER) es facturen només quan Didit rep un resultat concloent de la font de validació.

* **Preu per crida:** \$0.20 USD.
* **Facturació:** per consulta satisfactòria. No es cobra quan el registre no és accessible, quan falten camps obligatoris o quan la sol·licitud es rebutja abans d'arribar a la font.
* **Latència:** p95 típic \< 2 s.
* **Disponibilitat:** 99.9% per trimestre per part de Didit; la disponibilitat de la font dependent varia segons el país i el conjunt de dades.

## Puntuació de coincidència facial

`face_match_score` és la similitud que RENAPER calcula entre la selfie i la fotografia registrada del DNI. S'envia com a nombre enter de 0 a 100 dins d'una cadena de text, per exemple `"92"`. No és una probabilitat entre 0 i 1.

La verificació retorna `BIOMETRIC_NO_MATCH` quan RENAPER indica que la cara no coincideix, o quan la puntuació és inferior a 50. A partir de 50 la cara s'accepta i després es comparen el nom i la data de naixement registrats amb les dades que has enviat.

La fotografia registrada pot tenir diversos anys, així que un usuari legítim pot obtenir una puntuació baixa si el seu aspecte ha canviat molt. Considera enviar `BIOMETRIC_NO_MATCH` a revisió manual en lloc de rebutjar-lo directament, amb les [accions de coincidència parcial / sense coincidència](https://docs.didit.me/ca/core-technology/database-validation/database-validation-warnings.md).

## Quan RENAPER no respon

Si no es pot connectar amb RENAPER o respon amb un error, el resultat és `REGISTRY_UNAVAILABLE`: no s'ha comprovat res sobre la persona i no se't factura la crida. La mateixa sol·licitud pot reeixir si la reintentes més tard. Consulta [Codis de resultat](https://docs.didit.me/ca/core-technology/database-validation/database-validation-outcome-codes.md) per saber com gestionar-ho.

## Documents que llegeix un flux de treball

Dins d'un flux de treball, el número de DNI i el gènere provenen del pas de Verificació d'identitat, que llegeix la targeta DNI argentina i el DNI digital. Els residents estrangers tenen la mateixa targeta DNI i es verifiquen de la mateixa manera.

El DNI antic en format llibreta (*libreta*) no és un document compatible amb la Verificació d'identitat, així que un usuari que només en tingui un no pot completar aquest pas. Tot i això, pots comprovar directament el número de DNI amb `POST /v3/database-validation/`.

## Utilitza-ho en un flux de treball

Afegeix el servei a un pas de Validació en bases de dades després de la Verificació d'identitat. Per exemple, amb [`POST /v3/workflows/`](https://docs.didit.me/ca/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 hi ha un pas de Prova de vida abans, RENAPER compara la selfie en directe. Si no n'hi ha, Didit envia en lloc de la selfie en directe el retrat imprès al document d'identitat, que confirma la fotografia del document però no que la persona davant la càmera sigui el seu titular. Un ID de servei que el flux de treball no pot executar es rebutja amb un `400` que l'esmenta, de manera que el pas mai no es desa sense la comprovació que has demanat. Consulta [Configuració de funcionalitats del flux de treball](https://docs.didit.me/ca/management-api/workflows/feature-configs.md#validació-en-bases-de-dades) per veure totes les opcions de Validació en bases de dades.

## Continua llegint

* [Visió general de la Validació en bases de dades d'Argentina](https://docs.didit.me/api-reference/database-validation/argentina.md)
* [Visió general de la Validació en bases de dades](https://docs.didit.me/ca/core-technology/database-validation/overview.md)
* [Codis de resultat](https://docs.didit.me/ca/core-technology/database-validation/database-validation-outcome-codes.md)


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