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

# Transaktionsüberwachung Regelbibliothek API, 150+ Presets

> Didit-Regelbibliothek per API abrufen: 150+ Transaktionsregeln für Sanktionen, Geräte, Krypto und Travel Rule, inklusive Installationsstatus.

Prompt für die API zum Auflisten der Regelbibliothek
Prompt in die Zwischenablage kopieren

<pre>
  \`Browse Didit's preset transaction-monitoring rule library.

  Endpoint:
  GET [https://verification.didit.me/v3/transactions/rules/library/](https://verification.didit.me/v3/transactions/rules/library/)

  Authentication:
  Use the x-api-key header with my Didit API key.

  Query parameters (all optional): bundle, category, search, limit, offset.

  Behavior:

  * Returns every library preset with its full configuration (conditions, aggregation, actions) and an is\_installed flag for this application.
  * Check the library before building a custom rule: if an equivalent preset exists, install it via POST /v3/transactions/rules/install/ instead of recreating its logic.
  * Bundles group related presets, e.g. finance, aml\_ctf, anomaly\_detection, fatf, device\_intelligence, crypto\_monitoring, travel\_rule, responsible\_gaming, e\_commerce.\`
</pre>

Einfügen in


## OpenAPI

````yaml de/openapi-25.json GET /v3/transactions/rules/library/
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/transactions/rules/library/:
    get:
      tags:
        - Transactions
      summary: Regelbibliothek auflisten
      description: >-
        Durchsuchen Sie die vollständige Bibliothek vordefinierter Regeln (150+
        Regeln) mit der vollständigen Konfiguration jedes Eintrags und einem
        `is_installed`-Flag für diese Anwendung. Filtern Sie nach Paket,
        Kategorie oder Freitextsuche. Eine Bibliotheksregel, deren Bedingungen
        Daten lesen, die die Regel-Engine noch nicht auswerten kann, wird
        zurückgehalten, bis sie ausgeführt werden kann. Zurückgehaltene Regeln
        werden nicht aufgeführt.
      operationId: listTransactionRuleLibrary
      parameters:
        - name: bundle
          in: query
          required: false
          schema:
            type: string
          description: >-
            Nach Paket filtern, z. B. finance, aml_ctf, crypto_monitoring,
            travel_rule
        - name: category
          in: query
          required: false
          schema:
            type: string
          description: Nach Kategorie filtern
        - name: search
          in: query
          required: false
          schema:
            type: string
          description: >-
            Übereinstimmung ohne Berücksichtigung von Groß-/Kleinschreibung mit
            Titel und Beschreibung
        - name: limit
          in: query
          required: false
          schema:
            type: integer
          description: Seitengröße
        - name: offset
          in: query
          required: false
          schema:
            type: integer
          description: Seiten-Offset
      responses:
        '200':
          description: Paginierte Bibliothekseinträge.
          content:
            application/json:
              schema:
                type: object
                properties:
                  count:
                    type: integer
                  next:
                    type: string
                    nullable: true
                  previous:
                    type: string
                    nullable: true
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/TransactionRuleLibraryEntry'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/transactions/rules/library/?bundle=finance'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            for item in client.transactions.rules.list_library():
                print(item)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

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

            for await (const item of didit.transactions.rules.listLibrary()) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.Transactions.Rules.ListLibraryAutoPaging(ctx, didit.TransactionsRulesListLibraryParams{})\nfor iter.Next() {\n\tfmt.Printf(\"%+v\\n\", iter.Current())\n}\nif err := iter.Err(); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            for (var item : client.transactions().rules().listLibrary()) {
                System.out.println(item);
            }
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

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

            foreach ($didit->transactions->rules->listLibrary() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            didit.transactions.rules.list_library.auto_paging_each do |item|
              puts item.to_h
            end
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            await foreach (var item in await
            client.Transactions.Rules.ListLibraryAsync())

            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    TransactionRuleLibraryEntry:
      type: object
      properties:
        library_key:
          type: string
        title:
          type: string
        description:
          type: string
          nullable: true
        category:
          type: string
        evaluation_mode:
          type: string
          enum:
            - ALL
            - ANY
        scope:
          $ref: '#/components/schemas/TransactionRuleScope'
        conditions:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleCondition'
        aggregation:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleAggregation'
        actions:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleAction'
        metadata:
          type: object
        bundle:
          type: string
          nullable: true
          description: >-
            Funktionale Familie, z. B. finance, aml_ctf, crypto_monitoring,
            travel_rule, responsible_gaming.
        tags:
          type: array
          items:
            type: string
        industries:
          type: array
          items:
            type: string
        source:
          type: string
        is_installed:
          type: boolean
          description: >-
            Gibt an, ob diese Voreinstellung derzeit in der Anwendung
            installiert ist.
    TransactionRuleScope:
      type: object
      properties:
        transaction_types:
          type: array
          items:
            type: string
          description: >-
            Auf Transaktionstypen einschränken, z. B. finance, kyc, travel_rule,
            user_event. Leer oder fehlend = keine Einschränkung.
        directions:
          type: array
          items:
            type: string
            enum:
              - INBOUND
              - OUTBOUND
          description: >-
            Auf Transaktionsrichtungen einschränken (beim Schreiben ohne
            Berücksichtigung von Groß-/Kleinschreibung).
        action_types:
          type: array
          items:
            type: string
          description: Auf Ihre action_type-Werte einschränken, z. B. withdrawal, deposit.
      description: >-
        Für welche Transaktionen die Regel gilt. Es werden nur diese drei
        Schlüssel akzeptiert.
    TransactionRuleCondition:
      type: object
      required:
        - field
        - operator
      properties:
        field:
          type: string
          description: >-
            Zu evaluierender Transaktionsfeldpfad. Kernfelder: amount, currency,
            direction, action_type, score, severity, transaction_type,
            payment_details, preferred_currency_amount (weicht auf
            amount_in_default_currency aus), default_currency_code,
            subject_country, counterparty_country, subject_vendor_data,
            counterparty_vendor_data, subject_device_fingerprint,
            counterparty_device_fingerprint, subject_browser_family,
            subject_browser_version, subject_platform, subject_accept_language,
            subject_session_age_ms, subject_ip_country, counterparty_ip_country,
            subject_ip_address, counterparty_ip_address,
            subject_payment_method_type, subject_payment_method_country,
            subject_payment_method_fingerprint,
            subject_payment_method_account_id (und die
            counterparty_payment_method_*-Äquivalente), travel_rule_status,
            travel_rule_required, travel_rule_obligations_count,
            counterparty_dd_status (Ihre Entscheidung zur
            Travel-Rule-Gegenpartei: APPROVED, RESTRICTED oder BLOCKED, wobei
            eine Entität der Marke folgt), counterparty_risk_level (LOW, MEDIUM
            oder HIGH; HIGH, solange Ihr eigenes Gegenparteien-Screening
            markiert ist), counterparty_jurisdiction (das Land des VASP der
            Gegenpartei), counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE
            oder UNKNOWN), subject_days_since_previous_transaction, tags und
            custom_values.<key> für jeden Schlüssel, der in custom_properties
            bei der Transaktionserstellung übermittelt wurde. Ländercode-Felder
            akzeptieren ISO-2 oder ISO-3; beide Seiten werden vor dem Vergleich
            auf ISO-3 normalisiert.
        operator:
          type: string
          enum:
            - eq
            - ne
            - gt
            - gte
            - lt
            - lte
            - in
            - not_in
            - contains
            - not_contains
            - contains_any
            - regex
            - fuzzy_match
            - exists
            - is_not_empty
            - is_not_null
            - not_exists
            - is_empty
            - is_null
          description: >-
            Vergleichsoperator. in/not_in prüfen die Zugehörigkeit (value kann
            eine Liste oder ein einzelner Skalar sein). contains/not_contains
            sind Substring-Prüfungen ohne Berücksichtigung der
            Groß-/Kleinschreibung gegen einen String-Wert. contains_any
            akzeptiert eine Liste von Strings und stimmt überein, wenn ein
            beliebiger Eintrag ein Substring des Feldwerts ohne Berücksichtigung
            der Groß-/Kleinschreibung ist. regex gleicht das Wertmuster mit dem
            Feld ab. fuzzy_match vergleicht mit dem Wert-String anhand des
            erforderlichen `score`-Schwellenwerts (0-100). gt/gte/lt/lte stimmen
            niemals überein, wenn eine der beiden Seiten fehlt.
            exists/is_not_empty/is_not_null (Aliase) und
            not_exists/is_empty/is_null (Aliase) sind Vorhandenseinsprüfungen,
            die `value` ignorieren.
        value:
          description: >-
            Vergleichswert. Dessen Struktur hängt vom Operator und value_type
            ab; lassen Sie ihn bei Vorhandenseinsprüfungs-Operatoren weg. Jeder
            andere Operator erfordert einen Wert, der weder `null` noch eine
            leere Liste ist, andernfalls wird die Regel mit `400` abgelehnt.
            `contains_any` erfordert eine Liste von Strings, und `contains`,
            `not_contains` sowie `regex` erfordern einen einzelnen String.
        value_type:
          type: string
          enum:
            - list
            - field
            - relative_date
          description: >-
            Optionale Interpretation des Werts. `list`: Der Wert ist eine
            Listen-UUID und die Einträge der Liste werden zum Vergleichswert.
            `field`: Der Wert ist ein anderer Feldpfad, bei dem Feld für Feld
            verglichen wird. `relative_date`: Der Wert ist ein Objekt für ein
            relatives Datum, z. B. {"direction": "past", "unit": "days",
            "amount": 30}.
        score:
          type: number
          minimum: 0
          maximum: 100
          description: >-
            Erforderlich, wenn operator fuzzy_match ist: der
            Ähnlichkeitsschwellenwert von 0-100.
        group_index:
          type: integer
          description: >-
            Optionale gruppierte Logik. Wenn eine Bedingung group_index enthält,
            bilden Bedingungen mit demselben Index eine Gruppe und die
            gruppierte Auswertung ersetzt evaluation_mode.
        group_logic:
          type: string
          enum:
            - AND
            - OR
          default: AND
          description: Wie Bedingungen INNERHALB einer Gruppe kombiniert werden.
        groups_logic:
          type: string
          enum:
            - AND
            - OR
          default: OR
          description: >-
            Wie Gruppenergebnisse GRUPPENÜBERGREIFEND kombiniert werden. Wird
            aus der ersten Bedingung gelesen.
      description: >-
        Eine Bedingung liest nur die ausgewertete Transaktion – sie filtert
        niemals das Aggregationsfenster.
    TransactionRuleAggregation:
      type: object
      required:
        - value
      properties:
        metric:
          type: string
          enum:
            - count
            - sum
            - max
            - min
            - avg
            - distinct_count
          default: count
          description: >-
            Wie die übereinstimmenden historischen Transaktionen aggregiert
            werden. unique_count wird als Alias von distinct_count akzeptiert.
        field:
          type: string
          default: amount
          description: >-
            Feld aggregiert nach sum/max/min/avg/distinct_count. Wird für count
            ignoriert.
        operator:
          type: string
          enum:
            - eq
            - ne
            - gt
            - gte
            - lt
            - lte
          default: eq
          description: Auf die berechnete Metrik angewendeter Vergleich.
        value:
          type: number
          description: Schwellenwert, mit dem die berechnete Metrik verglichen wird.
        window:
          type: string
          pattern: ^\d+(m|h|d)$
          default: 1d
          description: >-
            Rückblickzeitraum, der am txn_date der Transaktion endet: <N>m
            (MINUTEN, nicht Monate), <N>h (Stunden) oder <N>d (Tage), z. B. 30m,
            24h, 7d, 30d.
        filters:
          type: object
          additionalProperties: true
          description: >-
            Grenzt ein, welche historischen Transaktionen aggregiert werden.
            Schlüssel sind Feldpfade aus dem Bedingungsfeldkatalog; ein Wert von
            „__current__“ wird zum Wert desselben Felds der ausgewerteten
            Transaktion aufgelöst (z. B. grenzt {"subject_vendor_data":
            "__current__"} das Zeitfenster auf dasselbe Subjekt ein), und ein
            Listenwert bedeutet Mitgliedschaft. Datensätze ohne den gruppierten
            Wert werden niemals zusammen gruppiert: Wenn die ausgewertete
            Transaktion keinen Wert für ein „__current__“-Feld aufweist (keine
            Gegenpartei, kein Geräte-Fingerprint), stimmt die Aggregation
            unabhängig von ihrem Operator nicht überein. Filter vergleichen NUR
            auf Gleichheit oder Mitgliedschaft – es gibt keinen lt/gte-Filter,
            daher kann ein Bereich wie „historische Transaktionen unter 10.000“
            hier nicht ausgedrückt werden. Wenden Sie den Bereich stattdessen
            auf die Metrik an (Metrik max mit dem Operator lt hält jede
            Transaktion im Zeitfenster unter dem Schwellenwert).
      description: >-
        Velocity-Prüfung über die historischen Transaktionen der Anwendung
        innerhalb des Zeitfensters. Jeder Aggregationseintrag muss
        übereinstimmen, damit die Regel zutrifft, unabhängig von
        evaluation_mode. Eine Aggregation schränkt nur das Zeitfenster ein; die
        zu bewertende Transaktion wird durch Scope und Bedingungen
        eingeschränkt. Wiederholen Sie daher direction, currency oder
        transaction_type in beiden Teilen, wenn die Regel diese vorsieht.
    TransactionRuleAction:
      oneOf:
        - $ref: '#/components/schemas/TransactionRuleActionAddScore'
        - $ref: '#/components/schemas/TransactionRuleActionChangeStatus'
        - $ref: '#/components/schemas/TransactionRuleActionAddTags'
        - $ref: '#/components/schemas/TransactionRuleActionAddNote'
        - $ref: '#/components/schemas/TransactionRuleActionAddToList'
        - $ref: '#/components/schemas/TransactionRuleActionOpenCase'
      discriminator:
        propertyName: type
        mapping:
          add_score: '#/components/schemas/TransactionRuleActionAddScore'
          change_status: '#/components/schemas/TransactionRuleActionChangeStatus'
          add_tags: '#/components/schemas/TransactionRuleActionAddTags'
          add_note: '#/components/schemas/TransactionRuleActionAddNote'
          add_to_list: '#/components/schemas/TransactionRuleActionAddToList'
          open_case: '#/components/schemas/TransactionRuleActionOpenCase'
      description: >-
        Eine Regelaktion. Eine Regel kann mehrere enthalten; alle werden
        zusammen angewendet, wenn sie zutrifft. Regeln im TEST-Modus zeichnen
        auf, was sie getan hätten, ohne eine Aktion anzuwenden.
    TransactionRuleActionAddScore:
      type: object
      required:
        - type
        - value
      properties:
        type:
          type: string
          enum:
            - add_score
        value:
          type: integer
          description: >-
            Punkte, die zum Risiko-Score der Transaktion hinzugefügt werden.
            Kann negativ sein.
      description: >-
        Punkte zum kumulativen Risiko-Score der Transaktion hinzufügen; der
        Gesamtwert entscheidet anhand der Prüfungs-/Ablehnungsschwellenwerte der
        Anwendung über den Status.
    TransactionRuleActionChangeStatus:
      type: object
      required:
        - type
        - value
      properties:
        type:
          type: string
          enum:
            - change_status
        value:
          type: string
          enum:
            - APPROVED
            - IN_REVIEW
            - DECLINED
            - AWAITING_USER
          description: >-
            Sofort festzulegender Status, unabhängig vom Score. Alias-Schlüssel:
            status.
        workflow_id:
          type: string
          format: uuid
          description: >-
            ERFORDERLICH, wenn der Wert AWAITING_USER ist: der
            Verifizierungs-Workflow, den das Subjekt ausfüllen soll.
            Alias-Schlüssel: remediation_workflow_id. Didit erstellt eine
            gehostete Remediation-Sitzung für das Subjekt, wenn die Regel
            ausgelöst wird.
      description: >-
        Den Transaktionsstatus direkt festlegen. DECLINED hat unter den
        zutreffenden Regeln immer Vorrang.
    TransactionRuleActionAddTags:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - add_tags
        tag_uuid:
          type: string
          format: uuid
          description: Vorhandenes Anwendungs-Tag, das angehängt werden soll.
        tag_name:
          type: string
          description: >-
            Name des anzuhängenden Tags; wird bei der ersten Verwendung erstellt
            (in Großbuchstaben gespeichert). Geben Sie tag_uuid oder tag_name
            an.
        tag_color:
          type: string
          description: >-
            Hex-Farbe, die verwendet wird, wenn tag_name ein neues Tag erstellt,
            z. B. #007AFE.
      description: Ein Anwendungs-Tag an die übereinstimmende Transaktion anhängen.
    TransactionRuleActionAddNote:
      type: object
      required:
        - type
        - note
      properties:
        type:
          type: string
          enum:
            - add_note
        note:
          type: string
          description: >-
            Notiztext, der an die Transaktion angehängt ist (Autor: Rule
            Engine). Alias-Schlüssel: Wert.
      description: >-
        Eine automatisierte Analystennotiz an die übereinstimmende Transaktion
        anhängen.
    TransactionRuleActionAddToList:
      type: object
      required:
        - type
        - list_id
      properties:
        type:
          type: string
          enum:
            - add_to_list
        list_id:
          type: string
          format: uuid
          description: Liste, zu der vendor_data des Subjekts hinzugefügt werden soll.
      description: >-
        Fügen Sie die vendor_data der betroffenen Person einer Sperrliste,
        Positivliste oder benutzerdefinierten Liste hinzu.
    TransactionRuleActionOpenCase:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - open_case
        blueprint:
          type: string
          format: uuid
          description: >-
            UUID der Fallvorlage; standardmäßig die Standardvorlage der
            Anwendung.
        grouping:
          type: string
          enum:
            - by_applicant
            - by_rule_and_applicant
          description: >-
            Gibt an, ob wiederholte Übereinstimmungen zu einem Fall pro
            Antragsteller oder zu einem Fall pro Regel+Antragsteller
            zusammengeführt werden.
        attach_matched_transaction:
          type: boolean
          description: Die übereinstimmende Transaktion an den Fall anhängen.
      description: >-
        Einen Untersuchungsfall eröffnen (oder zu einem hinzufügen). Nur die
        erste open_case-Aktion einer Regel wird angewendet.
  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.

````

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