> ## 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überwachungsregel per API erstellen (KYT) > Eigene KYT-Regel mit Didit per API erstellen: Bedingungen, Velocity-Fenster, Aktionen. Im TEST-Modus anlegen, backtesten, dann aktivieren. API-Prompt zum Erstellen einer Regel Prompt in die Zwischenablage kopieren \

\`Create a custom transaction-monitoring rule on my Didit application.

Endpoint:
POST https://verification.didit.me/v3/transactions/rules/

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

Request body (application/json):
\{
"title": "Structuring - inbound (custom)",   // required, unique per application - duplicate -> 400
"description": "20+ inbound EUR transfers, all under 10,000 EUR, 30 days",
"category": "finance",                        // required: finance, aml_ctf, anomaly_detection, fatf, device_intelligence, crypto_monitoring, travel_rule, responsible_gaming, e_commerce, ...
"mode": "TEST",                               // required: TEST (recommended start - evaluates, never affects transactions), ACTIVE, DISABLED
"evaluation_mode": "ALL",                     // ALL = every condition must match, ANY = at least one
"scope": {"transaction_types": ["finance"], "directions": ["INBOUND"]},  // constrains the transaction being evaluated; optional keys: transaction_types, directions (INBOUND/OUTBOUND), action_types
"conditions": [                               // read the transaction being evaluated, never the history window
\{"field": "currency", "operator": "eq", "value": "EUR"},
\{"field": "amount", "operator": "lt", "value": 10000}
],
"aggregation": [                              // velocity over the history window: ALL entries must match
\{"metric": "count", "operator": "gte", "value": 20, "window": "30d",
 "filters": {"direction": "INBOUND", "transaction_type": "finance", "currency": "EUR", "subject_vendor_data": "__current__"}},
\{"metric": "max", "field": "amount", "operator": "lt", "value": 10000, "window": "30d",
 "filters": {"direction": "INBOUND", "transaction_type": "finance", "currency": "EUR", "subject_vendor_data": "__current__"}}
],
"actions": [{"type": "add_score", "value": 35}]
}

Schema essentials:
\- Condition operators: eq, ne, gt, gte, lt, lte, in, not_in, contains, not_contains, contains_any (list of strings), regex, fuzzy_match (needs "score" 0-100), exists/is_not_empty/is_not_null, not_exists/is_empty/is_null.
\- Condition fields include amount, preferred_currency_amount, direction, action_type, payment_details, subject_vendor_data, counterparty_country, subject_device_fingerprint, subject_payment_method_*, travel_rule_status, tags, and custom_values. for your own custom_properties.
\- value_type turns "value" into a List UUID ("list"), another field path ("field"), or a relative date ("relative_date").
\- Aggregation windows: m (MINUTES), h, d. A filter value of "__current__" means same-as-the-evaluated-transaction. Records without the grouped value are never grouped together: when the evaluated transaction has no value for a "__current__" field (no counterparty, no device fingerprint), that aggregation does not match, whatever its operator.
\- Conditions and aggregation filters are NOT interchangeable. A condition constrains only the transaction being evaluated; an aggregation filter constrains only the historical window, and it compares by equality or list membership - there is no lt/gte filter. Express a range over the window as a max/min aggregation (e.g. max amount lt 10000 with currency pinned to EUR keeps every transaction in that window under 10,000 EUR), and repeat direction/currency/transaction_type on BOTH halves when the rule promises them - otherwise the rule fires on transactions it never meant to cover.
\- Actions: add_score {value}, change_status {value, workflow_id (REQUIRED for AWAITING_USER)}, add_tags {tag_uuid|tag_name, tag_color}, add_note {note}, add_to_list {list_id}, open_case {blueprint, grouping, attach_matched_transaction}.

Recommended workflow:
1\. Create in mode TEST.
2\. POST /v3/transactions/rules/backtest/ with the SAME conditions, aggregation, evaluation_mode and scope to see matches over your history. Omitted conditions, aggregation and scope add no constraints of their own; dropping scope can include directions or transaction types the saved rule skips. Omitted evaluation_mode defaults to ALL (which can reduce matches for an ANY rule), and omitted period_days defaults to 90 days, not unlimited history.
3\. PATCH the rule to mode ACTIVE once the numbers look right.

Sandbox fixtures for this example: at least 20 inbound EUR finance transactions for the same subject within 30 days, each with raw amount below 10000. No normalized amount is required. Sandbox ingestion does not evaluate rules; call backtest explicitly.

Failure modes:
\- 400 - duplicate title, unknown operator/metric, malformed window, invalid scope direction, contains_any without a list, fuzzy_match without a score, or AWAITING_USER without workflow_id. The body names the exact index and problem.
\- 401 - missing or malformed x-api-key.

Full guide: /transaction-monitoring/rules-api.`

\
Einfügen in ## OpenAPI ````yaml de/openapi-25.json POST /v3/transactions/rules/ 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/: post: tags: - Transactions summary: Regel erstellen description: >- Erstellen Sie eine benutzerdefinierte (CUSTOM) Transaktionsüberwachungsregel. Titel sind pro Anwendung eindeutig (Duplikat -> 400). Eine `change_status`-Aktion, die auf `AWAITING_USER` abzielt, muss `workflow_id` enthalten. Regeln, die im Modus ACTIVE erstellt wurden, gelten sofort für neue Transaktionen – der empfohlene Workflow besteht darin, sie im Modus TEST zu erstellen, ein Backtesting durchzuführen und den Modus anschließend auf ACTIVE umzustellen. Um eine Bibliotheksregel zu ändern, erstellen Sie sie als Kopie: Senden Sie die Definition der Bibliotheksregel mit `metadata.based_on` (ihr Bibliotheksschlüssel) und `metadata.based_on_rule_uuid`. operationId: createTransactionRule requestBody: required: true content: application/json: schema: $ref: '#/components/schemas/TransactionRuleCreateRequest' example: title: Structuring - inbound (custom) description: 20+ inbound EUR transfers, all under 10,000 EUR, 30 days category: finance mode: TEST evaluation_mode: ALL scope: transaction_types: - finance directions: - INBOUND conditions: - field: currency operator: eq value: EUR - field: amount operator: lt value: 10000 aggregation: - metric: count operator: gte value: 20 window: 30d filters: direction: INBOUND transaction_type: finance subject_vendor_data: __current__ currency: EUR - metric: max field: amount operator: lt value: 10000 window: 30d filters: direction: INBOUND transaction_type: finance subject_vendor_data: __current__ currency: EUR actions: - type: add_score value: 35 responses: '201': description: Die erstellte Regel. content: application/json: schema: $ref: '#/components/schemas/TransactionRuleDetail' '400': description: >- Validierungsfehler – doppelter Titel, unbekannter Operator/Metrik, fehlerhaftes Fenster, ungültige Scope-Richtung oder AWAITING_USER ohne workflow_id. content: application/json: schema: type: object example: title: - A rule with this name already exists. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: >- curl -X POST 'https://verification.didit.me/v3/transactions/rules/' \ -H 'x-api-key: YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{"title": "Structuring - inbound (custom)", "description": "20+ inbound EUR transfers, all under 10,000 EUR, 30 days", "category": "finance", "mode": "TEST", "evaluation_mode": "ALL", "scope": {"transaction_types": ["finance"], "directions": ["INBOUND"]}, "conditions": [{"field": "currency", "operator": "eq", "value": "EUR"}, {"field": "amount", "operator": "lt", "value": 10000}], "aggregation": [{"metric": "count", "operator": "gte", "value": 20, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}}, {"metric": "max", "field": "amount", "operator": "lt", "value": 10000, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}}], "actions": [{"type": "add_score", "value": 35}]}' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.transactions.rules.create( title="Structuring - inbound (custom)", description="20+ inbound EUR transfers, all under 10,000 EUR, 30 days", category="finance", mode="TEST", evaluation_mode="ALL", scope={ "transaction_types": ["finance"], "directions": ["INBOUND"], }, conditions=[{ "field": "currency", "operator": "eq", "value": "EUR", }, { "field": "amount", "operator": "lt", "value": 10000, }], aggregation=[{ "metric": "count", "operator": "gte", "value": 20.0, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}, }, { "metric": "max", "field": "amount", "operator": "lt", "value": 10000.0, "window": "30d", "filters": {"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}, }], actions=[{ "type": "add_score", "value": 35, }], ) 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.transactions.rules.create({ title: "Structuring - inbound (custom)", description: "20+ inbound EUR transfers, all under 10,000 EUR, 30 days", category: "finance", mode: "TEST", evaluation_mode: "ALL", scope: { transaction_types: ["finance"], directions: ["INBOUND"], }, conditions: [{ field: "currency", operator: "eq", value: "EUR", }, { field: "amount", operator: "lt", value: 10000, }], aggregation: [{ metric: "count", operator: "gte", value: 20.0, window: "30d", filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" }, }, { metric: "max", field: "amount", operator: "lt", value: 10000.0, window: "30d", filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" }, }], actions: [{ type: "add_score", value: 35, }], }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.Rules.Create(ctx, didit.TransactionRuleCreateRequest{\n\tTitle: \"Structuring - inbound (custom)\",\n\tDescription: didit.String(\"20+ inbound EUR transfers, all under 10,000 EUR, 30 days\"),\n\tCategory: \"finance\",\n\tMode: \"TEST\",\n\tEvaluationMode: didit.Some(didit.TransactionRuleCreateRequestEvaluationMode(\"ALL\")),\n\tScope: didit.Some(didit.TransactionRuleScopeParam{\n\t\tTransactionTypes: didit.Some([]string{\"finance\"}),\n\t\tDirections: didit.Some([]didit.TransactionRuleScopeDirections{\"INBOUND\"}),\n\t}),\n\tConditions: didit.Some([]didit.TransactionRuleConditionParam{{\n\t\tField: \"currency\",\n\t\tOperator: \"eq\",\n\t\tValue: didit.Some[any](\"EUR\"),\n\t}, {\n\t\tField: \"amount\",\n\t\tOperator: \"lt\",\n\t\tValue: didit.Some[any](10000),\n\t}}),\n\tAggregation: didit.Some([]didit.TransactionRuleAggregationParam{{\n\t\tMetric: didit.Some(didit.TransactionRuleAggregationMetric(\"count\")),\n\t\tOperator: didit.Some(didit.TransactionRuleAggregationOperator(\"gte\")),\n\t\tValue: 20.0,\n\t\tWindow: didit.String(\"30d\"),\n\t\tFilters: didit.Some(map[string]any{\"direction\": \"INBOUND\", \"transaction_type\": \"finance\", \"subject_vendor_data\": \"__current__\", \"currency\": \"EUR\"}),\n\t}, {\n\t\tMetric: didit.Some(didit.TransactionRuleAggregationMetric(\"max\")),\n\t\tField: didit.String(\"amount\"),\n\t\tOperator: didit.Some(didit.TransactionRuleAggregationOperator(\"lt\")),\n\t\tValue: 10000.0,\n\t\tWindow: didit.String(\"30d\"),\n\t\tFilters: didit.Some(map[string]any{\"direction\": \"INBOUND\", \"transaction_type\": \"finance\", \"subject_vendor_data\": \"__current__\", \"currency\": \"EUR\"}),\n\t}}),\n\tActions: didit.Some([]didit.TransactionRuleActionParam{{\n\t\tType: \"add_score\",\n\t\tValue: didit.Some[any](35),\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 java.util.Map; import me.didit.Didit; import me.didit.types.TransactionRuleAction; import me.didit.types.TransactionRuleActionAddScore; import me.didit.types.TransactionRuleAggregation; import me.didit.types.TransactionRuleCondition; import me.didit.types.TransactionRuleCreateRequest; import me.didit.types.TransactionRuleScope; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.transactions().rules().create(TransactionRuleCreateRequest.builder() .title("Structuring - inbound (custom)") .description("20+ inbound EUR transfers, all under 10,000 EUR, 30 days") .category("finance") .mode(TransactionRuleCreateRequest.Mode.of("TEST")) .evaluationMode(TransactionRuleCreateRequest.EvaluationMode.of("ALL")) .scope(TransactionRuleScope.builder() .transactionTypes(List.of("finance")) .directions(List.of(TransactionRuleScope.Directions.of("INBOUND"))) .build()) .conditions(List.of( TransactionRuleCondition.builder() .field("currency") .operator(TransactionRuleCondition.Operator.of("eq")) .value("EUR") .build(), TransactionRuleCondition.builder() .field("amount") .operator(TransactionRuleCondition.Operator.of("lt")) .value(10000) .build())) .aggregation(List.of( TransactionRuleAggregation.builder() .metric(TransactionRuleAggregation.Metric.of("count")) .operator(TransactionRuleAggregation.Operator.of("gte")) .value(20.0) .window("30d") .filters(Map.of("direction", "INBOUND", "transaction_type", "finance", "subject_vendor_data", "__current__", "currency", "EUR")) .build(), TransactionRuleAggregation.builder() .metric(TransactionRuleAggregation.Metric.of("max")) .field("amount") .operator(TransactionRuleAggregation.Operator.of("lt")) .value(10000.0) .window("30d") .filters(Map.of("direction", "INBOUND", "transaction_type", "finance", "subject_vendor_data", "__current__", "currency", "EUR")) .build())) .actions(List.of(TransactionRuleAction.ofAddScore(TransactionRuleActionAddScore.builder() .type(TransactionRuleActionAddScore.Type.of("add_score")) .value(35L) .build()))) .build()); System.out.println(result); - lang: php label: PHP source: |- transactions->rules->create([ 'title' => 'Structuring - inbound (custom)', 'description' => '20+ inbound EUR transfers, all under 10,000 EUR, 30 days', 'category' => 'finance', 'mode' => 'TEST', 'evaluation_mode' => 'ALL', 'scope' => [ 'transaction_types' => ['finance'], 'directions' => ['INBOUND'], ], 'conditions' => [[ 'field' => 'currency', 'operator' => 'eq', 'value' => 'EUR', ], [ 'field' => 'amount', 'operator' => 'lt', 'value' => 10000, ]], 'aggregation' => [[ 'metric' => 'count', 'operator' => 'gte', 'value' => 20.0, 'window' => '30d', 'filters' => ['direction' => 'INBOUND', 'transaction_type' => 'finance', 'subject_vendor_data' => '__current__', 'currency' => 'EUR'], ], [ 'metric' => 'max', 'field' => 'amount', 'operator' => 'lt', 'value' => 10000.0, 'window' => '30d', 'filters' => ['direction' => 'INBOUND', 'transaction_type' => 'finance', 'subject_vendor_data' => '__current__', 'currency' => 'EUR'], ]], 'actions' => [[ 'type' => 'add_score', 'value' => 35, ]], ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.transactions.rules.create( title: "Structuring - inbound (custom)", description: "20+ inbound EUR transfers, all under 10,000 EUR, 30 days", category: "finance", mode: "TEST", evaluation_mode: "ALL", scope: { transaction_types: ["finance"], directions: ["INBOUND"], }, conditions: [{ field: "currency", operator: "eq", value: "EUR", }, { field: "amount", operator: "lt", value: 10000, }], aggregation: [{ metric: "count", operator: "gte", value: 20.0, window: "30d", filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" }, }, { metric: "max", field: "amount", operator: "lt", value: 10000.0, window: "30d", filters: { direction: "INBOUND", transaction_type: "finance", subject_vendor_data: "__current__", currency: "EUR" }, }], actions: [{ type: "add_score", value: 35, }] ) puts result.to_h - lang: csharp label: .NET source: >- using System; using System.Collections.Generic; using System.Text.Json; using Didit; // Reads DIDIT_API_KEY. using var client = new DiditClient(); var result = await client.Transactions.Rules.CreateAsync(new TransactionRuleCreateRequest { Title = "Structuring - inbound (custom)", Description = "20+ inbound EUR transfers, all under 10,000 EUR, 30 days", Category = "finance", Mode = "TEST", EvaluationMode = new TransactionRuleCreateRequestEvaluationMode("ALL"), Scope = new TransactionRuleScope { TransactionTypes = new string[] { "finance" }, Directions = new TransactionRuleScopeDirections[] { "INBOUND" }, }, Conditions = new TransactionRuleCondition[] { new() { Field = "currency", Operator = "eq", Value = "EUR", }, new() { Field = "amount", Operator = "lt", Value = 10000, }, }, Aggregation = new TransactionRuleAggregation[] { new() { Metric = new TransactionRuleAggregationMetric("count"), Operator = new TransactionRuleAggregationOperator("gte"), Value = 20.0, Window = "30d", Filters = new Dictionary { ["direction"] = "INBOUND", ["transaction_type"] = "finance", ["subject_vendor_data"] = "__current__", ["currency"] = "EUR" }, }, new() { Metric = new TransactionRuleAggregationMetric("max"), Field = "amount", Operator = new TransactionRuleAggregationOperator("lt"), Value = 10000.0, Window = "30d", Filters = new Dictionary { ["direction"] = "INBOUND", ["transaction_type"] = "finance", ["subject_vendor_data"] = "__current__", ["currency"] = "EUR" }, }, }, Actions = new TransactionRuleAction[] { new() { Type = new TransactionRuleActionType("add_score"), Value = 35, }, }, }); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: TransactionRuleCreateRequest: type: object required: - title - category - mode properties: title: type: string description: >- Regelname. Eindeutig pro Anwendung unter nicht gelöschten Regeln; Duplikate geben 400 zurück. description: type: string nullable: true category: type: string description: >- Risikothema zur Gruppierung und Berichterstellung, z. B. finance, aml_ctf, anomaly_detection, fatf, device_intelligence, crypto_monitoring, travel_rule, responsible_gaming, e_commerce. mode: type: string enum: - ACTIVE - DISABLED - TEST description: >- ACTIVE wertet live aus. TEST wertet Regelläufe aus und zeichnet sie auf, ändert jedoch niemals Score oder Status – der empfohlene Startmodus. DISABLED wird übersprungen. evaluation_mode: type: string enum: - ALL - ANY default: ALL description: >- Gibt an, ob jede Bedingung zutreffen muss (ALL) oder mindestens eine (ANY). Wird ignoriert, wenn Bedingungen group_index verwenden. 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 description: Freiform-Metadaten, die für die Regel gespeichert sind. description: >- Erstellt eine CUSTOM-Regel. Regeln im Modus ACTIVE werden für neue Transaktionen sofort wirksam – erstellen Sie sie zunächst im TEST-Modus und führen Sie zuerst ein Backtesting durch. TransactionRuleDetail: type: object properties: uuid: type: string format: uuid title: type: string description: >- Regelname. Eindeutig pro Anwendung unter nicht gelöschten Regeln; Duplikate geben 400 zurück. description: type: string nullable: true category: type: string description: >- Risikothema zur Gruppierung und Berichterstellung, z. B. finance, aml_ctf, anomaly_detection, fatf, device_intelligence, crypto_monitoring, travel_rule, responsible_gaming, e_commerce. mode: type: string enum: - ACTIVE - DISABLED - TEST description: >- ACTIVE wertet live aus. TEST wertet Regelläufe aus und zeichnet sie auf, ändert jedoch niemals Score oder Status – der empfohlene Startmodus. DISABLED wird übersprungen. evaluation_mode: type: string enum: - ALL - ANY default: ALL description: >- Gibt an, ob jede Bedingung zutreffen muss (ALL) oder mindestens eine (ANY). Wird ignoriert, wenn Bedingungen group_index verwenden. 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 description: Freiform-Metadaten, die für die Regel gespeichert sind. severity: type: string enum: - UNKNOWN - LOW - MEDIUM - HIGH - CRITICAL nullable: true description: >- Informativer Schweregrad, der von Bibliotheksregeln getragen wird; kann bei benutzerdefinierten Regeln nicht festgelegt werden. source: type: string enum: - PRESET - CUSTOM description: >- PRESET-Regeln stammen aus der Bibliothek (Installieren/Deinstallieren, Bearbeitungen nur des Modus); CUSTOM-Regeln gehören vollständig Ihnen. library_key: type: string nullable: true description: Stabile Bibliothekskennung; null für benutzerdefinierte Regeln. latest_triggered_at: type: string format: date-time nullable: true run_count: type: integer description: Wie viele Transaktionen mit dieser Regel übereingestimmt haben. approved_count: type: integer reviewed_count: type: integer declined_count: type: integer awaiting_user_count: type: integer approved_pct: type: number reviewed_pct: type: number declined_pct: type: number created_at: type: string format: date-time updated_at: type: string format: date-time 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. 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: m (MINUTEN, nicht Monate), h (Stunden) oder 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.