BASE_URL="https://backoffice-hml.idcerberus.com"

TOKEN=$(curl --silent --location "${BASE_URL}/api/token-generate" \
  --header 'Content-Type: application/json' \
  --data '{
    "client": "{client}",
    "secret": "{secret}"
  }' | jq -r '.access_token')

curl --location "${BASE_URL}/api/service-api" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header 'Content-Type: application/json' \
  --data '{
    "service": "SERVICE_PERSON_DATA_ENRICHMENT",
    "cpf": "cpf"
  }'

$baseUrl = "https://backoffice-hml.idcerberus.com"

$tokenResponse = curl.exe --silent --location "$baseUrl/api/token-generate" `
  --header "Content-Type: application/json" `
  --data "{\"client\":\"{client}\",\"secret\":\"{secret}\"}"

$token = ($tokenResponse | ConvertFrom-Json).access_token

curl.exe --location "$baseUrl/api/service-api" `
  --header "Authorization: Bearer $token" `
  --header "Content-Type: application/json" `
  --data "{\"service\":\"SERVICE_PERSON_DATA_ENRICHMENT\",\"cpf\":\"cpf\"}"

const baseUrl = "https://backoffice-hml.idcerberus.com";

async function gerarToken() {
  const response = await fetch(`${baseUrl}/api/token-generate`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      client: "{client}",
      secret: "{secret}",
    }),
  });

  if (!response.ok) {
    throw new Error(`Falha ao gerar token: ${response.status}`);
  }

  return response.json();
}

async function executarServico(token) {
  const response = await fetch(`${baseUrl}/api/service-api`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${token}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      service: "SERVICE_PERSON_DATA_ENRICHMENT",
      cpf: "cpf",
    }),
  });

  const body = await response.json();

  if (body.status?.code !== 200) {
    throw new Error(body.status?.message || "Falha no processamento");
  }

  return body.result;
}

(async () => {
  const { access_token } = await gerarToken();
  const result = await executarServico(access_token);
  console.log(result);
})();

const axios = require("axios");

const baseUrl = "https://backoffice-hml.idcerberus.com";

(async () => {
  const tokenResponse = await axios.post(`${baseUrl}/api/token-generate`, {
    client: "{client}",
    secret: "{secret}",
  });

  const token = tokenResponse.data.access_token;

  const serviceResponse = await axios.post(
    `${baseUrl}/api/service-api`,
    {
      service: "SERVICE_PERSON_DATA_ENRICHMENT",
      cpf: "cpf",
    },
    {
      headers: {
        Authorization: `Bearer ${token}`,
        "Content-Type": "application/json",
      },
      timeout: 60000,
    },
  );

  if (serviceResponse.data.status?.code !== 200) {
    throw new Error(serviceResponse.data.status?.message || "Falha no processamento");
  }

  console.log(serviceResponse.data.result);
})();

import requests

BASE_URL = "https://backoffice-hml.idcerberus.com"

token_response = requests.post(
    f"{BASE_URL}/api/token-generate",
    json={
        "client": "{client}",
        "secret": "{secret}",
    },
    timeout=30,
)
token_response.raise_for_status()
token = token_response.json()["access_token"]

service_response = requests.post(
    f"{BASE_URL}/api/service-api",
    headers={"Authorization": f"Bearer {token}"},
    json={
        "service": "SERVICE_PERSON_DATA_ENRICHMENT",
        "cpf": "cpf",
    },
    timeout=60,
)
service_response.raise_for_status()
body = service_response.json()

if body.get("status", {}).get("code") != 200:
    raise RuntimeError(body.get("status", {}).get("message", "Falha no processamento"))

print(body["result"])

using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var baseUrl = "https://backoffice-hml.idcerberus.com";
using var http = new HttpClient();

var tokenPayload = JsonSerializer.Serialize(new
{
    client = "{client}",
    secret = "{secret}"
});

var tokenResponse = await http.PostAsync(
    $"{baseUrl}/api/token-generate",
    new StringContent(tokenPayload, Encoding.UTF8, "application/json")
);

tokenResponse.EnsureSuccessStatusCode();
using var tokenJson = JsonDocument.Parse(await tokenResponse.Content.ReadAsStringAsync());
var token = tokenJson.RootElement.GetProperty("access_token").GetString();

http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

var servicePayload = JsonSerializer.Serialize(new
{
    service = "SERVICE_PERSON_DATA_ENRICHMENT",
    cpf = "cpf"
});

var serviceResponse = await http.PostAsync(
    $"{baseUrl}/api/service-api",
    new StringContent(servicePayload, Encoding.UTF8, "application/json")
);

serviceResponse.EnsureSuccessStatusCode();
var serviceBody = await serviceResponse.Content.ReadAsStringAsync();
Console.WriteLine(serviceBody);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class IdCerberusExample {
  public static void main(String[] args) throws Exception {
    var baseUrl = "https://backoffice-hml.idcerberus.com";
    var http = HttpClient.newHttpClient();

    var tokenRequest = HttpRequest.newBuilder()
      .uri(URI.create(baseUrl + "/api/token-generate"))
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString("""
        {
          "client": "{client}",
          "secret": "{secret}"
        }
      """))
      .build();

    var tokenResponse = http.send(tokenRequest, HttpResponse.BodyHandlers.ofString());
    var tokenBody = tokenResponse.body();
    var token = tokenBody.split("\"access_token\"\\s*:\\s*\"")[1].split("\"")[0];

    var serviceRequest = HttpRequest.newBuilder()
      .uri(URI.create(baseUrl + "/api/service-api"))
      .header("Authorization", "Bearer " + token)
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString("""
        {
          "service": "SERVICE_PERSON_DATA_ENRICHMENT",
          "cpf": "cpf"
        }
      """))
      .build();

    var serviceResponse = http.send(serviceRequest, HttpResponse.BodyHandlers.ofString());
    System.out.println(serviceResponse.body());
  }
}

{
  "service": "SERVICE_CORPORATE_DATA_ENRICHMENT",
  "cnpj": "cnpj"
}

{
  "service": "SERVICE_FACE_MATCH",
  "image1": "base64",
  "image2": "base64"
}