> ## 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.
# Créer une règle de surveillance des transactions API KYT
> Créez une règle KYT via l'API Didit : conditions, fenêtres de vélocité, périmètre et actions. Testez en mode TEST, puis activez.
Prompt de l'API de création de règle
Copier le prompt dans le presse-papiers
\
\`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.`
\
Coller dans
## OpenAPI
````yaml fr/openapi-25.json POST /v3/transactions/rules/
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/transactions/rules/:
post:
tags:
- Transactions
summary: Créer une règle
description: >-
Créez une règle personnalisée (CUSTOM) de surveillance des transactions.
Les titres sont uniques par application (doublon -> 400). Une action
`change_status` ciblant `AWAITING_USER` doit comporter un `workflow_id`.
Les règles créées en mode ACTIVE s'appliquent immédiatement aux
nouvelles transactions - le workflow recommandé consiste à créer en mode
TEST, effectuer un backtest, puis basculer le mode sur ACTIVE. Pour
modifier une règle de la bibliothèque, créez-la sous forme de copie :
envoyez la définition de la règle de la bibliothèque avec
`metadata.based_on` (sa clé de bibliothèque) et
`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: La règle créée.
content:
application/json:
schema:
$ref: '#/components/schemas/TransactionRuleDetail'
'400':
description: >-
Erreur de validation - titre en doublon, opérateur/métrique
inconnu(e), fenêtre mal formée, direction de portée invalide ou
AWAITING_USER sans 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: >-
Nom de la règle. Unique par application parmi les règles non
supprimées ; les doublons renvoient 400.
description:
type: string
nullable: true
category:
type: string
description: >-
Thématique de risque utilisée pour le regroupement et les rapports,
par ex. 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 évalue en direct. TEST évalue et enregistre les exécutions de
règles mais ne modifie jamais le score ni le statut - le mode de
départ recommandé. DISABLED est ignoré.
evaluation_mode:
type: string
enum:
- ALL
- ANY
default: ALL
description: >-
Indique si chaque condition doit correspondre (ALL) ou au moins une
(ANY). Ignoré lorsque les conditions utilisent group_index.
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: Métadonnées libres stockées sur la règle.
description: >-
Crée une règle CUSTOM. Les règles en mode ACTIVE prennent effet
immédiatement pour les nouvelles transactions - créez-les d'abord en
mode TEST et effectuez un backtest au préalable.
TransactionRuleDetail:
type: object
properties:
uuid:
type: string
format: uuid
title:
type: string
description: >-
Nom de la règle. Unique par application parmi les règles non
supprimées ; les doublons renvoient 400.
description:
type: string
nullable: true
category:
type: string
description: >-
Thématique de risque utilisée pour le regroupement et les rapports,
par ex. 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 évalue en direct. TEST évalue et enregistre les exécutions de
règles mais ne modifie jamais le score ni le statut - le mode de
départ recommandé. DISABLED est ignoré.
evaluation_mode:
type: string
enum:
- ALL
- ANY
default: ALL
description: >-
Indique si chaque condition doit correspondre (ALL) ou au moins une
(ANY). Ignoré lorsque les conditions utilisent group_index.
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: Métadonnées libres stockées sur la règle.
severity:
type: string
enum:
- UNKNOWN
- LOW
- MEDIUM
- HIGH
- CRITICAL
nullable: true
description: >-
Gravité informative portée par les règles de la bibliothèque ; non
définissable sur les règles personnalisées.
source:
type: string
enum:
- PRESET
- CUSTOM
description: >-
Les règles PRESET proviennent de la bibliothèque
(installation/désinstallation, modifications du mode uniquement) ;
les règles CUSTOM sont entièrement les vôtres.
library_key:
type: string
nullable: true
description: >-
Identifiant stable de bibliothèque ; null pour les règles
personnalisées.
latest_triggered_at:
type: string
format: date-time
nullable: true
run_count:
type: integer
description: Nombre de transactions correspondant à cette règle.
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: >-
Restreindre aux types de transaction, par ex. finance, kyc,
travel_rule, user_event. Vide ou manquant = aucune restriction.
directions:
type: array
items:
type: string
enum:
- INBOUND
- OUTBOUND
description: >-
Restreindre aux directions de transaction (insensible à la casse à
l'écriture).
action_types:
type: array
items:
type: string
description: Restreindre à vos valeurs action_type, par ex. withdrawal, deposit.
description: >-
À quelles transactions la règle s'applique. Seules ces trois clés sont
acceptées.
TransactionRuleCondition:
type: object
required:
- field
- operator
properties:
field:
type: string
description: >-
Chemin du champ de transaction à évaluer. Champs principaux :
amount, currency, direction, action_type, score, severity,
transaction_type, payment_details, preferred_currency_amount (se
rabat sur amount_in_default_currency), 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 (et les équivalents
counterparty_payment_method_*), travel_rule_status,
travel_rule_required, travel_rule_obligations_count,
counterparty_dd_status (votre décision sur la contrepartie Travel
Rule : APPROVED, RESTRICTED ou BLOCKED, une entité suivant celle de
sa marque), counterparty_risk_level (LOW, MEDIUM ou HIGH ; HIGH tant
que votre propre filtrage de la contrepartie est signalé),
counterparty_jurisdiction (le pays du VASP de la contrepartie),
counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE ou UNKNOWN),
subject_days_since_previous_transaction, tags, et
custom_values. pour toute clé fournie dans custom_properties
lors de la création de la transaction. Les champs de code pays
acceptent ISO-2 ou ISO-3 ; les deux côtés sont normalisés en ISO-3
avant la comparaison.
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: >-
Opérateur de comparaison. in/not_in testent l'appartenance (la
valeur peut être une liste ou un scalaire unique).
contains/not_contains sont des vérifications de sous-chaîne
insensibles à la casse par rapport à une valeur de chaîne.
contains_any prend une liste de chaînes et correspond lorsque l'une
d'elles est une sous-chaîne insensible à la casse de la valeur du
champ. regex fait correspondre le motif de la valeur avec le champ.
fuzzy_match compare avec la chaîne de valeur selon le seuil de
`score` requis (0-100). gt/gte/lt/lte ne correspondent jamais
lorsque l'un des côtés est manquant. exists/is_not_empty/is_not_null
(alias) et not_exists/is_empty/is_null (alias) sont des
vérifications de présence qui ignorent `value`.
value:
description: "Valeur de comparaison. Sa forme dépend de l'opérateur et de value_type\_; omettez-la pour les opérateurs de vérification de présence. Tout autre opérateur nécessite une valeur qui n'est pas `null` ou une liste vide, sinon la règle est refusée avec `400`. `contains_any` nécessite une liste de chaînes, et `contains`, `not_contains` et `regex` nécessitent une seule chaîne."
value_type:
type: string
enum:
- list
- field
- relative_date
description: "Interprétation de la valeur optionnelle. `list`\_: la valeur est un UUID de liste et les entrées de la liste deviennent la valeur de comparaison. `field`\_: la valeur est un chemin vers un autre champ, comparé champ à champ. `relative_date`\_: la valeur est un objet de date relative, par exemple {\"direction\": \"past\", \"unit\": \"days\", \"amount\": 30}."
score:
type: number
minimum: 0
maximum: 100
description: >-
Requis lorsque l'opérateur est fuzzy_match : le seuil de similarité
de 0 à 100.
group_index:
type: integer
description: >-
Logique groupée optionnelle. Lorsqu'une condition porte group_index,
les conditions partageant un index forment un groupe et l'évaluation
groupée remplace evaluation_mode.
group_logic:
type: string
enum:
- AND
- OR
default: AND
description: Manière dont les conditions se combinent AU SEIN d'un groupe.
groups_logic:
type: string
enum:
- AND
- OR
default: OR
description: >-
Manière dont les résultats des groupes se combinent ENTRE les
groupes. Lu à partir de la première condition.
description: "Une condition lit uniquement la transaction en cours d'évaluation\_- elle ne filtre jamais la fenêtre d'agrégation."
TransactionRuleAggregation:
type: object
required:
- value
properties:
metric:
type: string
enum:
- count
- sum
- max
- min
- avg
- distinct_count
default: count
description: >-
Manière dont les transactions historiques correspondantes sont
agrégées. unique_count est accepté en tant qu'alias de
distinct_count.
field:
type: string
default: amount
description: Champ agrégé par sum/max/min/avg/distinct_count. Ignoré pour count.
operator:
type: string
enum:
- eq
- ne
- gt
- gte
- lt
- lte
default: eq
description: Comparaison appliquée à la métrique calculée.
value:
type: number
description: Seuil auquel la métrique calculée est comparée.
window:
type: string
pattern: ^\d+(m|h|d)$
default: 1d
description: >-
Fenêtre rétrospective se terminant à la date txn_date de la
transaction : m (MINUTES, et non mois), h (heures) ou d
(jours), par ex. 30m, 24h, 7d, 30d.
filters:
type: object
additionalProperties: true
description: "Restreint les transactions historiques qui sont agrégées. Les clés sont des chemins de champs issus du catalogue de champs de conditions\_; une valeur de \"__current__\" prend la valeur du même champ sur la transaction en cours d'évaluation (par exemple {\"subject_vendor_data\": \"__current__\"} restreint la fenêtre au même sujet), et une liste indique une appartenance. Les enregistrements dépourvus de la valeur de regroupement ne sont jamais regroupés ensemble\_: lorsque la transaction en cours d'évaluation n'a pas de valeur pour un champ \"__current__\" (pas de contrepartie, pas d'empreinte d'appareil), l'agrégation ne correspond pas, quel que soit son opérateur. Les filtres comparent UNIQUEMENT par égalité ou appartenance\_- il n'y a pas de filtre lt/gte, donc une plage telle que \"transactions historiques inférieures à 10 000\" ne peut pas être formulée ici. Définissez plutôt la plage sur la métrique (la métrique max avec l'opérateur lt conserve chaque transaction de la fenêtre sous le seuil)."
description: >-
Contrôle de vélocité sur les transactions historiques de l'application
dans la fenêtre. Chaque entrée d'agrégation doit correspondre pour que
la règle s'applique, quel que soit evaluation_mode. Une agrégation ne
restreint que la fenêtre ; la transaction en cours d'évaluation est
restreinte par le périmètre et les conditions, donc répétez la
direction, la devise ou le transaction_type sur les deux moitiés lorsque
la règle les prévoit.
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: >-
Une action de règle. Une règle peut en comporter plusieurs ; elles sont
toutes appliquées ensemble lorsqu'elle correspond. Les règles en mode
TEST enregistrent ce qu'elles auraient fait sans appliquer aucune
action.
TransactionRuleActionAddScore:
type: object
required:
- type
- value
properties:
type:
type: string
enum:
- add_score
value:
type: integer
description: >-
Points ajoutés au score de risque de la transaction. Peut être
négatif.
description: >-
Ajoutez des points au score de risque cumulé de la transaction ; le
total détermine le statut via les seuils d'examen/refus de
l'application.
TransactionRuleActionChangeStatus:
type: object
required:
- type
- value
properties:
type:
type: string
enum:
- change_status
value:
type: string
enum:
- APPROVED
- IN_REVIEW
- DECLINED
- AWAITING_USER
description: >-
Statut à définir immédiatement, indépendamment du score. Clé alias :
status.
workflow_id:
type: string
format: uuid
description: >-
REQUIS lorsque la valeur est AWAITING_USER : le workflow de
vérification que la personne concernée est invitée à effectuer. Clé
d'alias : remediation_workflow_id. Didit crée une session de
remédiation hébergée pour la personne concernée lorsque la règle se
déclenche.
description: >-
Définit directement le statut de la transaction. DECLINED l'emporte
toujours sur l'ensemble des règles correspondantes.
TransactionRuleActionAddTags:
type: object
required:
- type
properties:
type:
type: string
enum:
- add_tags
tag_uuid:
type: string
format: uuid
description: Tag d'application existant à associer.
tag_name:
type: string
description: >-
Nom du tag à associer ; créé à la première utilisation (stocké en
majuscules). Fournissez tag_uuid ou tag_name.
tag_color:
type: string
description: >-
Couleur hexadécimale utilisée lorsque tag_name crée une nouvelle
étiquette, par exemple #007AFE.
description: Associer un tag d'application à la transaction correspondante.
TransactionRuleActionAddNote:
type: object
required:
- type
- note
properties:
type:
type: string
enum:
- add_note
note:
type: string
description: >-
Texte de la note associée à la transaction (auteur : Moteur de
règles). Clé d'alias : valeur.
description: >-
Associer une note d'analyste automatisée à la transaction
correspondante.
TransactionRuleActionAddToList:
type: object
required:
- type
- list_id
properties:
type:
type: string
enum:
- add_to_list
list_id:
type: string
format: uuid
description: Liste à laquelle ajouter le vendor_data du sujet.
description: >-
Ajouter le vendor_data du sujet à une liste de blocage, une liste
d'autorisation ou une liste personnalisée.
TransactionRuleActionOpenCase:
type: object
required:
- type
properties:
type:
type: string
enum:
- open_case
blueprint:
type: string
format: uuid
description: >-
UUID du modèle de dossier (blueprint) ; la valeur par défaut est le
modèle par défaut de l'application.
grouping:
type: string
enum:
- by_applicant
- by_rule_and_applicant
description: >-
Indique si les correspondances répétées rejoignent un dossier par
demandeur ou un par règle+demandeur.
attach_matched_transaction:
type: boolean
description: Associer la transaction correspondante au dossier.
description: >-
Ouvrir (ou ajouter à) un dossier d'investigation. Seule la première
action open_case sur une règle est appliquée.
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.
````
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.