Servicio de validacion de identidad

Servicio de validacion de identidad - Chile

Lets integrate Servicio de validacion de identidad - Chile 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/identity-cl/"
payload = {'document_number': '8888888-1'}
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 = "{\"document_number\": \"8888888-1\"}"
RequestBody body = RequestBody.create(mediaType, payload);
Request request = new Request.Builder()
  .url("https://apitude.co/api/v1.0/requests/identity-cl/")
  .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({"document_number": "8888888-1"});
var requestOptions = {
  method: 'POST',
  headers: myHeaders,
  body: raw,
  redirect: 'follow'
};
fetch("https://apitude.co/api/v1.0/requests/identity-cl/", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));


url := "https://apitude.co/api/v1.0/requests/identity-cl/"
method := "POST"
data := "{\"document_number\": \"8888888-1\"}"
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/identity-cl/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/identity-cl/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/identity-cl/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/identity-cl/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/identity-cl/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": {
         "age": 58,
         "rut": "8888888-1",
         "name": "JHON WICK",
         "found": true,
         "deceased": false,
         "addresses": [
            {
               "city": "SANTIAGO",
               "date": "2023-01-04",
               "type": "BUSINESS",
               "address": "AV. ANDRES BELLO 2425",
               "commune": "SANTIAGO CENTRO"
            },
            {
               "city": "NY",
               "date": "1999-11-04",
               "type": "RESIDENTIAL",
               "address": "121 MILL NECK",
               "commune": "LONG ISLAND"
            }
         ],
         "date_of_birth": "1964-10-12",
         "phone_numbers": [
            {
               "type": "PERSONAL",
               "number": "5555555",
               "area_code": "02"
            },
            {
               "type": "PERSONAL",
               "number": "1946020",
               "area_code": "315"
            }
         ],
         "email_addresses": [
            "jhon.wick@gmail.com",
            "the_excommunicado@hotmail.com"
         ]
      },
      "error": "",
      "end_at": "2023-01-30 21:54:06.453355",
      "status": 200,
      "message": "successful",
      "queried_by": "YOUR-USER",
      "service_name": "identity-cl"
   },
   "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 identity-cl.
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.age: La edad es un entero con la edad de la persona (número) denominada en años.
data.found: La variable es un booleano . Los valores posibles son:
- true : El código RUT se encuentra con información en la base de datos de personas.
- false : El código RUT no se encuentra con información en la base de datos de personas.
data.deceased: La variable es un booleano . Los valores posibles son:
- true : La persona dueña del código RUT ha fallecido.
- false : La persona dueña del código RUT se encuentra con vida.
data.addresses: La variable es una lista de objetos que representan una direccion previa del código RUT. La lista puede tener cero o más elementos. Los campos de un objeto son:
- data.addresses[1].city : La ciudad donde se reporta la dirección.
- data.addresses[1].date : La fecha en formato YYYY-MM-DD cuando se reportó la dirección.
- data.addresses[1].type : El tipo de dirección. Los valores posibles son: BUSINESS para direcciones comerciales y RESIDENTIAL para direcciones no comerciales.
- data.addresses[1].address : La dirección completa reportada.
- data.addresses[1].commune : La comuna donde se reporta la dirección.
data.date_of_birth: El fecha de nacimiento es una cadena con el formato YYYY-MM-DD.
data.phone_numbers: La variable es una lista de objetos que representan un número telefonico previo del código RUT. La lista puede tener cero o más elementos. Los campos de un objeto son:
- data.phone_numbers[1].area_code : El código de area dentro del pais reportado. Es una cadena
- data.phone_numbers[1].type : El tipo de dirección. Los valores posibles son: BUSINESS para direcciones comerciales y PERSONAL para direcciones no comerciales.
- data.phone_numbers[1].number : El número de telefono reportado. Es una cadena . Tipicamente, se debe concatenar código de area número de telefono para obtener el valor completo.
data.phone_numbers: La variable es una lista de objetos tipo cadena que representan un email previamente reportado para el código RUT.

About this service

Este servicio permite obtener, a traves de API, la información de de validación de identidad que obtiene Apitude a traves de nuestra serie de partners afiliados. Esta API recibe un numero de RUT chileno y retorna la información requerida para validar los datos de un usuario, como por ejemplo las direcciones, los nombres, los emails y los numeros de telefono.

Who can you query using this service?:

This service (identity-cl) 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