> ## 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 comprovació de frau

> Planifica i executa en una sola petició les comprovacions seleccionades d'identitat, risc de contacte, enriquiment i xarxa amb Didit.

Envia identificadors introduïts i atributs d'identitat declarada, selecciona les comprovacions que vols executar i revisa cada resultat per separat.
Fes servir [Planifica una comprovació de frau](https://docs.didit.me/ca/standalone-apis/fraud-check-plan.md) primer per revisar els requisits d'entrada i els càrrecs estimats.

## Triar un perfil

Fixa `profile_version` perquè els valors predeterminats seleccionats i la política de decisió siguin explícits.
El perfil predeterminat és `standard`, versió `2026-08-27`.
La versió `2026-09-14` afegeix l'enriquiment social opcional de correu electrònic i de telèfon, i registra cada comprovació completada com a sessió nativa de Verificació d'usuaris.
En aquesta versió, els complements de pagament són d'activació voluntària.
La versió `2026-09-14.1` també activa les consultes d'identificadors a la xarxa global de fraus per a les organitzacions del pla Enterprise que comparteixen globalment.
La versió `2026-09-14.2` afegeix una comprovació de referència opcional entre selfie i CPF per al Brasil.
Les versions anteriors mantenen el comportament original.

Els perfils actuals admeten risc de correu electrònic, risc de telèfon, risc d'IP, validació en bases de dades elegibles i l'historial de la xarxa privada de la teva aplicació.
La vinculació d'identitat basada en selfie requereix la versió `2026-09-14.2`.
Seleccionar-la en versions anteriors retorna `not_available_in_profile_version`.

## Identitat declarada i context

Posa el correu electrònic, el telèfon i els identificadors governamentals a `subject.identifiers`.
Els identificadors governamentals requereixen el seu país emissor; també pot caldre un emissor quan els números només són únics dins d'una regió.
Posa els noms, la data de naixement, la nacionalitat i l'adreça a `subject.attributes`.
Són declaracions per comparar quan una font seleccionada les admet, no fets verificats només pel fet d'haver-se enviat.

Fes servir `context` per a l'adreça IP de l'intent, l'agent d'usuari, la finalitat, el país i qualsevol afirmació de consentiment requerida.
Això separa la informació sobre l'intent de verificació de la informació sobre la persona.
Per a les comprovacions biomètriques admeses, proporciona `subject.selfie` com a JPEG, PNG o WebP codificat en base64, de fins a 6 MB.
També s'accepta un URI de dades d'imatge corresponent.
No enviïs una imatge de referència, una URL remota ni una clau d'emmagatzematge.

## Selfie i identificador declarat

Selecciona `biometric_identity`, envia un identificador `tax_number` brasiler i una selfie, i confirma `context.consent_obtained`.
La referència comprova si aquesta selfie pertany al titular del CPF declarat.
Si falta el consentiment, es retorna `consent_required`, i els països no admesos retornen `unsupported_region`.
El mòdul té un preu per comprovació basat en la tarifa de Validació en bases de dades de la teva organització; revisa el pla abans d'executar-lo.

Quan la referència respon, `identity_relationship.result` és `match`, `mismatch` o `inconclusive`.
Una resposta no concloent requereix revisió i mai es tracta com a discrepància.
El resultat només estableix la relació entre la selfie i el CPF.
No valida un nom ni una data de naixement enviats, no demostra que s'hagi superat la prova de vida, ni cerca una cara a internet ni a la xarxa global de fraus.
Els noms i la data de naixement continuen sent declaracions, tret que una altra font seleccionada aporti evidències per a aquests camps.
Els temps d'espera esgotats i els errors de font són resultats no disponibles i no es facturen.
Les respostes no concloents completades es facturen a la mateixa tarifa de comprovació de referència.
Aquesta comprovació no inclou la selfie en el resultat ni la desa com a contingut multimèdia de la sessió.

## Seleccionar comprovacions

`checks.include` selecciona els mòduls, i `checks.exclude` té prioritat.
Una llista `include` explícitament buida desactiva totes les tasques opcionals; la normalització s'executa igualment.
Si omets `include`, s'usen els valors predeterminats del perfil fixat.
L'enriquiment social de correu electrònic i de telèfon se selecciona per separat amb `email_social` i `phone_social`.
Requereixen un identificador vàlid i coincident, i no envien cap 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"] }
}
```

## Llegir els resultats sense confondre'ls

Cada mòdul informa del seu estat d'execució, del motiu i de les unitats facturables.
`not_requested`, `excluded_by_caller`, `missing_required_input` i `source_unavailable` descriuen resultats diferents.
Una font absent no és una discrepància d'identitat ni un resultat de risc zero.

`attribute_evidence` descriu les evidències a nivell de camp, mentre que `risk` manté separades les dimensions d'identitat, contacte, dispositiu, comportament i xarxa de fraus.
Un correu electrònic compartit, un dispositiu compartit o un altre identificador compartit és una connexió observada, no una prova que dos comptes pertanyin a la mateixa persona ni que hagin comès frau.
`recommendation` és la recomanació de la comprovació; no canvia l'estat d'un altre registre.
Els resultats de l'enriquiment social apareixen sota `enrichment`, amb els resultats no disponibles diferenciats dels completats.

## Xarxa global contra el frau

Selecciona `networks_cross_org` per consultar els identificadors compatibles de correu electrònic, de telèfon i de document amb un espai de noms correcte a la xarxa compartida.
La consulta requereix el pla Enterprise i que el mode de compartició de la teva organització estigui configurat a `global`.
Si no es compleix alguna d'aquestes condicions, el pla informa del mòdul amb `available: false` i `availability_reason: "entitlement_required"`, i una comprovació que el selecciona l'omet amb l'estat `skipped` i el motiu `entitlement_required`.
El mateix motiu s'aplica quan Networks no està habilitat per a la teva organització.
Les aplicacions de sandbox no estan sotmeses al pla ni al mode de compartició: amb un identificador compatible, el mòdul s'executa i retorna un resultat de mostra buit.
La consulta utilitza el pressupost de lectures existent de l'organització i en deixa un registre d'auditoria.
No té cap cobrament per consulta.
Planificar una comprovació no consulta l'índex compartit ni consumeix el seu pressupost de lectures.

`network.cross_organization` conté `signals_checked` i les `insights` agregades divulgades quan la comprovació finalitza.
Cada element conté el tipus de senyal, les classes de resultat, el nombre de contribuidors, la franja de recència i, només si la divulgació està habilitada, les categories de sector.
Mai no identifica una altra organització, un altre compte, una altra persona ni una altra verificació.
Els resultats per sota del llindar de divulgació s'ometen; una llista buida no demostra l'absència d'historial de frau.
Un senyal compartit divulgat activa una recomanació de revisió, mai un rebuig automàtic ni una coincidència d'identitat.

Una consulta no disponible informa del seu motiu per separat d'una consulta completada buida.
Si la teva organització perd més endavant l'accés a la xarxa entre organitzacions, per exemple després d'un canvi de pla o quan la compartició ja no és `global`, la recuperació del resultat, els reintents i els detalls de la sessió amaguen les agregacions compartides i les evidències de risc derivades.
La recomanació original es manté com a decisió històrica; les lectures no canvien l'estat de la verificació.

## Sessions, reintents i cobraments

`check_id` recupera el resultat emmagatzemat mitjançant [Obté una comprovació de frau](https://docs.didit.me/ca/standalone-apis/fraud-check-result.md).
Quan hi és, `request_id` identifica la seva sessió de verificació nativa.
Les versions `2026-09-14`, `2026-09-14.1` i `2026-09-14.2` sempre creen aquesta sessió, fins i tot quan només se selecciona l'historial de xarxa privada.

Reutilitzar `client_reference` amb el mateix cos de sol·licitud retorna el resultat original sense una altra execució ni cobrament mentre la comprovació existeixi.
Un cos diferent amb la mateixa referència retorna `409`.
Si l'execució encara està en curs, torna a enviar la mateixa sol·licitud després de l'interval indicat a `Retry-After` de la resposta.
Si se suprimeix la verificació associada, també se suprimeix el resultat de la comprovació de frau; la recuperació retorna `404`.
Una comprovació suprimida durant l'execució no pot publicar un resultat completat.

Els preus provenen de les tarifes prepagades o de contracte vigents de la teva organització.
Els mòduls no disponibles i omesos no es cobren, i l'historial de xarxa privada no té cap cobrament per comprovació.
Les comprovacions de sandbox utilitzen respostes de mostra sense crides de pagament a proveïdors ni cobraments.


## OpenAPI

````yaml ca/openapi-25.json POST /v3/fraud/checks/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de verificació d'identitat. Autentica't amb la capçalera x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/fraud/checks/:
    post:
      tags:
        - Fraud Check
      summary: Executa un control de frau
      description: >-
        Envia un o més identificadors tipats i rep normalització, enriquiment
        actualitzat, validació fidedigna on el país i el tipus d'identificador
        estiguin coberts, dimensions de risc independents i una recomanació en
        una única resposta.


        Aquests perfils admeten comprovacions d'identificadors. La vinculació
        d'identitat basada en selfie (`biometric_identity`) requereix la versió
        de perfil `2026-09-14.2` i un CPF brasiler; s'executa només amb el
        consentiment de l'usuari i quan la teva organització hi té dret. Les
        versions anteriors l'informen com a `not_available_in_profile_version`.
        Els mòduls que no es poden executar s'informen com a omesos amb un motiu
        determinista; una font que no hagi pogut respondre mai s'informa com a
        no coincidència d'identitat.
      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: >-
            Conflicte, retornat sense cap càrrec: el `client_reference` ja
            s'havia utilitzat amb un cos de sol·licitud diferent; una
            comprovació amb el mateix `client_reference` encara s'està executant
            (reintenta després dels segons indicats a `Retry-After` amb la
            mateixa referència); o la verificació en la qual es registra aquesta
            comprovació s'ha suprimit abans que la comprovació es completés.
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                required:
                  - error
              examples:
                different_body:
                  summary: Referència reutilitzada amb un cos diferent
                  value:
                    error: >-
                      client_reference has already been used with a different
                      request body.
                still_running:
                  summary: >-
                    Una comprovació amb aquesta referència encara s'està
                    executant
                  value:
                    error: >-
                      A check with this client_reference is already running.
                      Retry with the same reference later.
                verification_deleted:
                  summary: >-
                    La verificació s'ha suprimit abans que es completés la
                    comprovació
                  value:
                    error: This verification was deleted before the check completed.
          headers:
            Retry-After:
              description: >-
                Segons d'espera abans de reintentar, enviat quan una comprovació
                amb el mateix `client_reference` encara s'està executant.
              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: >-
            La teva pròpia referència per a aquesta comprovació. Actua també com
            a clau d'idempotència: reutilitzar-la amb el mateix cos retorna la
            comprovació original sense tornar a executar ni facturar els mòduls;
            reutilitzar-la amb un cos diferent retorna un 409.
          maxLength: 255
        profile:
          type: string
          minLength: 1
          default: standard
          description: >-
            ID del perfil d'orquestració. Per defecte és el perfil `standard` de
            Didit.
          maxLength: 64
        profile_version:
          type: string
          minLength: 1
          description: >-
            Fixa una versió de perfil congelada. Per defecte s'utilitza la
            versió actual del 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: Sessió de verificació nativa creada per a aquesta comprovació.
        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 JPEG, PNG o WebP codificat en Base64, de fins a 6 MB. Sense
            imatge de referència ni URL.
          maxLength: 8388672
        identifiers:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckIdentifierRequest'
          description: Un o més identificadors tipats. Amb un és suficient.
          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 on el subjecte afirma trobar-se. Només contextual - mai una
            prova de titularitat de la identitat.
          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` - Pendent
        * `running` - En execució
        * `completed` - Completat
        * `failed` - Fallit
    FraudCheckInput:
      type: object
      properties:
        reference:
          type: string
          description: Àlies ofuscat per a l'identificador enviat.
        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: >-
            Cert quan la sol·licitud ha proporcionat tot el que aquesta dimensió
            necessitava i la plataforma encara no ha pogut respondre-la. Mai es
            recomana aprovar una comprovació d'aquest tipus basant-se en la
            solidesa de les dimensions que sí que han respost.
        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` - Revisar
        * `reject` - Rebutjar
    FraudNextActionEnum:
      enum:
        - none
        - manual_review
        - step_up
        - resubmit_capture
      type: string
      description: |-
        * `none` - Cap
        * `manual_review` - Revisió manual
        * `step_up` - Verificació addicional
        * `resubmit_capture` - Tornar a enviar captura
    FraudCheckIdentifierRequest:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/FraudTypeEnum'
          description: >-
            Tipus d'identificador. Determina quins camps de l'espai de noms són
            obligatoris.


            * `email` - Correu electrònic

            * `phone` - Telèfon

            * `national_id` - Document d'identitat nacional

            * `tax_number` - Número d'identificació fiscal

            * `passport_number` - Número de passaport

            * `driving_licence_number` - Número de permís de conduir

            * `residence_permit_number` - Número de permís de residència

            * `voter_id` - ID electoral

            * `external_id` - ID extern
        value:
          type: string
          minLength: 1
          description: El valor de l'identificador, en qualsevol format habitual.
          maxLength: 255
        country:
          type: string
          description: >-
            País emissor ISO-3166 alpha-2 o alpha-3. Obligatori per a tipus
            d'identificador governamental: els mateixos dígits representen
            persones diferents en països diferents.
          maxLength: 3
        issuer:
          type: string
          description: >-
            Autoritat emissora opcional o emissor subnacional, quan el país per
            si sol no permet identificar-lo unívocament.
          maxLength: 128
      required:
        - type
        - value
    FraudCheckAttributesRequest:
      type: object
      description: >-
        Atributs de corroboració. Tots opcionals; amplien la cobertura del
        mòdul.
      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` - Normalització
        * `email_risk` - Risc de correu electrònic
        * `email_social` - Aspectes socials del correu electrònic
        * `phone_social` - Aspectes socials del telèfon
        * `phone_risk` - Risc de telèfon
        * `ip_risk` - Risc d'IP
        * `database_validation` - Validació en bases de dades
        * `networks_same_org` - Xarxes de la mateixa organització
        * `networks_cross_org` - Xarxes entre organitzacions
        * `biometric_identity` - Identitat 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` - Correu electrònic
        * `phone` - Telèfon
        * `national_id` - Document d'identitat nacional
        * `tax_number` - Identificador fiscal
        * `passport_number` - Número de passaport
        * `driving_licence_number` - Número de permís de conduir
        * `residence_permit_number` - Número de permís de residència
        * `voter_id` - Identificador de votant
        * `external_id` - ID extern
    FraudAvailabilityEnum:
      enum:
        - available
        - not_requested
        - no_reference
        - insufficient_history
        - unsupported_region
        - source_unavailable
      type: string
      description: |-
        * `available` - Disponible
        * `not_requested` - No sol·licitat
        * `no_reference` - Sense referència
        * `insufficient_history` - Historial insuficient
        * `unsupported_region` - Regió no admesa
        * `source_unavailable` - Font no disponible
    FraudStatusEnum:
      enum:
        - planned
        - completed
        - skipped
        - failed
      type: string
      description: |-
        * `planned` - Planificat
        * `completed` - Completat
        * `skipped` - Omès
        * `failed` - Fallit
    FraudDimensionEnum:
      enum:
        - identity
        - contact
        - device_network
        - behavioral
        - fraud_network
      type: string
      description: |-
        * `identity` - Identitat
        * `contact` - Contacte
        * `device_network` - Dispositiu i xarxa
        * `behavioral` - Conductual
        * `fraud_network` - Xarxa de frau
    FraudBandEnum:
      enum:
        - low
        - medium
        - high
        - unknown
      type: string
      description: |-
        * `low` - Baix
        * `medium` - Mitjà
        * `high` - Alt
        * `unknown` - Desconegut
    FraudResultEnum:
      enum:
        - match
        - mismatch
        - inconclusive
        - no_reference
      type: string
      description: |-
        * `match` - Coincidència
        * `mismatch` - Discrepància
        * `inconclusive` - No concloent
        * `no_reference` - Sense referència
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clau d'API de la teva aplicació, des de Developers -> API keys a la
        Business Console. La clau primària té accés complet. Una clau amb nom
        pot tenir l'abast limitat: cap, lectura o escriptura per recurs,
        limitada a determinats fluxos de treball o a sessions aprovades, a una
        llista d'adreces IP i a una data de caducitat. 401 significa que la clau
        és incorrecta, revocada o caducada; 403 significa que no s'ha enviat cap
        clau, que la clau no té accés a aquest recurs o acció, o que la
        sol·licitud prové d'una adreça fora de la seva llista d'IP; 404 en una
        ruta de sessió significa que la sessió està fora dels fluxos de treball
        o estats de la clau. Una clau sense accés a fitxers multimèdia rep els
        URL d'imatge, vídeo i PDF com a null, i una clau sense permís
        d'escriptura de sessions rep els enllaços de sessió i els tokens com a
        null. Consulta https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: El token d'accés de credencials de client de l'aplicació.

````

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