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

# Betrugsprüfung planen

> Mit Didit Eingaben validieren und die Kosten ausgewählter Fraud-Check-Prüfungen schätzen, bevor du die Anfrage ausführst.

Senden Sie denselben Body, den Sie für [Fraud Check](https://docs.didit.me/de/standalone-apis/fraud-check.md) verwenden möchten.
Die Planung erstellt weder einen Check noch eine Sitzung, ruft keinen Anreicherungsanbieter auf, liest keinen Netzwerkverlauf und berechnet nichts.

Jedes Modul trennt `available` von `will_run`.
`availability_reason` erklärt, ob die übergebenen Eingaben die Ausführung unterstützen können, während `selection_reason` erklärt, warum es ausgewählt wird oder nicht.
Halten Sie nicht verfügbare Schalter sichtbar und zeigen Sie deren Eingabeanforderungen an.

`networks_cross_org` erfordert den Enterprise-Tarif und einen auf `global` gesetzten Freigabemodus für Ihre Organisation.
Ohne beides oder wenn Networks für Ihre Organisation nicht aktiviert ist, meldet die Planung das mit `available: false` und `availability_reason: "entitlement_required"`.
Ein Check, der dieses Modul auswählt, überspringt es mit demselben Grund.
Sandbox-Anwendungen unterliegen weder dem Tarif noch dem Freigabemodus: Mit einer unterstützten Kennung wird das Modul ausgeführt und liefert ein leeres Beispielergebnis.

`estimated_price` ist eine Dezimalzeichenkette in der zurückgegebenen `currency`.
Ein Preis mit dem Wert null bedeutet nicht verfügbar oder nicht bepreist, nicht kostenlos.
Die Gesamtschätzung auf oberster Ebene summiert die ausgewählten, ausführbaren Module; `can_afford` prüft zusätzlich die anwendbare Abrechnungsvereinbarung.
Planen Sie neu, nachdem Sie Kennungen, Kontext oder Auswahl geändert haben.
Die Ausführung prüft die Berechtigung zur Ausführung und die Preise erneut. Eine Planung ist daher keine Reservierung und keine Garantie, dass eine externe Quelle antwortet.


## OpenAPI

````yaml de/openapi-25.json POST /v3/fraud/checks/plan/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API für Ausweisverifizierung. Authentifizierung über den x-api-key-Header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/fraud/checks/plan/:
    post:
      tags:
        - Fraud Check
      summary: Betrugsprüfung planen
      description: >-
        Ausgewählte Prüfungen validieren und ihren Preis schätzen, ohne sie
        auszuführen, eine Sitzung zu erstellen oder abzurechnen.
      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: >-
            Ihre eigene Referenz für diese Prüfung. Dient gleichzeitig als
            Idempotenzschlüssel: Bei Wiederverwendung mit demselben Body wird
            die ursprüngliche Prüfung zurückgegeben, ohne die Module erneut
            auszuführen oder abzurechnen; bei Wiederverwendung mit einem anderen
            Body wird 409 zurückgegeben.
          maxLength: 255
        profile:
          type: string
          minLength: 1
          default: standard
          description: Orchestrierungsprofil-ID. Standardmäßig das Didit-Profil `standard`.
          maxLength: 64
        profile_version:
          type: string
          minLength: 1
          description: >-
            Eine eingefrorene Profilversion anpinnen. Standardmäßig die aktuelle
            Version des Profils.
          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: >-
            Base64-kodiertes JPEG-, PNG- oder WebP-Selfie, bis zu 6 MB. Kein
            Referenzbild oder keine URL.
          maxLength: 8388672
        identifiers:
          type: array
          items:
            $ref: '#/components/schemas/FraudCheckIdentifierRequest'
          description: Ein oder mehrere typisierte Bezeichner. Einer reicht aus.
          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: >-
            Land, in dem sich die Person laut eigener Angabe befindet. Dient nur
            dem Kontext – niemals als Nachweis dafür, dass die Person die
            Identität besitzt.
          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: |-
            Kennungstyp. Bestimmt, welche Namespace-Felder erforderlich sind.

            * `email` - E-Mail
            * `phone` - Telefon
            * `national_id` - Nationale ID
            * `tax_number` - Steuernummer
            * `passport_number` - Reisepassnummer
            * `driving_licence_number` - Führerscheinnummer
            * `residence_permit_number` - Aufenthaltstitelnummer
            * `voter_id` - Wähler-ID
            * `external_id` - Externe ID
        value:
          type: string
          minLength: 1
          description: Der Identifikatorwert in einem beliebigen gebräuchlichen Format.
          maxLength: 255
        country:
          type: string
          description: >-
            ISO-3166-Alpha-2- oder -Alpha-3-Code des Ausstellungslands.
            Erforderlich für behördliche Identifikatortypen: Dieselben Ziffern
            bezeichnen in verschiedenen Ländern unterschiedliche Personen.
          maxLength: 3
        issuer:
          type: string
          description: >-
            Optionale Ausstellungsbehörde oder subnationale Ausstellungsstelle,
            wenn das Land allein nicht eindeutig ist.
          maxLength: 128
      required:
        - type
        - value
    FraudCheckAttributesRequest:
      type: object
      description: >-
        Bestätigende Attribute. Alle sind optional; sie erweitern die
        Modulabdeckung.
      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` - Normalisierung
        * `email_risk` - E-Mail-Risiko
        * `email_social` - E-Mail-Social
        * `phone_social` - Telefon-Social
        * `phone_risk` - Telefonrisiko
        * `ip_risk` - IP-Risiko
        * `database_validation` - Datenbankvalidierung
        * `networks_same_org` - Netzwerke derselben Organisation
        * `networks_cross_org` - Organisationsübergreifende Netzwerke
        * `biometric_identity` - Biometrische Identität
    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` - Telefon
        * `national_id` - Nationale ID
        * `tax_number` - Steuernummer
        * `passport_number` - Reisepassnummer
        * `driving_licence_number` - Führerscheinnummer
        * `residence_permit_number` - Aufenthaltstitelnummer
        * `voter_id` - Wähler-ID
        * `external_id` - Externe ID
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Der API-Schlüssel Ihrer Anwendung, aus Entwickler -> API-Schlüssel in
        der Business Console. Der Primärschlüssel hat Vollzugriff. Ein benannter
        Schlüssel kann im Geltungsbereich eingeschränkt werden: keine, Lese-
        oder Schreibberechtigung pro Ressource, beschränkt auf bestimmte
        Workflows oder genehmigte Sitzungen, auf eine Liste von IP-Adressen und
        auf ein Ablaufdatum. 401 bedeutet, dass der Schlüssel falsch, widerrufen
        oder abgelaufen ist; 403 bedeutet, dass kein Schlüssel gesendet wurde,
        der Schlüssel keinen Zugriff auf diese Ressource oder Aktion hat oder
        die Anfrage von einer Adresse außerhalb seiner IP-Liste stammte; 404 bei
        einer Sitzungsroute bedeutet, dass die Sitzung außerhalb der Workflows
        oder Status des Schlüssels liegt. Ein Schlüssel ohne Medienzugriff
        erhält Bild-, Video- und PDF-URLs als null, und ein Schlüssel ohne
        Schreibberechtigung für Sitzungen erhält Sitzungslinks und Token als
        null. Siehe https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: Das Client-Credentials-Zugriffstoken der Anwendung.

````

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