> ## 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.
# Monitoraggio delle transazioni: API per creare regole KYT
> Crea con Didit una regola KYT via API: condizioni, velocity, ambito e azioni con schemi. Testa in TEST, esegui il backtest, poi attiva.
Prompt API per la creazione di una regola
Copia il prompt negli appunti
\
\`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.`
\
Incolla in
## OpenAPI
````yaml it/openapi-25.json POST /v3/transactions/rules/
openapi: 3.0.0
info:
version: 3.0.0
title: Didit Verification API
description: API di verifica dell'identità. Autenticati con l'intestazione x-api-key.
servers:
- url: https://verification.didit.me
security: []
tags: []
paths:
/v3/transactions/rules/:
post:
tags:
- Transactions
summary: Crea regola
description: >-
Crea una regola di monitoraggio delle transazioni di tipo CUSTOM. I
titoli sono univoci per applicazione (duplicato -> 400). Un'azione
`change_status` che ha come destinazione `AWAITING_USER` deve contenere
`workflow_id`. Le regole create in modalità ACTIVE si applicano
immediatamente alle nuove transazioni: il flusso di lavoro consigliato
consiste nel creare in modalità TEST, effettuare il backtest e poi
passare alla modalità ACTIVE. Per modificare una regola della libreria,
creala come copia: invia la definizione della regola della libreria con
`metadata.based_on` (la sua chiave di libreria) e
`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 regola creata.
content:
application/json:
schema:
$ref: '#/components/schemas/TransactionRuleDetail'
'400':
description: >-
Errore di validazione - titolo duplicato, operatore/metrica
sconosciuti, intervallo non valido, direzione dell'ambito non valida
o AWAITING_USER senza 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: >-
Nome della regola. Univoco per applicazione tra le regole non
eliminate; i duplicati restituiscono 400.
description:
type: string
nullable: true
category:
type: string
description: >-
Tema di rischio utilizzato per il raggruppamento e la reportistica,
ad es. 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 valuta in produzione. TEST valuta e registra le esecuzioni
delle regole senza mai modificare punteggio o stato: è la modalità
iniziale consigliata. DISABLED viene ignorato.
evaluation_mode:
type: string
enum:
- ALL
- ANY
default: ALL
description: >-
Indica se ogni condizione deve corrispondere (ALL) o almeno una
(ANY). Viene ignorato quando le condizioni utilizzano 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: Metadati a struttura libera memorizzati sulla regola.
description: >-
Crea una regola CUSTOM. Le regole in modalità ACTIVE diventano
immediatamente effettive per le nuove transazioni: creale in modalità
TEST ed esegui prima il backtest.
TransactionRuleDetail:
type: object
properties:
uuid:
type: string
format: uuid
title:
type: string
description: >-
Nome della regola. Univoco per applicazione tra le regole non
eliminate; i duplicati restituiscono 400.
description:
type: string
nullable: true
category:
type: string
description: >-
Tema di rischio utilizzato per il raggruppamento e la reportistica,
ad es. 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 valuta in produzione. TEST valuta e registra le esecuzioni
delle regole senza mai modificare punteggio o stato: è la modalità
iniziale consigliata. DISABLED viene ignorato.
evaluation_mode:
type: string
enum:
- ALL
- ANY
default: ALL
description: >-
Indica se ogni condizione deve corrispondere (ALL) o almeno una
(ANY). Viene ignorato quando le condizioni utilizzano 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: Metadati a struttura libera memorizzati sulla regola.
severity:
type: string
enum:
- UNKNOWN
- LOW
- MEDIUM
- HIGH
- CRITICAL
nullable: true
description: >-
Gravità informativa applicata dalle regole di libreria; non
impostabile per le regole personalizzate.
source:
type: string
enum:
- PRESET
- CUSTOM
description: >-
Le regole PRESET provengono dalla libreria
(installazione/disinstallazione, modifiche solo alla modalità); le
regole CUSTOM sono interamente tue.
library_key:
type: string
nullable: true
description: >-
Identificatore stabile di libreria; null per le regole
personalizzate.
latest_triggered_at:
type: string
format: date-time
nullable: true
run_count:
type: integer
description: Quante transazioni corrispondono a questa regola.
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: >-
Limita ai tipi di transazione, ad es. finance, kyc, travel_rule,
user_event. Vuoto o mancante = nessuna limitazione.
directions:
type: array
items:
type: string
enum:
- INBOUND
- OUTBOUND
description: >-
Limita alle direzioni della transazione (senza distinzione tra
maiuscole e minuscole in scrittura).
action_types:
type: array
items:
type: string
description: Limita ai tuoi valori di action_type, ad es. withdrawal, deposit.
description: >-
A quali transazioni si applica la regola. Sono accettate solo queste tre
chiavi.
TransactionRuleCondition:
type: object
required:
- field
- operator
properties:
field:
type: string
description: >-
Percorso del campo della transazione da valutare. Campi principali:
amount, currency, direction, action_type, score, severity,
transaction_type, payment_details, preferred_currency_amount
(utilizza amount_in_default_currency come fallback),
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 (e i corrispettivi
counterparty_payment_method_*), travel_rule_status,
travel_rule_required, travel_rule_obligations_count,
counterparty_dd_status (la tua decisione sulla controparte Travel
Rule: APPROVED, RESTRICTED o BLOCKED, un'entità conforme al suo
marchio), counterparty_risk_level (LOW, MEDIUM o HIGH; HIGH mentre
il tuo screening della controparte è contrassegnato con un flag),
counterparty_jurisdiction (il paese del VASP di controparte),
counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE o UNKNOWN),
subject_days_since_previous_transaction, tags e custom_values.
per qualsiasi chiave inviata in custom_properties durante la
creazione della transazione. I campi con codice paese accettano
ISO-2 o ISO-3; entrambi i lati vengono normalizzati a ISO-3 prima
del confronto.
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: >-
Operatore di confronto. in/not_in verificano l'appartenenza (il
valore può essere un elenco o un singolo scalare).
contains/not_contains sono controlli di sottostringa senza
distinzione tra maiuscole e minuscole rispetto a un valore stringa.
contains_any accetta un elenco di stringhe e trova una
corrispondenza se una qualsiasi è una sottostringa senza distinzione
tra maiuscole e minuscole del valore del campo. regex confronta il
pattern del valore con il campo. fuzzy_match effettua il confronto
con la stringa del valore con la soglia di punteggio (`score`)
richiesta (0-100). gt/gte/lt/lte non trovano mai corrispondenze se
uno dei due lati è mancante. exists/is_not_empty/is_not_null (alias)
e not_exists/is_empty/is_null (alias) sono controlli di presenza che
ignorano `value`.
value:
description: >-
Valore di confronto. La sua struttura dipende dall'operatore e da
value_type; omettilo per gli operatori di controllo di presenza.
Tutti gli altri operatori richiedono un valore che non sia `null` o
un elenco vuoto, altrimenti la regola viene rifiutata con `400`.
`contains_any` richiede un elenco di stringhe, mentre `contains`,
`not_contains` e `regex` richiedono una singola stringa.
value_type:
type: string
enum:
- list
- field
- relative_date
description: >-
Interpretazione opzionale del valore. `list`: il valore è l'UUID di
un elenco e le voci dell'elenco diventano il valore di confronto.
`field`: il valore è il percorso di un altro campo, confrontato
campo per campo. `relative_date`: il valore è un oggetto data
relativa, ad es. {"direction": "past", "unit": "days", "amount":
30}.
score:
type: number
minimum: 0
maximum: 100
description: >-
Obbligatorio quando operator è fuzzy_match: la soglia di similarità
da 0 a 100.
group_index:
type: integer
description: >-
Logica raggruppata opzionale. Quando una qualsiasi condizione
include group_index, le condizioni che condividono un indice formano
un gruppo e la valutazione raggruppata sostituisce evaluation_mode.
group_logic:
type: string
enum:
- AND
- OR
default: AND
description: Come si combinano le condizioni ALL'INTERNO di un gruppo.
groups_logic:
type: string
enum:
- AND
- OR
default: OR
description: >-
Come si combinano i risultati TRA i gruppi. Letto dalla prima
condizione.
description: >-
Una condizione legge solo la transazione valutata: non filtra mai la
finestra di aggregazione.
TransactionRuleAggregation:
type: object
required:
- value
properties:
metric:
type: string
enum:
- count
- sum
- max
- min
- avg
- distinct_count
default: count
description: >-
In che modo vengono aggregate le transazioni storiche
corrispondenti. unique_count è accettato come alias di
distinct_count.
field:
type: string
default: amount
description: >-
Campo aggregato tramite sum/max/min/avg/distinct_count. Ignorato per
count.
operator:
type: string
enum:
- eq
- ne
- gt
- gte
- lt
- lte
default: eq
description: Confronto applicato alla metrica calcolata.
value:
type: number
description: Soglia con cui viene confrontata la metrica calcolata.
window:
type: string
pattern: ^\d+(m|h|d)$
default: 1d
description: >-
Finestra retrospettiva che termina alla data txn_date della
transazione: m (MINUTI, non mesi), h (ore) o d (giorni), ad
es. 30m, 24h, 7d, 30d.
filters:
type: object
additionalProperties: true
description: >-
Limita quali transazioni storiche vengono aggregate. Le chiavi sono
percorsi di campo dal catalogo dei campi di condizione; un valore
pari a "__current__" fa riferimento al valore dello stesso campo
sulla transazione in fase di valutazione (ad es.
{"subject_vendor_data": "__current__"} delimita l'intervallo allo
stesso soggetto), e un valore di tipo elenco indica l'appartenenza.
I record senza il valore raggruppato non vengono mai raggruppati
insieme: quando la transazione in fase di valutazione non ha alcun
valore per un campo "__current__" (nessuna controparte, nessuna
impronta digitale del dispositivo), l'aggregazione non corrisponde,
indipendentemente dal suo operatore. I filtri confrontano SOLO per
uguaglianza o appartenenza: non esiste un filtro lt/gte, quindi un
intervallo come "transazioni storiche inferiori a 10.000" non può
essere espresso qui. Imposta invece l'intervallo sulla metrica (la
metrica max con operatore lt mantiene ogni transazione
nell'intervallo al di sotto della soglia).
description: >-
Controllo di velocità sulle transazioni storiche dell'applicazione
all'interno della finestra temporale. Ogni voce di aggregazione deve
corrispondere affinché la regola corrisponda, indipendentemente da
evaluation_mode. Un'aggregazione vincola solo la finestra; la
transazione in fase di valutazione è vincolata dall'ambito e dalle
condizioni, quindi ripeti direction, currency o transaction_type su
entrambe le metà quando la regola li prevede.
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: >-
Un'azione della regola. Una regola può averne diverse; vengono tutte
applicate insieme in caso di corrispondenza. Le regole in modalità TEST
registrano ciò che avrebbero fatto senza applicare alcuna azione.
TransactionRuleActionAddScore:
type: object
required:
- type
- value
properties:
type:
type: string
enum:
- add_score
value:
type: integer
description: >-
Punti aggiunti al punteggio di rischio della transazione. Possono
essere negativi.
description: >-
Aggiungi punti al punteggio di rischio cumulativo della transazione; il
totale determina lo stato tramite le soglie di revisione/rifiuto
dell'applicazione.
TransactionRuleActionChangeStatus:
type: object
required:
- type
- value
properties:
type:
type: string
enum:
- change_status
value:
type: string
enum:
- APPROVED
- IN_REVIEW
- DECLINED
- AWAITING_USER
description: >-
Stato da impostare immediatamente, a prescindere dal punteggio.
Chiave alias: status.
workflow_id:
type: string
format: uuid
description: >-
OBBLIGATORIO quando il valore è AWAITING_USER: il workflow di
verifica che il soggetto è invitato a completare. Chiave alias:
remediation_workflow_id. Didit crea una sessione di correzione
ospitata per il soggetto quando la regola si attiva.
description: >-
Imposta direttamente lo stato della transazione. DECLINED prevale sempre
tra le regole corrispondenti.
TransactionRuleActionAddTags:
type: object
required:
- type
properties:
type:
type: string
enum:
- add_tags
tag_uuid:
type: string
format: uuid
description: Tag dell'applicazione esistente da associare.
tag_name:
type: string
description: >-
Nome del tag da associare; creato al primo utilizzo (salvato in
maiuscolo). Fornisci tag_uuid o tag_name.
tag_color:
type: string
description: >-
Colore esadecimale utilizzato quando tag_name crea un nuovo tag, ad
es. #007AFE.
description: Collega un tag dell'applicazione alla transazione corrispondente.
TransactionRuleActionAddNote:
type: object
required:
- type
- note
properties:
type:
type: string
enum:
- add_note
note:
type: string
description: >-
Testo della nota allegato alla transazione (autore: Rule Engine).
Alias chiave: valore.
description: >-
Collega una nota automatica dell'analista alla transazione
corrispondente.
TransactionRuleActionAddToList:
type: object
required:
- type
- list_id
properties:
type:
type: string
enum:
- add_to_list
list_id:
type: string
format: uuid
description: Elenco a cui aggiungere il vendor_data del soggetto.
description: >-
Aggiungi il vendor_data del soggetto a una blocklist, lista consentita o
lista personalizzata.
TransactionRuleActionOpenCase:
type: object
required:
- type
properties:
type:
type: string
enum:
- open_case
blueprint:
type: string
format: uuid
description: >-
UUID del blueprint del caso; il valore predefinito è il blueprint
predefinito dell'applicazione.
grouping:
type: string
enum:
- by_applicant
- by_rule_and_applicant
description: >-
Indica se le corrispondenze ripetute vengono aggregate in un unico
caso per richiedente o uno per regola+richiedente.
attach_matched_transaction:
type: boolean
description: Collega la transazione corrispondente al caso.
description: >-
Apri (o aggiungi a) un caso di indagine. Viene applicata solo la prima
azione open_case su una regola.
securitySchemes:
ApiKeyAuth:
type: apiKey
in: header
name: x-api-key
description: >-
La chiave API della tua applicazione, da Developers -> API keys nella
Business Console. La chiave primaria ha accesso completo. Una chiave con
nome può avere un ambito definito: nessuno, lettura o scrittura per
risorsa, limitata ad alcuni workflow o a sessioni approvate, a un elenco
di indirizzi IP e a una data di scadenza. 401 indica che la chiave è
errata, revocata o scaduta; 403 indica che non è stata inviata alcuna
chiave, che la chiave non ha accesso a questa risorsa o azione, oppure
che la richiesta proviene da un indirizzo non incluso nel suo elenco IP;
404 su una route di sessione indica che la sessione non rientra nei
workflow o negli stati previsti dalla chiave. Una chiave senza accesso
ai media riceve gli URL di immagini, video e PDF come null, e una chiave
senza permessi di scrittura sulle sessioni riceve link e token di
sessione come null. Consulta https://docs.didit.me/console/api-keys.
````
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.