Reconocimiento biométrico para validación de cedula

Reconocimiento biométrico para validación de cedula - Colombia

Lets integrate Reconocimiento biométrico para validación de cedula - Colombia 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-co/"
payload = {'emotion': 'neutral', 'back_img': 'https://apitude.co/example/not/real/url/cedula_reverso.jpg', 'front_img': 'https://apitude.co/example/not/real/url/cedula_frente.jpg', 'selfie_img': 'https://apitude.co/example/not/real/url/cedula_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://apitude.co/example/not/real/url/cedula_selfie_neutral.jpg\", \"front_img\": \"https://apitude.co/example/not/real/url/cedula_frente.jpg\", \"back_img\": \"https://apitude.co/example/not/real/url/cedula_reverso.jpg\"}"
RequestBody body = RequestBody.create(mediaType, payload);
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/face-id-co/")
  .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://apitude.co/example/not/real/url/cedula_selfie_neutral.jpg", "front_img": "https://apitude.co/example/not/real/url/cedula_frente.jpg", "back_img": "https://apitude.co/example/not/real/url/cedula_reverso.jpg"});
var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/face-id-co/", 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-co/"
method := "POST"
data := "{\"emotion\": \"neutral\", \"selfie_img\": \"https://apitude.co/example/not/real/url/cedula_selfie_neutral.jpg\", \"front_img\": \"https://apitude.co/example/not/real/url/cedula_frente.jpg\", \"back_img\": \"https://apitude.co/example/not/real/url/cedula_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 petición misma, codificadas como cadenas en base64
Example of Colombia National ID Photo


import requests
url = "https://apitude.co/api/v1.0/requests/face-id-co/"
payload = {'emotion': 'neutral', 'back_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=', 'front_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=', 'selfie_img': '/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN 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 ENCODEDIN BASE64...H/9k=\", \"front_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=\", \"back_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=\"}"
RequestBody body = RequestBody.create(mediaType, payload);
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/face-id-co/")
  .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 ENCODEDIN BASE64...H/9k=", "front_img": "/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=", "back_img": "/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k="});
var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/face-id-co/", 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-co/"
method := "POST"
data := "{\"emotion\": \"neutral\", \"selfie_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=\", \"front_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN BASE64...H/9k=\", \"back_img\": \"/9j/4AAQSkZJR...YOUR IMAGE ENCODEDIN 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-co/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-co/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-co/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-co/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-co/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": {
            "birthday": "1972-03-22",
            "date_expedition": "1990-08-15",
            "document_number": "888888881"
         },
         "face_match": true,
         "front_info": {
            "gender": "male",
            "emotion": {
               "fear": 0.0,
               "anger": 0.0,
               "disgust": 0.0,
               "neutral": 0.933,
               "sadness": 0.066,
               "contempt": 0.0,
               "surprise": 0.0,
               "happiness": 0.0
            },
            "process_id": "33d77916-c6e1-46b5-90b5-b349a244906c",
            "face_rectangle": {
               "top": 334,
               "left": 656,
               "right": 825,
               "width": 169,
               "bottom": 503,
               "height": 169
            },
            "document_number": "888888881"
         },
         "selfie_info": {
            "gender": "female",
            "emotion": {
               "fear": 0.0,
               "anger": 0.0,
               "disgust": 0.0,
               "neutral": 0.861,
               "sadness": 0.022,
               "contempt": 0.002,
               "surprise": 0.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
            }
         },
         "registraduria": {
            "area": "BOLIVAR",
            "city": "CARTAGENA",
            "name": "JUAN PEREZ",
            "status": "VIGENTE",
            "resolution": "",
            "date_resolution": "2020-05-30"
         },
         "liveness_check": true,
         "face_match_score": 0.84552,
         "national_registry": true
      },
      "error": "",
      "end_at": "2020-11-01 06:46:37.602006",
      "status": 200,
      "message": "successful",
      "queried_by": "YOUR-USER",
      "service_name": "face-id-co"
   },
   "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-co.
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 (código de barras) de la imagen de identificación nacional colombiana enviada.
data.front_info: Este campo es un diccionario con la información OCR de la cara frontal de la imagen de identificación nacional colombiana 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 de la identificación nacional de Colombia. Un valor de verdadero significaría que ambos son la misma persona, un valor de falso significaría lo contrario.
data.registraduria Este campo es un diccionario con la información de la cedula colombiana dentro de la base de datos del Registro Nacional del Estado Civil de Colombia (Registraduría).
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 cara en la imagen frontal de la identificación nacional colombiana son idénticas.
data.national_registry Este campo es un booleano con un valor de verdadero si la cédula nacional colombiana fue validada por el Registro Nacional del Estado Civil de Colombia.
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 validad 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 de la cedula Colombiana (lado de la imagen y nombre) y una foto posterior de la cedula Colombiana (lado del codigo de barras) 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 la cedula son de la misma persona.
La cedula se encuentra activa en la Registraduría Nacional del Estado Civil de Colombia

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 forences de la imagen de la selfie y de la imagen del documento (e.g. sexo, edad, raza, etc.) y las comparan contra la base de datos de la Registraduría Nacional de Colombia y de otras fuentes privadas a las que Apitude tiene acceso.
Se verifica la autenticidad de los códigos de barras formato PDF417 y MRZ de la cédula contra la información impresa en el texto dentro de las imágenes del documento y contra la base de datos de la Registraduría Nacional de Colombia
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 valida o no
Si la imagen de la selfie y la cara frontal de la cedula son de la misma persona
Si la persona en la selfie esta realizando la emoción enviada
Si la cedula se encuentra activa y valida en la Registraduría Nacional del Estado Civil de Colombia o no
La información del lado frontal de la cedula
La información del lado posterior de la cedula
La informacion de la cedula en la registraduría

Who can you query using this service?:

This service (face-id-co) 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