> ## 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 de Verificação de Fraude

> Planeie e execute verificações selecionadas de identidade, risco de contacto, enriquecimento e rede num único pedido com a Didit.

Submeter identificadores introduzidos e atributos de identidade declarados, selecionar as verificações a executar e analisar cada resultado separadamente.
Utilize [Planear uma verificação de fraude](https://docs.didit.me/pt/standalone-apis/fraud-check-plan.md) primeiro, para confirmar os requisitos de entrada e os custos estimados.

## Escolher um perfil

Fixe `profile_version` para que os valores predefinidos selecionados e a política de decisão fiquem explícitos.
O perfil predefinido é `standard`, versão `2026-08-27`.
A versão `2026-09-14` acrescenta o enriquecimento social opcional de e-mail e telefone e regista cada verificação concluída como uma sessão nativa de Verificação de utilizadores.
Nessa versão, os complementos pagos são de adesão voluntária.
A versão `2026-09-14.1` ativa também as pesquisas de identificadores na rede global de fraude para organizações do plano Enterprise que partilham dados globalmente.
A versão `2026-09-14.2` acrescenta uma verificação de referência opcional entre selfie e CPF, para o Brasil.
As versões anteriores mantêm o comportamento original.

Os perfis atuais suportam risco de e-mail, risco de telefone, risco de IP, validação de base de dados elegível e o histórico da rede privada da sua aplicação.
A vinculação de identidade baseada em selfie requer a versão `2026-09-14.2`.
Selecioná-la em versões anteriores devolve `not_available_in_profile_version`.

## Identidade declarada e contexto

Coloque o e-mail, o telefone e os identificadores governamentais em `subject.identifiers`.
Os identificadores governamentais exigem o respetivo país emissor; pode também ser necessário um emissor quando os números só são únicos dentro de uma região.
Coloque os nomes, a data de nascimento, a nacionalidade e a morada em `subject.attributes`.
Estes dados são declarações a comparar sempre que uma fonte selecionada as suporte, e não factos verificados só por terem sido submetidos.

Use `context` para o endereço IP da tentativa, o agente do utilizador, a finalidade, o país e qualquer declaração de consentimento exigida.
Isto separa as informações sobre a tentativa de verificação das informações sobre a pessoa.
Para as verificações biométricas suportadas, forneça `subject.selfie` como JPEG, PNG ou WebP codificado em base64, até 6 MB.
Também é aceite um URI de dados de imagem correspondente.
Não envie uma imagem de referência, um URL remoto nem uma chave de armazenamento.

## Selfie e identificador declarado

Selecione `biometric_identity`, submeta um identificador `tax_number` brasileiro e uma selfie, e confirme `context.consent_obtained`.
A verificação de referência verifica se essa selfie pertence ao titular do CPF declarado.
Um consentimento em falta devolve `consent_required`, e os países não suportados devolvem `unsupported_region`.
O módulo tem um preço por verificação, baseado na taxa de Validação de base de dados da sua organização; consulte o plano antes de o executar.

Quando a referência responde, `identity_relationship.result` é `match`, `mismatch` ou `inconclusive`.
Uma resposta inconclusiva exige revisão e nunca é tratada como uma não correspondência.
O resultado estabelece apenas a relação entre a selfie e o CPF.
Não valida um nome ou uma data de nascimento submetidos, não comprova a existência de vida e não pesquisa uma face na internet ou na rede global de fraude.
Os nomes e a data de nascimento continuam a ser dados declarados, salvo se outra fonte selecionada fornecer evidências para esses campos.
Os tempos limite e os erros de fonte são resultados indisponíveis e não são faturados.
As respostas inconclusivas concluídas são faturadas à mesma taxa de verificação de referência.
A selfie não é incluída no resultado nem armazenada como ficheiro multimédia da sessão por esta verificação.

## Selecionar verificações

`checks.include` seleciona os módulos, e `checks.exclude` tem precedência.
Uma lista `include` explicitamente vazia desativa todo o trabalho opcional; a normalização continua a ser executada.
Se omitir `include`, são usados os valores predefinidos do perfil fixado.
O enriquecimento social de e-mail e de telefone é selecionado separadamente com `email_social` e `phone_social`.
Ambos requerem um identificador válido e correspondente e não enviam um OTP.

```json theme={null}
{
  "profile_version": "2026-09-14.1",
  "client_reference": "review-attempt-001",
  "subject": {
    "identifiers": [
      { "type": "email", "value": "applicant@example.com" }
    ],
    "attributes": { "first_name": "Alex", "last_name": "Example" }
  },
  "checks": { "include": ["networks_same_org", "networks_cross_org", "email_risk"] }
}
```

## Ler os resultados sem os confundir

Cada módulo indica o seu estado de execução, o motivo e as unidades faturáveis.
`not_requested`, `excluded_by_caller`, `missing_required_input` e `source_unavailable` descrevem resultados diferentes.
Uma fonte em falta não é uma não correspondência de identidade nem um resultado de risco zero.

`attribute_evidence` descreve as evidências ao nível do campo, enquanto `risk` mantém separadas as dimensões de identidade, contacto, dispositivo, comportamento e rede de fraude.
Um e-mail, dispositivo ou outro identificador partilhado é uma ligação observada, e não prova que duas contas pertencem à mesma pessoa nem que houve fraude.
`recommendation` é a recomendação da verificação; não altera o estado de outro registo.
Os resultados do enriquecimento social aparecem em `enrichment`, distinguindo os resultados indisponíveis dos concluídos.

## Rede global de fraude

Selecione `networks_cross_org` para consultar, na rede partilhada, os identificadores suportados de correio eletrónico, telefone e documento com o espaço de nomes corretamente definido.
A consulta requer o plano Enterprise e o modo de partilha da sua organização definido como `global`.
Sem estes requisitos, o plano indica o módulo com `available: false` e `availability_reason: "entitlement_required"`, e uma verificação que o selecione ignora-o com o estado `skipped` e o motivo `entitlement_required`.
O mesmo motivo aplica-se quando as Networks não estão ativadas para a sua organização.
As aplicações de sandbox não estão sujeitas ao plano nem ao modo de partilha: com um identificador suportado, o módulo é executado e devolve um resultado de amostra vazio.
A consulta utiliza o orçamento de leituras existente da organização e regista uma auditoria da leitura.
Não tem cobrança por consulta.
Planear uma verificação não consulta o índice partilhado nem consome o respetivo orçamento de leituras.

`network.cross_organization` contém `signals_checked` e os `insights` agregados divulgados quando a verificação termina.
Cada insight contém o tipo de sinal, as classes de resultado, o número de contribuidores, o intervalo de recência e, apenas quando a divulgação está ativada, as categorias de setor.
Nunca identifica outra organização, conta, pessoa ou verificação.
Os resultados abaixo do limiar de divulgação são omitidos; uma lista vazia não prova a ausência de histórico de fraude.
Um sinal partilhado divulgado gera uma recomendação de revisão, nunca uma rejeição automática nem uma correspondência de identidade.

Uma consulta indisponível indica o motivo separadamente de uma consulta concluída mas vazia.
Se a sua organização perder mais tarde o acesso entre organizações, por exemplo após uma alteração de plano ou quando a partilha deixar de ser `global`, a obtenção de resultados, as novas tentativas e os detalhes da sessão ocultam os agregados partilhados e as respetivas evidências de risco derivadas.
A recomendação original mantém-se como decisão histórica; as leituras não alteram o estado da verificação.

## Sessões, novas tentativas e cobranças

`check_id` obtém o resultado guardado através de [Obter uma verificação de fraude](https://docs.didit.me/pt/standalone-apis/fraud-check-result.md).
Quando presente, `request_id` identifica a respetiva sessão de verificação nativa.
As versões `2026-09-14`, `2026-09-14.1` e `2026-09-14.2` criam sempre essa sessão, mesmo quando só é selecionado o histórico da rede privada.

Reutilizar `client_reference` com o mesmo corpo do pedido devolve o resultado original, sem nova execução nem cobrança, enquanto essa verificação existir.
Um corpo diferente com a mesma referência devolve `409`.
Se a execução ainda estiver em curso, tente novamente o mesmo pedido após o intervalo indicado em `Retry-After` na resposta.
Eliminar a verificação associada também elimina o resultado da verificação de fraude; a obtenção devolve depois `404`.
Uma verificação eliminada durante a execução não pode publicar um resultado concluído.

Os preços provêm das tarifas pré-pagas ou contratuais atuais da sua organização.
Os módulos indisponíveis e ignorados não são faturados, e o histórico da rede privada não tem cobrança por verificação.
As verificações em sandbox utilizam respostas de amostra, sem chamadas pagas a fornecedores nem cobranças.


## OpenAPI

````yaml pt/openapi-25.json POST /v3/fraud/checks/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de Verificação de identidade. Autentique-se com o cabeçalho x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/fraud/checks/:
    post:
      tags:
        - Fraud Check
      summary: Executar uma verificação de fraude
      description: >-
        Submeta um ou mais identificadores tipificados e receba normalização,
        enriquecimento atualizado, validação fidedigna onde o país e o tipo de
        identificador tenham cobertura, dimensões de risco independentes e uma
        recomendação numa única resposta.


        Estes perfis suportam verificações de identificadores. A vinculação de
        identidade baseada em selfie (`biometric_identity`) requer a versão de
        perfil `2026-09-14.2` e um CPF brasileiro; é executada apenas com o
        consentimento do utilizador e quando a sua organização tiver direito a
        ela. Versões anteriores reportam-na como
        `not_available_in_profile_version`. Os módulos que não possam ser
        executados são reportados como ignorados com um motivo determinístico;
        uma fonte que não tenha conseguido responder nunca é reportada como uma
        não correspondência de identidade.
      operationId: create_fraud_check
      requestBody:
        content:
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
          application/json:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
            example:
              client_reference: review-attempt-001
              subject:
                identifiers:
                  - type: email
                    value: applicant@example.com
                attributes:
                  first_name: Alex
                  last_name: Example
              checks:
                include:
                  - networks_same_org
                  - networks_cross_org
                  - email_risk
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/FraudCheckRequestRequest'
        required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudCheckResponse'
          description: ''
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudClientCredentialsErrorMessage'
          description: ''
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/FraudClientCredentialsForbiddenErrorMessage
          description: ''
        '409':
          description: >-
            Conflito, devolvido sem cobrança: o `client_reference` já foi
            utilizado com um corpo de pedido diferente; uma verificação com o
            mesmo `client_reference` ainda está em execução (tente novamente
            após `Retry-After` segundos com a mesma referência); ou a
            verificação na qual este controlo é registado foi eliminada antes de
            o controlo ser concluído.
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                required:
                  - error
              examples:
                different_body:
                  summary: Referência reutilizada com um corpo diferente
                  value:
                    error: >-
                      client_reference has already been used with a different
                      request body.
                still_running:
                  summary: Uma verificação com esta referência ainda está em execução
                  value:
                    error: >-
                      A check with this client_reference is already running.
                      Retry with the same reference later.
                verification_deleted:
                  summary: >-
                    A verificação foi eliminada antes da conclusão da
                    verificação
                  value:
                    error: This verification was deleted before the check completed.
          headers:
            Retry-After:
              description: >-
                Segundos a aguardar antes de tentar novamente, enviados quando
                uma verificação com a mesma `client_reference` ainda estiver em
                execução.
              schema:
                type: integer
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.fraud_checks.create(
                client_reference="review-attempt-001",
                subject={
                    "identifiers": [{
                        "type": "email",
                        "value": "applicant@example.com",
                    }],
                    "attributes": {
                        "first_name": "Alex",
                        "last_name": "Example",
                    },
                },
                checks={
                    "include": ["networks_same_org", "networks_cross_org", "email_risk"],
                },
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

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

            const result = await didit.fraudChecks.create({
              client_reference: "review-attempt-001",
              subject: {
                identifiers: [{
                  type: "email",
                  value: "applicant@example.com",
                }],
                attributes: {
                  first_name: "Alex",
                  last_name: "Example",
                },
              },
              checks: {
                include: ["networks_same_org", "networks_cross_org", "email_risk"],
              },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.FraudChecks.Create(ctx, didit.FraudCheckRequestRequest{\n\tClientReference: didit.String(\"review-attempt-001\"),\n\tSubject: didit.FraudCheckSubjectRequest{\n\t\tIdentifiers: []didit.FraudCheckIdentifierRequest{{\n\t\t\tType:  didit.FraudTypeEnum(\"email\"),\n\t\t\tValue: \"applicant@example.com\",\n\t\t}},\n\t\tAttributes: didit.Some(didit.FraudCheckAttributesRequest{\n\t\t\tFirstName: didit.String(\"Alex\"),\n\t\t\tLastName:  didit.String(\"Example\"),\n\t\t}),\n\t},\n\tChecks: didit.Some(didit.FraudCheckModuleSelectionRequest{\n\t\tInclude: didit.Some([]didit.FraudExcludeEnum{didit.FraudExcludeEnum(\"networks_same_org\"), didit.FraudExcludeEnum(\"networks_cross_org\"), didit.FraudExcludeEnum(\"email_risk\")}),\n\t}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.FraudCheckAttributesRequest;

            import me.didit.types.FraudCheckIdentifierRequest;

            import me.didit.types.FraudCheckModuleSelectionRequest;

            import me.didit.types.FraudCheckRequestRequest;

            import me.didit.types.FraudCheckSubjectRequest;

            import me.didit.types.FraudExcludeEnum;

            import me.didit.types.FraudTypeEnum;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.fraudChecks().create(FraudCheckRequestRequest.builder()
                    .clientReference("review-attempt-001")
                    .subject(FraudCheckSubjectRequest.builder()
                            .identifiers(List.of(FraudCheckIdentifierRequest.builder()
                                    .type(FraudTypeEnum.of("email"))
                                    .value("applicant@example.com")
                                    .build()))
                            .attributes(FraudCheckAttributesRequest.builder()
                                    .firstName("Alex")
                                    .lastName("Example")
                                    .build())
                            .build())
                    .checks(FraudCheckModuleSelectionRequest.builder()
                            .include(List.of(FraudExcludeEnum.of("networks_same_org"), FraudExcludeEnum.of("networks_cross_org"), FraudExcludeEnum.of("email_risk")))
                            .build())
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

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

            $result = $didit->fraudChecks->create([
                'client_reference' => 'review-attempt-001',
                'subject' => [
                    'identifiers' => [[
                        'type' => 'email',
                        'value' => 'applicant@example.com',
                    ]],
                    'attributes' => [
                        'first_name' => 'Alex',
                        'last_name' => 'Example',
                    ],
                ],
                'checks' => [
                    'include' => ['networks_same_org', 'networks_cross_org', 'email_risk'],
                ],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.fraud_checks.create(
              client_reference: "review-attempt-001",
              subject: {
                identifiers: [{
                  type: "email",
                  value: "applicant@example.com",
                }],
                attributes: {
                  first_name: "Alex",
                  last_name: "Example",
                },
              },
              checks: {
                include: ["networks_same_org", "networks_cross_org", "email_risk"],
              }
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.FraudChecks.CreateAsync(new
            FraudCheckRequestRequest

            {
                ClientReference = "review-attempt-001",
                Subject = new()
                {
                    Identifiers = new FraudCheckIdentifierRequest[]
                    {
                        new()
                        {
                            Type = "email",
                            Value = "applicant@example.com",
                        },
                    },
                    Attributes = new FraudCheckAttributesRequest
                    {
                        FirstName = "Alex",
                        LastName = "Example",
                    },
                },
                Checks = new FraudCheckModuleSelectionRequest
                {
                    Include = new FraudExcludeEnum[] { "networks_same_org", "networks_cross_org", "email_risk" },
                },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    FraudCheckRequestRequest:
      type: object
      properties:
        client_reference:
          type: string
          minLength: 1
          description: >-
            A sua própria referência para esta verificação. Funciona também como
            a chave de idempotência: reutilizá-la com o mesmo corpo devolve a
            verificação original sem executar ou faturar os módulos novamente;
            reutilizá-la com um corpo diferente devolve 409.
          maxLength: 255
        profile:
          type: string
          minLength: 1
          default: standard
          description: >-
            ID do perfil de orquestração. O valor predefinido é o perfil
            `standard` da Didit.
          maxLength: 64
        profile_version:
          type: string
          minLength: 1
          description: >-
            Fixar uma versão congelada do perfil. Assume por predefinição a
            versão atual do perfil.
          maxLength: 32
        subject:
          $ref: '#/components/schemas/FraudCheckSubjectRequest'
        context:
          $ref: '#/components/schemas/FraudCheckContextRequest'
        checks:
          $ref: '#/components/schemas/FraudCheckModuleSelectionRequest'
        vendor_data:
          type: string
          maxLength: 1000
        metadata: {}
      required:
        - subject
    FraudCheckResponse:
      type: object
      properties:
        check_id:
          type: string
          format: uuid
        request_id:
          type: string
          format: uuid
          description: Sessão de verificação nativa criada para esta verificação.
        client_reference:
          type: string
          nullable: true
        processing_status:
          $ref: '#/components/schemas/FraudProcessingStatusEnum'
        profile_id:
          type: string
        profile_version:
          type: string
        created_at:
          type: string
          format: date-time
        completed_at:
          type: string
          format: date-time
          nullable: true
        inputs:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckInput'
        modules:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckModuleReport'
        attribute_evidence:
          type: array
          items:
            type: object
            additionalProperties: {}
        compound_evidence:
          type: array
          items:
            type: object
            additionalProperties: {}
        risk:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckRisk'
        network:
          type: object
          additionalProperties: {}
        enrichment:
          type: object
          additionalProperties: {}
        identity_relationship:
          allOf:
            - $ref: '#/components/schemas/FraudCheckIdentityRelationship'
          nullable: true
        recommendation:
          $ref: '#/components/schemas/FraudRecommendationEnum'
        next_action:
          $ref: '#/components/schemas/FraudNextActionEnum'
        decision_reasons:
          type: array
          items:
            type: string
        coverage:
          type: object
          additionalProperties: {}
        usage:
          type: array
          items:
            type: object
            additionalProperties: {}
        vendor_data:
          type: string
          nullable: true
        metadata:
          nullable: true
      required:
        - attribute_evidence
        - check_id
        - client_reference
        - completed_at
        - compound_evidence
        - coverage
        - created_at
        - decision_reasons
        - inputs
        - modules
        - network
        - next_action
        - processing_status
        - profile_id
        - profile_version
        - recommendation
        - risk
        - usage
    FraudClientCredentialsErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: 'Authentication failed: Invalid client access token.'
    FraudClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    FraudCheckSubjectRequest:
      type: object
      properties:
        selfie:
          type: string
          minLength: 1
          description: >-
            Selfie em JPEG, PNG ou WebP em Base64, até 6 MB. Sem imagem de
            referência nem URL.
          maxLength: 8388672
        identifiers:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckIdentifierRequest'
          description: Um ou mais identificadores com tipo. Um é suficiente.
          maxItems: 10
          minItems: 1
        attributes:
          $ref: '#/components/schemas/FraudCheckAttributesRequest'
      required:
        - identifiers
    FraudCheckContextRequest:
      type: object
      properties:
        ip_address:
          type: string
          minLength: 1
        user_agent:
          type: string
          maxLength: 512
        country:
          type: string
          description: >-
            País onde o titular alega estar. Apenas contextual - nunca prova de
            titularidade da identidade.
          maxLength: 3
        purpose:
          type: string
          maxLength: 128
        consent_obtained:
          type: boolean
    FraudCheckModuleSelectionRequest:
      type: object
      properties:
        include:
          type: array
          items:
            $ref: '#/components/schemas/FraudExcludeEnum'
        exclude:
          type: array
          items:
            $ref: '#/components/schemas/FraudExcludeEnum'
    FraudProcessingStatusEnum:
      enum:
        - pending
        - running
        - completed
        - failed
      type: string
      description: |-
        * `pending` - Pendente
        * `running` - Em execução
        * `completed` - Concluído
        * `failed` - Falhado
    FraudCheckInput:
      type: object
      properties:
        reference:
          type: string
          description: Nome de utilizador ocultado para o identificador submetido.
        type:
          $ref: '#/components/schemas/FraudTypeEnum'
        namespace:
          type: object
          additionalProperties: {}
        quality:
          type: string
        normalization:
          type: object
          additionalProperties: {}
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
      required:
        - availability
        - namespace
        - normalization
        - quality
        - reference
        - type
    FraudCheckModuleReport:
      type: object
      properties:
        module:
          $ref: '#/components/schemas/FraudExcludeEnum'
        status:
          $ref: '#/components/schemas/FraudStatusEnum'
        reason:
          type: string
          nullable: true
        latency_ms:
          type: integer
        freshness:
          type: string
          nullable: true
        billable_units:
          type: integer
      required:
        - billable_units
        - freshness
        - latency_ms
        - module
        - reason
        - status
    FraudCheckRisk:
      type: object
      properties:
        dimension:
          $ref: '#/components/schemas/FraudDimensionEnum'
        score:
          type: integer
          nullable: true
        band:
          $ref: '#/components/schemas/FraudBandEnum'
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
        requested_but_unavailable:
          type: boolean
          description: >-
            True quando o pedido forneceu tudo o que esta dimensão necessitava e
            a plataforma mesmo assim não conseguiu responder. Uma verificação
            deste tipo nunca é recomendada para aprovação com base apenas nas
            dimensões que responderam.
        reason_codes:
          type: array
          items:
            type: string
        evidence_indexes:
          type: array
          items:
            type: integer
      required:
        - availability
        - band
        - dimension
        - evidence_indexes
        - reason_codes
        - requested_but_unavailable
        - score
    FraudCheckIdentityRelationship:
      type: object
      properties:
        result:
          $ref: '#/components/schemas/FraudResultEnum'
        reference_type:
          type: string
        country:
          type: string
        availability:
          $ref: '#/components/schemas/FraudAvailabilityEnum'
        reason_codes:
          type: array
          items:
            type: string
      required:
        - availability
        - country
        - reason_codes
        - reference_type
        - result
    FraudRecommendationEnum:
      enum:
        - approve
        - review
        - reject
      type: string
      description: |-
        * `approve` - Aprovar
        * `review` - Rever
        * `reject` - Rejeitar
    FraudNextActionEnum:
      enum:
        - none
        - manual_review
        - step_up
        - resubmit_capture
      type: string
      description: |-
        * `none` - Nenhum
        * `manual_review` - Revisão manual
        * `step_up` - Escalonamento
        * `resubmit_capture` - Reenviar captura
    FraudCheckIdentifierRequest:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/FraudTypeEnum'
          description: >-
            Tipo de identificador. Determina quais os campos do namespace que
            são obrigatórios.


            * `email` - E-mail

            * `phone` - Telefone

            * `national_id` - ID Nacional

            * `tax_number` - Número de Identificação Fiscal

            * `passport_number` - Número de Passaporte

            * `driving_licence_number` - Número da Carta de Condução

            * `residence_permit_number` - Número da Autorização de Residência

            * `voter_id` - Título de Eleitor

            * `external_id` - ID Externo
        value:
          type: string
          minLength: 1
          description: O valor do identificador, em qualquer formato habitual.
          maxLength: 255
        country:
          type: string
          description: >-
            País emissor ISO-3166 alfa-2 ou alfa-3. Obrigatório para tipos de
            identificadores governamentais: os mesmos dígitos representam
            pessoas diferentes em países diferentes.
          maxLength: 3
        issuer:
          type: string
          description: >-
            Autoridade emissora ou emissor subnacional opcional, quando o país,
            por si só, não for único.
          maxLength: 128
      required:
        - type
        - value
    FraudCheckAttributesRequest:
      type: object
      description: Atributos corroborantes. Todos opcionais; alargam a cobertura do módulo.
      properties:
        first_name:
          type: string
          maxLength: 128
        last_name:
          type: string
          maxLength: 128
        full_name:
          type: string
          maxLength: 256
        date_of_birth:
          type: string
          format: date
        nationality:
          type: string
          maxLength: 3
        gender:
          type: string
          maxLength: 16
        address:
          type: string
          maxLength: 512
        city:
          type: string
          maxLength: 128
        state:
          type: string
          maxLength: 128
        postal_code:
          type: string
          maxLength: 32
    FraudExcludeEnum:
      enum:
        - normalization
        - email_risk
        - email_social
        - phone_social
        - phone_risk
        - ip_risk
        - database_validation
        - networks_same_org
        - networks_cross_org
        - biometric_identity
      type: string
      description: |-
        * `normalization` - Normalização
        * `email_risk` - Risco de e-mail
        * `email_social` - Redes sociais do e-mail
        * `phone_social` - Redes sociais do telefone
        * `phone_risk` - Risco do telefone
        * `ip_risk` - Risco de IP
        * `database_validation` - Validação de base de dados
        * `networks_same_org` - Redes da mesma organização
        * `networks_cross_org` - Redes entre organizações
        * `biometric_identity` - Identidade biométrica
    FraudTypeEnum:
      enum:
        - email
        - phone
        - national_id
        - tax_number
        - passport_number
        - driving_licence_number
        - residence_permit_number
        - voter_id
        - external_id
      type: string
      description: |-
        * `email` - E-mail
        * `phone` - Telefone
        * `national_id` - Documento de identificação nacional
        * `tax_number` - Número de identificação fiscal
        * `passport_number` - Número de passaporte
        * `driving_licence_number` - Número da carta de condução
        * `residence_permit_number` - Número do título de residência
        * `voter_id` - Cartão de eleitor
        * `external_id` - ID externo
    FraudAvailabilityEnum:
      enum:
        - available
        - not_requested
        - no_reference
        - insufficient_history
        - unsupported_region
        - source_unavailable
      type: string
      description: |-
        * `available` - Disponível
        * `not_requested` - Não solicitado
        * `no_reference` - Sem referência
        * `insufficient_history` - Histórico insuficiente
        * `unsupported_region` - Região não suportada
        * `source_unavailable` - Origem indisponível
    FraudStatusEnum:
      enum:
        - planned
        - completed
        - skipped
        - failed
      type: string
      description: |-
        * `planned` - Planeado
        * `completed` - Concluído
        * `skipped` - Ignorado
        * `failed` - Falhou
    FraudDimensionEnum:
      enum:
        - identity
        - contact
        - device_network
        - behavioral
        - fraud_network
      type: string
      description: |-
        * `identity` - Identidade
        * `contact` - Contacto
        * `device_network` - Rede do dispositivo
        * `behavioral` - Comportamental
        * `fraud_network` - Rede de fraude
    FraudBandEnum:
      enum:
        - low
        - medium
        - high
        - unknown
      type: string
      description: |-
        * `low` - Baixo
        * `medium` - Médio
        * `high` - Alto
        * `unknown` - Desconhecido
    FraudResultEnum:
      enum:
        - match
        - mismatch
        - inconclusive
        - no_reference
      type: string
      description: |-
        * `match` - Correspondência
        * `mismatch` - Não correspondência
        * `inconclusive` - Inconclusivo
        * `no_reference` - Sem referência
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        A chave de API da sua aplicação, a partir de Programadores -> Chaves de
        API na Business Console. A chave principal tem acesso total. Uma chave
        nomeada pode ter o âmbito definido: nenhum, leitura ou escrita por
        recurso, limitada a alguns fluxos ou a sessões aprovadas, a uma lista de
        endereços IP e a uma data de validade. 401 significa que a chave está
        incorreta, revogada ou expirada; 403 significa que nenhuma chave foi
        enviada, que a chave não tem acesso a este recurso ou ação, ou que o
        pedido veio de um endereço fora da sua lista de IP; 404 numa rota de
        sessão significa que a sessão está fora dos fluxos ou estados da chave.
        Uma chave sem acesso a multimédia recebe URLs de imagens, vídeos e PDFs
        como nulos, e uma chave sem permissão de escrita em sessões recebe
        ligações de sessão e tokens como nulos. Consulte
        https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: O token de acesso de credenciais de cliente da aplicação.

````

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