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

# Planifier une vérification antifraude

> Valider les entrées et estimer les frais des contrôles Fraud Check sélectionnés, avant d'exécuter la requête avec l'API Didit.

Envoyez le même corps que celui que vous prévoyez d'utiliser pour [Fraud Check](https://docs.didit.me/fr/standalone-apis/fraud-check.md).
La planification ne crée aucune vérification ni aucune session, n'appelle aucun fournisseur d'enrichissement, ne consulte aucun historique réseau et ne facture rien.

Chaque module distingue `available` de `will_run`.
`availability_reason` indique si les entrées fournies permettent de l'utiliser, tandis que `selection_reason` explique pourquoi il est ou n'est pas sélectionné.
Gardez visibles les modules indisponibles et affichez leurs exigences en matière d'entrées.

`networks_cross_org` nécessite le forfait Enterprise et que le mode de partage de votre organisation soit défini sur `global`.
Sans l'un de ces deux éléments, ou lorsque Networks n'est pas activé pour votre organisation, la planification le signale avec `available: false` et `availability_reason: "entitlement_required"`.
Une vérification qui sélectionne ce module l'ignore avec la même raison.
Les applications sandbox ne sont soumises ni au forfait ni au mode de partage : avec un identifiant pris en charge, le module s'exécute et renvoie un résultat d'exemple vide.

`estimated_price` est une chaîne décimale exprimée dans la devise indiquée par `currency`.
Un prix null signifie indisponible ou non tarifé, et non gratuit.
L'estimation au niveau supérieur additionne les modules exécutables sélectionnés ; `can_afford` vérifie aussi la modalité de facturation applicable.
Replanifiez après avoir modifié les identifiants, le contexte ou les sélections.
L'exécution revérifie l'éligibilité et les tarifs. Un plan n'est donc ni une réservation ni une garantie qu'une source externe répondra.


## OpenAPI

````yaml fr/openapi-25.json POST /v3/fraud/checks/plan/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/fraud/checks/plan/:
    post:
      tags:
        - Fraud Check
      summary: Planifier une vérification de fraude
      description: >-
        Valider les vérifications sélectionnées et estimer leur prix sans
        exécuter les vérifications, créer une session ni facturer.
      operationId: plan_create
      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/FraudCheckPlan'
          description: ''
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FraudBadRequestErrorMessage'
          description: ''
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.fraud_checks.plan(
                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.plan({
              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.Plan(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().plan(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->plan([
                '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.plan(
              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.PlanAsync(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: >-
            Votre propre référence pour cette vérification. Fait également
            office de clé d'idempotence : la réutiliser avec le même corps de
            requête renvoie la vérification d'origine sans réexécuter ni
            refacturer les modules ; la réutiliser avec un corps différent
            renvoie une erreur 409.
          maxLength: 255
        profile:
          type: string
          minLength: 1
          default: standard
          description: >-
            ID du profil d'orchestration. Le profil `standard` de Didit est
            utilisé par défaut.
          maxLength: 64
        profile_version:
          type: string
          minLength: 1
          description: >-
            Épingler une version de profil gelée. Correspond par défaut à la
            version actuelle du profil.
          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
    FraudCheckPlan:
      type: object
      properties:
        profile_id:
          type: string
        profile_version:
          type: string
        modules:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckPlannedModule'
        estimated_price:
          type: string
          nullable: true
        currency:
          type: string
          nullable: true
        is_sandbox:
          type: boolean
        can_afford:
          type: boolean
      required:
        - can_afford
        - currency
        - estimated_price
        - is_sandbox
        - modules
        - profile_id
        - profile_version
    FraudBadRequestErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Bad Request - Invalid request data
    FraudCheckSubjectRequest:
      type: object
      properties:
        selfie:
          type: string
          minLength: 1
          description: >-
            Selfie au format JPEG, PNG ou WebP en Base64, jusqu'à 6 Mo. Aucune
            image de référence ni URL.
          maxLength: 8388672
        identifiers:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckIdentifierRequest'
          description: Un ou plusieurs identifiants typés. Un seul suffit.
          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: >-
            Pays dans lequel la personne déclare se trouver. Purement contextuel
            - ne constitue jamais une preuve de propriété de l'identité.
          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'
    FraudCheckPlannedModule:
      type: object
      properties:
        module:
          $ref: '#/components/schemas/FraudExcludeEnum'
        available:
          type: boolean
        availability_reason:
          type: string
          nullable: true
        will_run:
          type: boolean
        selection_reason:
          type: string
          nullable: true
        estimated_price:
          type: string
          nullable: true
      required:
        - availability_reason
        - available
        - estimated_price
        - module
        - selection_reason
        - will_run
    FraudCheckIdentifierRequest:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/FraudTypeEnum'
          description: |-
            Type d'identifiant. Détermine quels champs de namespace sont requis.

            * `email` - Email
            * `phone` - Téléphone
            * `national_id` - Identifiant national
            * `tax_number` - Numéro fiscal
            * `passport_number` - Numéro de passeport
            * `driving_licence_number` - Numéro de permis de conduire
            * `residence_permit_number` - Numéro de titre de séjour
            * `voter_id` - Carte d'électeur
            * `external_id` - Identifiant externe
        value:
          type: string
          minLength: 1
          description: La valeur de l'identifiant, dans tout format habituel.
          maxLength: 255
        country:
          type: string
          description: >-
            Pays de délivrance ISO-3166 alpha-2 ou alpha-3. Requis pour les
            types d'identifiants gouvernementaux : les mêmes chiffres
            correspondent à des personnes différentes selon les pays.
          maxLength: 3
        issuer:
          type: string
          description: >-
            Autorité de délivrance ou émetteur infranational optionnel, lorsque
            le pays seul n'est pas unique.
          maxLength: 128
      required:
        - type
        - value
    FraudCheckAttributesRequest:
      type: object
      description: >-
        Attributs corroborants. Tous optionnels ; ils élargissent la couverture
        des modules.
      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` - Normalisation
        * `email_risk` - Risque lié à l'e-mail
        * `email_social` - Réseaux sociaux de l'e-mail
        * `phone_social` - Réseaux sociaux du téléphone
        * `phone_risk` - Risque lié au téléphone
        * `ip_risk` - Risque lié à l'IP
        * `database_validation` - Validation en base de données
        * `networks_same_org` - Réseaux au sein de la même organisation
        * `networks_cross_org` - Réseaux inter-organisations
        * `biometric_identity` - Identité biométrique
    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` - Téléphone
        * `national_id` - Identifiant national
        * `tax_number` - Identifiant fiscal
        * `passport_number` - Numéro de passeport
        * `driving_licence_number` - Numéro de permis de conduire
        * `residence_permit_number` - Numéro de titre de séjour
        * `voter_id` - Identifiant d'électeur
        * `external_id` - Identifiant externe
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: Le token d'accès client-credentials de l'application.

````

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