> ## 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. # Crear regla de monitoratge de transaccions (KYT) API > Crea una regla KYT personalitzada amb l'API de Didit: condicions, finestres de velocitat, àmbit i accions. Prova-la en mode TEST i activa-la. Indicació de l'API per crear una regla Copia el prompt al porta-retalls \

\`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.`

\
Enganxa a ## OpenAPI ````yaml ca/openapi-25.json POST /v3/transactions/rules/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API de verificació d'identitat. Autentica't amb la capçalera x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/transactions/rules/: post: tags: - Transactions summary: Crea una regla description: >- Crea una regla CUSTOM de monitoratge de transaccions. Els títols són únics per aplicació (duplicat -> 400). Una acció `change_status` dirigida a `AWAITING_USER` ha d'incloure `workflow_id`. Les regles creades en mode ACTIVE s'apliquen a les noves transaccions immediatament - el flux de treball recomanat és crear-les en mode TEST, fer proves retroactives i després canviar el mode a ACTIVE. Per modificar una regla de la biblioteca, crea-la com a còpia: envia la definició de la regla de la biblioteca amb `metadata.based_on` (la seva clau de biblioteca) i `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 regla creada. content: application/json: schema: $ref: '#/components/schemas/TransactionRuleDetail' '400': description: >- Error de validació - títol duplicat, operador/mètrica desconeguts, finestra mal formada, direcció d'abast no vàlida o AWAITING_USER sense 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 regla. Únic per aplicació entre les regles no eliminades; els duplicats retornen 400. description: type: string nullable: true category: type: string description: >- Tema de risc utilitzat per agrupar i generar informes, p. 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 avalua en temps real. TEST avalua i registra les execucions de regles però mai no modifica la puntuació ni l'estat: el mode inicial recomanat. DISABLED s'omet. evaluation_mode: type: string enum: - ALL - ANY default: ALL description: >- Indica si s'han de complir totes les condicions (ALL) o com a mínim una (ANY). S'ignora quan les condicions utilitzen 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: Metadades de format lliure emmagatzemades a la regla. description: >- Crea una regla CUSTOM. Les regles en mode ACTIVE tenen efecte immediatament per a les noves transaccions; crea-la en mode TEST i fes un backtest primer. TransactionRuleDetail: type: object properties: uuid: type: string format: uuid title: type: string description: >- Nom de la regla. Únic per aplicació entre les regles no eliminades; els duplicats retornen 400. description: type: string nullable: true category: type: string description: >- Tema de risc utilitzat per agrupar i generar informes, p. 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 avalua en temps real. TEST avalua i registra les execucions de regles però mai no modifica la puntuació ni l'estat: el mode inicial recomanat. DISABLED s'omet. evaluation_mode: type: string enum: - ALL - ANY default: ALL description: >- Indica si s'han de complir totes les condicions (ALL) o com a mínim una (ANY). S'ignora quan les condicions utilitzen 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: Metadades de format lliure emmagatzemades a la regla. severity: type: string enum: - UNKNOWN - LOW - MEDIUM - HIGH - CRITICAL nullable: true description: >- Gravetat informativa transmesa per les regles de la biblioteca; no es pot configurar en regles personalitzades. source: type: string enum: - PRESET - CUSTOM description: >- Les regles PRESET provenen de la biblioteca (instal·lació/desinstal·lació, modificacions només de mode); les regles CUSTOM són totalment teves. library_key: type: string nullable: true description: >- Identificador de biblioteca estable; null per a regles personalitzades. latest_triggered_at: type: string format: date-time nullable: true run_count: type: integer description: Quantes transaccions han coincidit amb aquesta regla. 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: >- Restringeix als tipus de transacció, p. ex. finance, kyc, travel_rule, user_event. Buit o absent = sense restricció. directions: type: array items: type: string enum: - INBOUND - OUTBOUND description: >- Restringeix a direccions de transacció (no distingeix majúscules de minúscules en escriure). action_types: type: array items: type: string description: >- Restringeix als teus valors de action_type, p. ex. withdrawal, deposit. description: >- A quines transaccions s'aplica la regla. Només s'accepten aquestes tres claus. TransactionRuleCondition: type: object required: - field - operator properties: field: type: string description: >- Ruta del camp de la transacció que s'ha d'avaluar. Camps principals: amount, currency, direction, action_type, score, severity, transaction_type, payment_details, preferred_currency_amount (recorre a amount_in_default_currency si no està definit), 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 (i els equivalents counterparty_payment_method_*), travel_rule_status, travel_rule_required, travel_rule_obligations_count, counterparty_dd_status (la teva decisió sobre la contrapart de Travel Rule: APPROVED, RESTRICTED o BLOCKED, una entitat que segueix la decisió de la seva marca), counterparty_risk_level (LOW, MEDIUM o HIGH; HIGH mentre el teu propi cribratge de contraparts estigui marcat), counterparty_jurisdiction (el país del VASP de la contrapart), counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE o UNKNOWN), subject_days_since_previous_transaction, tags i custom_values. per a qualsevol clau enviada a custom_properties en crear la transacció. Els camps de codi de país accepten ISO-2 o ISO-3; ambdues parts es normalitzen a ISO-3 abans de la comparació. 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: >- Operador de comparació. in/not_in comproven la pertinença (el valor pot ser una llista o un únic escalar). contains/not_contains són comprovacions de subcadenes que no distingeixen majúscules de minúscules respecte a un valor de tipus cadena. contains_any rep una llista de cadenes i coincideix quan qualsevol d'elles és una subcadena (sense distingir majúscules de minúscules) del valor del camp. regex compara el patró del valor amb el camp. fuzzy_match compara amb la cadena del valor mitjançant el llindar `score` requerit (0-100). gt/gte/lt/lte mai no coincideixen quan falta algun dels dos costats. exists/is_not_empty/is_not_null (àlies) i not_exists/is_empty/is_null (àlies) són comprovacions de presència que ignoren `value`. value: description: >- Valor de comparació. La seva estructura depèn de l'operador i de value_type; omet-lo per als operadors de comprovació de presència. Qualsevol altre operador necessita un valor que no sigui `null` ni una llista buida; en cas contrari, la regla es rebutja amb `400`. `contains_any` necessita una llista de cadenes, i `contains`, `not_contains` i `regex` necessiten una sola cadena. value_type: type: string enum: - list - field - relative_date description: >- Interpretació opcional del valor. `list`: el valor és un UUID de llista i les entrades de la llista esdevenen el valor de comparació. `field`: el valor és una altra ruta de camp, comparada camp a camp. `relative_date`: el valor és un objecte de data relativa, p. ex. {"direction": "past", "unit": "days", "amount": 30}. score: type: number minimum: 0 maximum: 100 description: >- Obligatori quan operator és fuzzy_match: el llindar de similitud de 0-100. group_index: type: integer description: >- Lògica agrupada opcional. Quan qualsevol condició té group_index, les condicions que comparteixen un índex formen un grup i l'avaluació agrupada substitueix evaluation_mode. group_logic: type: string enum: - AND - OR default: AND description: Com es combinen les condicions DINS d'un grup. groups_logic: type: string enum: - AND - OR default: OR description: >- Com es combinen els resultats dels grups ENTRE grups. Es llegeix a partir de la primera condició. description: >- Una condició només llegeix la transacció que s'està avaluant; mai filtra la finestra d'agregació. TransactionRuleAggregation: type: object required: - value properties: metric: type: string enum: - count - sum - max - min - avg - distinct_count default: count description: >- Com s'agreguen les transaccions històriques coincidents. S'accepta unique_count com a àlies de distinct_count. field: type: string default: amount description: >- Camp agregat per sum/max/min/avg/distinct_count. S'ignora per a count. operator: type: string enum: - eq - ne - gt - gte - lt - lte default: eq description: Comparació aplicada a la mètrica calculada. value: type: number description: Llindar amb el qual es compara la mètrica calculada. window: type: string pattern: ^\d+(m|h|d)$ default: 1d description: >- Finestra retrospectiva que finalitza al camp txn_date de la transacció: m (MINUTS, no mesos), h (hores) o d (dies), p. ex. 30m, 24h, 7d, 30d. filters: type: object additionalProperties: true description: >- Restringeix quines transaccions històriques s'agreguen. Les claus són rutes de camps del catàleg de camps de condicions; un valor de "__current__" es resol al valor del mateix camp a la transacció que s'està avaluant (p. ex., {"subject_vendor_data": "__current__"} limita la finestra al mateix subjecte), i un valor de llista indica pertinença. Els registres sense el valor agrupat mai no s'agrupen junts: quan la transacció que s'està avaluant no té cap valor per a un camp "__current__" (sense contrapart, sense empremta digital del dispositiu), l'agregació no coincideix, sigui quin sigui el seu operador. Els filtres comparen NOMÉS per igualtat o pertinença; no hi ha cap filtre lt/gte, de manera que un interval com ara "transaccions històriques inferiors a 10.000" no es pot expressar aquí. En comptes d'això, posa l'interval a la mètrica (la mètrica max amb l'operador lt manté totes les transaccions de la finestra per sota del llindar). description: >- Comprovació de velocitat sobre les transaccions històriques de l'aplicació dins de la finestra temporal. Cada entrada d'agregació ha de coincidir perquè la regla coincideixi, independentment de evaluation_mode. Una agregació limita només la finestra temporal; la transacció que s'està avaluant està limitada per scope i conditions, per la qual cosa cal repetir direction, currency o transaction_type a totes dues meitats quan la regla els requereixi. 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: >- Una acció de regla. Una regla en pot incloure diverses; totes s'apliquen conjuntament quan coincideix. Les regles en mode TEST registren el que haurien fet sense aplicar cap acció. TransactionRuleActionAddScore: type: object required: - type - value properties: type: type: string enum: - add_score value: type: integer description: >- Punts afegits a la puntuació de risc de la transacció. Poden ser negatius. description: >- Afegeix punts a la puntuació de risc acumulada de la transacció; el total decideix l'estat mitjançant els llindars de revisió/rebuig de l'aplicació. TransactionRuleActionChangeStatus: type: object required: - type - value properties: type: type: string enum: - change_status value: type: string enum: - APPROVED - IN_REVIEW - DECLINED - AWAITING_USER description: >- Estat a establir immediatament, independentment de la puntuació. Clau d'àlies: status. workflow_id: type: string format: uuid description: >- OBLIGATORI quan el valor és AWAITING_USER: el flux de treball de verificació que el subjecte ha de completar. Clau d'àlies: remediation_workflow_id. Didit crea una sessió de resolució allotjada per al subjecte quan s'activa la regla. description: >- Estableix directament l'estat de la transacció. DECLINED sempre preval entre les regles coincidents. TransactionRuleActionAddTags: type: object required: - type properties: type: type: string enum: - add_tags tag_uuid: type: string format: uuid description: Etiqueta d'aplicació existent per adjuntar. tag_name: type: string description: >- Nom de l'etiqueta per adjuntar; es crea amb el primer ús (s'emmagatzema en majúscules). Proporciona tag_uuid o tag_name. tag_color: type: string description: >- Color hexadecimal utilitzat quan tag_name crea una etiqueta nova, p. ex. #007AFE. description: Adjunta una etiqueta d'aplicació a la transacció coincident. TransactionRuleActionAddNote: type: object required: - type - note properties: type: type: string enum: - add_note note: type: string description: >- Text de la nota adjunt a la transacció (autor: Rule Engine). Clau d'àlies: valor. description: Adjunta una nota d'analista automatitzada a la transacció coincident. TransactionRuleActionAddToList: type: object required: - type - list_id properties: type: type: string enum: - add_to_list list_id: type: string format: uuid description: Llista a la qual s'ha d'afegir el vendor_data del subjecte. description: >- Afegeix el vendor_data del subjecte a una llista de bloqueig, llista d'admesos o llista personalitzada. TransactionRuleActionOpenCase: type: object required: - type properties: type: type: string enum: - open_case blueprint: type: string format: uuid description: >- UUID del blueprint del cas; per defecte s'utilitza el blueprint per defecte de l'aplicació. grouping: type: string enum: - by_applicant - by_rule_and_applicant description: >- Indica si les coincidències repetides s'associen a un únic cas per sol·licitant o a un per regla+sol·licitant. attach_matched_transaction: type: boolean description: Adjunta la transacció coincident al cas. description: >- Obre (o afegeix a) un cas d'investigació. Només s'aplica la primera acció open_case d'una regla. securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- La clau d'API de la teva aplicació, des de Developers -> API keys a la Business Console. La clau primària té accés complet. Una clau amb nom pot tenir l'abast limitat: cap, lectura o escriptura per recurs, limitada a determinats fluxos de treball o a sessions aprovades, a una llista d'adreces IP i a una data de caducitat. 401 significa que la clau és incorrecta, revocada o caducada; 403 significa que no s'ha enviat cap clau, que la clau no té accés a aquest recurs o acció, o que la sol·licitud prové d'una adreça fora de la seva llista d'IP; 404 en una ruta de sessió significa que la sessió està fora dels fluxos de treball o estats de la clau. Una clau sense accés a fitxers multimèdia rep els URL d'imatge, vídeo i PDF com a null, i una clau sense permís d'escriptura de sessions rep els enllaços de sessió i els tokens com a null. Consulta https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.