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

# API Canada Credit Bureau 2 (sem FINTRAC): ID Match

> Canada Credit Bureau 2 (sem FINTRAC): consulta de bases de dados oficiais do Canadá via Didit. Pague por chamada a partir de $1.75, sem contratos nem mínimos.

Verifica os dados submetidos face aos dados de cabeçalho de crédito obtidos de uma agência de crédito no Canadá. Este serviço não fornece os dados exigidos pela FINTRAC, mas pode fornecer indicadores adicionais de deteção de fraude. É necessária uma aplicação para agências. A Didit disponibiliza este serviço através de `POST /v3/database-validation/`, para que possa verificar os dados submetidos face à fonte oficial e receber resultados de correspondência normalizados.

## Cobertura

* **Cobertura:** \~ 85%
* **País:** Canadá
* **ID do serviço:** `can_credit_bureau_2_non_fintrac`
* **Domínio de dados:** Financeiro
* **Categoria:** CreditBureau

## Dados de entrada

| Campo | Obrigatório | Exemplo |
| - | -: | - |
| `first_name` | Sim | `John` |
| `last_name` | Sim | `Doe` |
| `date_of_birth` | Sim | `1990-01-01` |
| `address.street_1` | Sim | `123 Sample Street` |
| `address.postal_code` | Sim | `10001` |
| `address.street_2` | Não | `Unit 4` |
| `address.city` | Não | `Sample City` |
| `address.region` | Não | `Sample State` |
| `vendor_data` | Não | `user-1234` |

* **Entradas obrigatórias:** `first_name`, `last_name`, `date_of_birth`, `address.street_1`, `address.postal_code`
* **Entradas opcionais:** `address.street_2`, `address.city`, `address.region`, `vendor_data`
* **Consentimento:** Obrigatório
* **Disponibilidade no fluxo:** Disponível no fluxo
* **Cobertura:** \~ 85%
* **Preço:** \$1.75 por consulta bem-sucedida

## Parâmetros do corpo

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

Código de país ISO 3166-1 alpha-3 para este serviço de base de dados.

Exemplo: `CAN`

**services** `string` *required* (default: can\_credit\_bureau\_2\_non\_fintrac)

Array que contém este ID de serviço. Fixar o serviço mantém o pedido restrito a esta base de dados exata.

Exemplo: `can_credit_bureau_2_non_fintrac`

**consent** `boolean` *required* (default: true)

Consentimento explícito do utilizador final para este serviço.

Exemplo: `true`

**first\_name** `string` *required* (default: John)

Nome próprio a validar.

Exemplo: `John`

**last\_name** `string` *required* (default: Doe)

Apelido a validar.

Exemplo: `Doe`

**date\_of\_birth** `string` *required* (default: 1990-01-01)

Data de nascimento no formato `YYYY-MM-DD`.

Exemplo: `1990-01-01`

**address** `object` *required* (default: \{"street\_1":"123 Sample Street","street\_2":"Unit 4","city":"Sample City","region":"Sample State","postal\_code":"10001","country":"US"})

Objeto de morada residencial estruturado. Use `street_1`, `street_2`, `city`, `region`, `postal_code` e `country`. Uma cadeia de texto de morada no formato antigo continua a ser aceite, mas não é recomendada.

Exemplo: `{"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}`

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

A sua referência de utilizador estável para esta pessoa, como o seu ID interno de utilizador. A Didit usa-a para ligar verificações independentes ao mesmo utilizador final e reduzir o ruído de deteção de duplicados.

Exemplo: `user-1234`

## Regras de entrada e notas de validação

* Nos serviços baseados em morada, envie campos de morada estruturados em vez de uma única cadeia `address` sempre que possível.
* `address.street_1` é a morada, incluindo o número de polícia e o tipo de via.
* `address.street_2` é o apartamento, fração, edifício, piso ou outra linha adicional da morada. Envie-o apenas quando o tiver.
* `address.city` é a cidade, subúrbio, distrito, localidade ou bairro.
* `address.region` é o estado, província, região ou localidade.
* `address.postal_code` é o código postal.
* Os serviços de base de dados baseados em morada exigem, no mínimo, a morada da rua e o código postal. Os pedidos rejeitados antes da consulta à fonte não são cobrados.

## Como fazer a chamada

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=CAN" \
  -F "services=can_credit_bureau_2_non_fintrac" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F 'address={"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}'
```

```python Python theme={null}
from didit import Didit

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="CAN",
    services=["can_credit_bureau_2_non_fintrac"],
    consent=True,
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    address={"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"},
    vendor_data="user-1234",
)
print(result)
```

```javascript Node.js theme={null}
import Didit from "@didit-protocol/sdk-node";

// Reads DIDIT_API_KEY.
const didit = new Didit();

const result = await didit.databaseValidation.validate({
  issuing_state: "CAN",
  services: ["can_credit_bureau_2_non_fintrac"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  vendor_data: "user-1234",
});
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: "CAN",
	Services:     didit.Some([]string{"can_credit_bureau_2_non_fintrac"}),
	Consent:      didit.Bool(true),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	Address:      didit.Some[any](map[string]any{"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"}),
	VendorData:   didit.String("user-1234"),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
import java.time.LocalDate;
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("CAN")
        .services(List.of("can_credit_bureau_2_non_fintrac"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .address(DatabaseValidationValidateParams.Address.ofVariant1(DatabaseValidationValidateParams.Address.Variant1.builder()
                .street1("123 Sample Street")
                .street2("Unit 4")
                .city("Sample City")
                .region("Sample State")
                .postalCode("10001")
                .country("US")
                .build()))
        .vendorData("user-1234")
        .build());
System.out.println(result);
```

```php PHP theme={null}
<?php

require 'vendor/autoload.php';

use Didit\DiditClient;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'CAN',
    'services' => ['can_credit_bureau_2_non_fintrac'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'address' => ['street_1' => '123 Sample Street', 'street_2' => 'Unit 4', 'city' => 'Sample City', 'region' => 'Sample State', 'postal_code' => '10001', 'country' => 'US'],
    'vendor_data' => 'user-1234',
]);
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: "CAN",
  services: ["can_credit_bureau_2_non_fintrac"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  vendor_data: "user-1234"
)
puts result.to_h
```

```csharp .NET theme={null}
using System;
using System.Collections.Generic;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.DatabaseValidation.ValidateAsync(new DatabaseValidationValidateParams
{
    IssuingState = "CAN",
    Services = new string[] { "can_credit_bureau_2_non_fintrac" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    Address = new Dictionary<string, object> { ["street_1"] = "123 Sample Street", ["street_2"] = "Unit 4", ["city"] = "Sample City", ["region"] = "Sample State", ["postal_code"] = "10001", ["country"] = "US" },
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Cada chamada bem-sucedida devolve HTTP `200`. O campo **`outcome_code`** indica o que realmente aconteceu, distinguindo, por exemplo, uma incompatibilidade biométrica real (`BIOMETRIC_NO_MATCH`) de uma selfie que não pôde ser lida (`BIOMETRIC_IMAGE_UNUSABLE`). O `status` apresentado é o estado predefinido da funcionalidade; as suas [ações configuradas de Correspondência parcial / Sem correspondência](https://docs.didit.me/pt/core-technology/database-validation/database-validation-warnings.md) podem substituí-lo.

**`MATCH`** — O registo confirmou a identidade e todos os campos verificados corresponderam.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "CAN",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "can_credit_bureau_2_non_fintrac",
      "service_name": "Canada Credit Bureau 2 (Non-FINTRAC)",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "last_name": "Doe"
      },
      "validation": {
        "address": "full_match",
        "date_of_birth": "full_match",
        "full_name": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`** — Um ou mais dos campos que este serviço compara não corresponderam totalmente. Neste exemplo, `full_name` não correspondeu, enquanto `address` e `date_of_birth` corresponderam.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "CAN",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "can_credit_bureau_2_non_fintrac",
      "service_name": "Canada Credit Bureau 2 (Non-FINTRAC)",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "last_name": "Doe"
      },
      "validation": {
        "address": "full_match",
        "date_of_birth": "full_match",
        "full_name": "no_match"
      }
    }
  ]
}
```

**`NO_MATCH`** — O registo não devolveu qualquer correspondência para os dados submetidos.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "CAN",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "can_credit_bureau_2_non_fintrac",
      "service_name": "Canada Credit Bureau 2 (Non-FINTRAC)",
      "source_data": {
        "address": "NO_MATCH",
        "date_of_birth": "NO_MATCH",
        "full_name": "NO_MATCH"
      },
      "validation": {
        "address": "no_match",
        "date_of_birth": "no_match",
        "full_name": "no_match"
      }
    }
  ]
}
```

## Dados devolvidos

Os campos exatos apresentados em `source_data` dependem do que o registo devolve. O exemplo gerado para `can_credit_bureau_2_non_fintrac` documenta atualmente esta estrutura normalizada:

* `address`
* `date_of_birth`
* `first_name`
* `last_name`

## Preços e SLAs

As consultas Canada Credit Bureau 2 (Non-FINTRAC) são faturadas apenas quando a Didit recebe um resultado conclusivo da fonte de validação.

* **Preço por chamada:** \$1.75 USD.
* **Faturação:** por consulta bem-sucedida. Não é cobrado quando o registo não está acessível, quando faltam campos obrigatórios ou quando o pedido é rejeitado antes de chegar à fonte.
* **Latência:** p95 típico \< 2 s.
* **Disponibilidade:** 99.9% por trimestre do lado da Didit; a disponibilidade das fontes a jusante varia consoante o país e o conjunto de dados.

## Continue a ler

* [Visão geral da validação de base de dados no Canadá](https://docs.didit.me/api-reference/database-validation/canada.md)
* [Visão geral da validação de base de dados](https://docs.didit.me/pt/core-technology/database-validation/overview.md)
* [Códigos de resultado](https://docs.didit.me/pt/core-technology/database-validation/database-validation-outcome-codes.md)


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