Reconocimiento biométrico para validación de INE/IFE

Reconocimiento biométrico para validación de INE/IFE - México

Lets integrate Reconocimiento biométrico para validación de INE/IFE - México in your system. First, get your Apitude API key, then send a POST request to Apitude... And that's it!.

Get API Access


import requests
url = "https://apitude.co/api/v1.0/requests/face-id-mx/"
payload = {'emotion': 'neutral', 'back_img': 'https://example.com/not/real/url/ine_reverso.jpg', 'front_img': 'https://example.com/not/real/url/ine_frente.jpg', 'selfie_img': 'https://example.com/not/real/url/ine_selfie_neutral.jpg'}
headers = {
    'x-api-key': 'API-KEY',
    'Content-Type': 'application/json'
}
response = requests.post(url, headers=headers, data=payload)
print(response.json())


OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("application/json");
String payload = "{\"emotion\": \"neutral\", \"selfie_img\": \"https://example.com/not/real/url/ine_selfie_neutral.jpg\", \"front_img\": \"https://example.com/not/real/url/ine_frente.jpg\", \"back_img\": \"https://example.com/not/real/url/ine_reverso.jpg\"}"
RequestBody body = RequestBody.create(mediaType, payload);
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/face-id-mx/")
  .method("POST", body)
  .addHeader("x-api-key", "API-KEY")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();


var myHeaders = new Headers();
myHeaders.append("x-api-key", "API-KEY");
myHeaders.append("Content-Type", "application/json");
var raw = JSON.stringify({"emotion": "neutral", "selfie_img": "https://example.com/not/real/url/ine_selfie_neutral.jpg", "front_img": "https://example.com/not/real/url/ine_frente.jpg", "back_img": "https://example.com/not/real/url/ine_reverso.jpg"});
var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/face-id-mx/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


url := "https://apitude.co/api/v1.0/requests/face-id-mx/"
method := "POST"
data := "{\"emotion\": \"neutral\", \"selfie_img\": \"https://example.com/not/real/url/ine_selfie_neutral.jpg\", \"front_img\": \"https://example.com/not/real/url/ine_frente.jpg\", \"back_img\": \"https://example.com/not/real/url/ine_reverso.jpg\"}"
payload := strings.NewReader(data)
client := &http.Client {}
req, err := http.NewRequest(method, url, payload)
if err != nil {
    fmt.Println(err)
}
req.Header.Add("x-api-key", "API-KEY")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
fmt.Println(string(body))

Alternatively, the service also receives the following payload

En este caso, en lugar de URLs, también puedes enviar las imágenes en la petición misma, codificadas como cadenas en base64
Ejemplo de foto de INE/IFE de México


import requests
url = "https://apitude.co/api/v1.0/requests/face-id-mx/"
payload = {'emotion': 'neutral', 'back_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=', 'front_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=', 'selfie_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k='}
headers = {
    'x-api-key': 'API-KEY',
    'Content-Type': 'application/json'
}
response = requests.post(url, headers=headers, data=payload)
print(response.json())


OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("application/json");
String payload = "{\"emotion\": \"neutral\", \"selfie_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\", \"front_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\", \"back_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\"}"
RequestBody body = RequestBody.create(mediaType, payload);
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/face-id-mx/")
  .method("POST", body)
  .addHeader("x-api-key", "API-KEY")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();


var myHeaders = new Headers();
myHeaders.append("x-api-key", "API-KEY");
myHeaders.append("Content-Type", "application/json");
var raw = JSON.stringify({"emotion": "neutral", "selfie_img": "/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=", "front_img": "/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=", "back_img": "/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k="});
var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/face-id-mx/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


url := "https://apitude.co/api/v1.0/requests/face-id-mx/"
method := "POST"
data := "{\"emotion\": \"neutral\", \"selfie_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\", \"front_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\", \"back_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODED IN BASE64...H/9k=\"}"
payload := strings.NewReader(data)
client := &http.Client {}
req, err := http.NewRequest(method, url, payload)
if err != nil {
    fmt.Println(err)
}
req.Header.Add("x-api-key", "API-KEY")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
fmt.Println(string(body))

That POST request should return the following


{
    "message": "Request processed successfully",
    "url": "/api/v1.0/requests/face-id-mx/e0606c19-a32d-410f-b2eb-d57a665677bc/",
    "request_id": "e0606c19-a32d-410f-b2eb-d57a665677bc"
}

This response will contains a unique request ID that you should poll using a GET as follows


import requests
url = "https://apitude.co/api/v1.0/requests/face-id-mx/e0606c19-a32d-410f-b2eb-d57a665677bc/"
headers = {
    'x-api-key': 'API-KEY',
    'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
print(response.json())


OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("application/json");
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/face-id-mx/e0606c19-a32d-410f-b2eb-d57a665677bc/")
  .method("GET")
  .addHeader("x-api-key", "API-KEY")
  .addHeader("Content-Type", "application/json")
  .build();
Response response = client.newCall(request).execute();


var myHeaders = new Headers();
myHeaders.append("x-api-key", "API-KEY");
myHeaders.append("Content-Type", "application/json");
var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/face-id-mx/e0606c19-a32d-410f-b2eb-d57a665677bc/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


url := "https://apitude.co/api/v1.0/requests/face-id-mx/e0606c19-a32d-410f-b2eb-d57a665677bc/"
method := "GET"
client := &http.Client {}
req, err := http.NewRequest(method, url)
if err != nil {
    fmt.Println(err)
}
req.Header.Add("x-api-key", "API-KEY")
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
fmt.Println(string(body))

How does the response looks like?


{
   "result": {
      "data": {
         "face_id": true,
         "back_info": {
            "cic": "ABCDEFGHIJKLM123456",
            "sex": "M",
            "address": "CALLE EJEMPLO 123, COL. CENTRO, 06000, CUAUHTEMOC, CDMX",
            "birth_date": "720322",
            "expiry_date": "301231",
            "nationality": "MEX",
            "document_type": "ID",
            "optional_data": "",
            "document_number": "1234567890",
            "issuing_country": "MEX",
            "optional_data_2": "",
            "composite_check_digit": "0"
         },
         "face_match": true,
         "front_info": {
            "curp": "GALJ720322HDFNNN01",
            "name": "GARC\u00cdA L\u00d3PEZ JUAN",
            "gender": "HOMBRE",
            "emotion": {
               "fear": 0,
               "anger": 0,
               "disgust": 0,
               "neutral": 0.933,
               "sadness": 0.066,
               "contempt": 0,
               "surprise": 0,
               "happiness": 0
            },
            "birthdate": "1972-03-22",
            "voter_key": "GRLPJN72032209H700",
            "ine_number": "1234567890",
            "process_id": "33d77916-c6e1-46b5-90b5-b349a244906c",
            "emission_date": "2020",
            "face_rectangle": {
               "top": 334,
               "left": 656,
               "right": 825,
               "width": 169,
               "bottom": 503,
               "height": 169
            },
            "expiration_date": "2030"
         },
         "selfie_info": {
            "gender": "male",
            "emotion": {
               "fear": 0,
               "anger": 0,
               "disgust": 0,
               "neutral": 0.861,
               "sadness": 0.022,
               "contempt": 0.002,
               "surprise": 0,
               "happiness": 0.114
            },
            "process_id": "399b5bcc-58f9-4700-8304-d5446dd09746",
            "face_rectangle": {
               "top": 115,
               "left": 98,
               "right": 273,
               "width": 175,
               "bottom": 290,
               "height": 175
            }
         },
         "ine_registry": {
            "name": "GARC\u00cdA L\u00d3PEZ JUAN",
            "state": "CDMX",
            "status": "VIGENTE",
            "section": "1234",
            "last_update": "2020-05-30",
            "municipality": "CUAUHTEMOC"
         },
         "liveness_check": true,
         "face_match_score": 0.84552,
         "national_registry": true
      },
      "error": "",
      "end_at": "2023-08-21 06:46:37.602006",
      "status": 200,
      "message": "successful",
      "queried_by": "YOUR-USER",
      "service_name": "face-id-mx"
   },
   "message": "Request completed"
}

Ok, but what does each field in that JSON means?

The general parts:

message:The message is an Apitude generated string with an informational text about the request.
result:The result is contains the main part of the request.
result.error:The error is a string generated by apitude for the request if everything worked it will be blank.
result.message:The message is a string with two options successful or unsuccessful depending of how your request finished.
result.queried_by:The queried_by field is a string that lets you know what user started the request.
result.end_at:The end_at field is a string formatted date that lets you know at what time the request ended in Apitude.
result.service_name:The service_name field is a string that echos the service called. For this service it will always be face-id-mx.
result.status:The status field is a integer that represents whether the service returned data from the input sent in the request. It could be one of the following values:
- 200: The service returned response data for the payload that was sent in the creation of the request.
- 404: The service did not returned data for the payload that was sent in the creation of the request.
- 400: The service did not started because your input was invalid.
- 500: Apitude tried to execute your request, however the service Apitude uses to execute your request was down. Please wait some time and try again, Apitude will not charged you for requests with this code.
Depending on the service, you want it to return different codes. For example, if you are checking the user against a security list to whitelist the user you should look for a 404, because a 200 would mean the user is in fact in the list. Other cases however, like creating objects in the name of a user you want the code to be 200, since it will imply the creation was a success.

The data in the response:

data.selfie_info: Este campo es un diccionario con la información biométrica de la imagen de selfie enviada.
data.back_info: Este campo es un diccionario con la información OCR de la cara posterior (dirección y código QR) de la imagen del INE/IFE mexicano enviada.
data.front_info: Este campo es un diccionario con la información OCR de la cara frontal de la imagen del INE/IFE mexicano enviada.
data.face_match:Este campo es un booleano con la coincidencia entre la imagen de la cara de la selfie y la cara en la imagen frontal del INE/IFE mexicano. Un valor de verdadero significaría que ambos son la misma persona, un valor de falso significaría lo contrario.
data.ine_registry Este campo es un diccionario con la información del INE/IFE mexicano dentro de la base de datos del Instituto Nacional Electoral de México.
data.liveness_check Este campo es un booleano con la coincidencia entre la imagen de la cara de la selfie y la emoción enviada. Un valor de verdadero significaría que la cara en la selfie está ejecutando la emoción enviada como parámetro, un valor de falso significaría lo contrario.
data.face_match_score Este campo es un número decimal con un valor entre 0.0 y 1.0. Un valor de 1.0 significa que la cara en la selfie y la cara en la imagen frontal del INE/IFE mexicano son idénticas.
data.national_registry Este campo es un booleano con un valor de verdadero si el INE/IFE mexicano fue validado por el Instituto Nacional Electoral de México.
data.face_id Este campo es un booleano con un valor de verdadero si los campos data.face_match, data.national_registry y data.liveness_check son todos verdaderos, un valor de falso significaría lo contrario.

About this service

El servicio permite validar una persona por medio de API. Recibe como entrada una emoción, una foto selfie del usuario realizando la emoción seleccionada (Los valores posibles son sorpresa, tristeza, neutralidad, enfado y felicidad), una foto de la parte frontal del INE/IFE mexicano (lado de la foto e información personal) y una foto posterior del INE/IFE (lado de la dirección y código QR) y obtener las siguientes validaciones:

La imagen con la selfie contiene la cara de solamente una persona.
La cara de la persona en la selfie corresponde con el sentimiento enviado.
La cara de la persona en la selfie y la cara en el INE/IFE son de la misma persona.
El INE/IFE se encuentra activo y válido según el Instituto Nacional Electoral (INE) de México

Detalle técnico de las validaciones realizadas:

Para la comparación de la selfie contra la imagen del documento, se realiza un proceso de identificación de características faciales, de los cuales nuestros algoritmos de inteligencia artificial de estado del arte, identifican +300 puntos referenciales en la cara de la selfie y en la foto del documento y realiza la comparación entre ambas.
Nuestros algoritmos de inteligencia artificial extraen características forenses de la imagen de la selfie y de la imagen del documento (e.g. sexo, edad, etc.) y las comparan contra la base de datos del Instituto Nacional Electoral de México y de otras fuentes privadas a las que tenemos acceso.
Se verifica la autenticidad del código QR en el reverso del INE/IFE contra la información impresa en el texto dentro de las imágenes del documento y contra la base de datos del Instituto Nacional Electoral de México
Nuestros algoritmos propietarios de inteligencia artificial de estado del arte, analizan los documentos por adulteraciones dejadas por software de manipulación de imágenes digitales como Photoshop y similares
Nuestros algoritmos de inteligencia artificial realizan detección (Opcional a solicitud del cliente) de imágenes no tomadas directamente desde una cámara fuente
Se realizan validaciones (Opcional a solicitud del cliente) de las selfie / imágenes enviadas contra una serie de bases de datos biométricas de entidades de inteligencia gubernamentales internacionales (Interpol, FBI, CIA, etc)

El servicio retorna en su respuesta:

Si la imagen de la selfie es válida o no
Si la imagen de la selfie y la cara del INE/IFE son de la misma persona
Si la persona en la selfie está realizando la emoción enviada
Si el INE/IFE se encuentra activo y válido según el Instituto Nacional Electoral de México
La información del lado frontal del INE/IFE
La información del lado posterior del INE/IFE
La información del INE/IFE en el registro electoral

Who can you query using this service?:

This service (face-id-mx) is available for you to query individuals only.

Get API Access

Services

Help and support

Pricing

Open Services APIs

Contract Required

Service Pipelines

Biometric Validation