> ## 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.
# API de backtest de regles de monitoratge de transaccions
> Avalua una regla de KYT amb el teu historial a Didit abans d'activar-la: coincidències, recompte i subjectes afectats. Només lectura i gratuït.
Indicació de l'API de proves retrospectives de regles
Copia el prompt al porta-retalls
\
\`Backtest a hypothetical rule configuration against my recent transactions.
Endpoint:
POST https://verification.didit.me/v3/transactions/rules/backtest/
Authentication:
Use the x-api-key header with my Didit API key.
Request body (application/json):
\{
"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", "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__"}}],
"evaluation_mode": "ALL",
"scope": {"transaction_types": ["finance"], "directions": ["INBOUND"]},
"period_days": 90 // 1-365, default 90
}
Response:
\{ "evaluated": 4820, "matched": 12, "affected_entities": 4, "period_days": 90 }
Behavior:
\- Read-only and free: no rule is created, no transaction is modified, no rule runs are recorded.
\- Evaluates the most recent transactions in the period, up to the backtest cap.
\- affected_entities counts distinct subjects (by vendor_data) among the matches.
\- Use it before switching a rule to ACTIVE; a surprising match count means the thresholds need tuning.
\- Copy the candidate rule EXACTLY: same conditions, aggregation, evaluation_mode and scope. 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.
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 - same condition/aggregation/scope validation as rule create.`
\
Enganxa a
## OpenAPI
````yaml ca/openapi-25.json POST /v3/transactions/rules/backtest/
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/backtest/:
post:
tags:
- Transactions
summary: Configuració de la regla de backtest
description: >-
Avalua una configuració hipotètica de regla contra les teves
transaccions recents (les més recents primer, fins al límit de backtest)
sense crear cap regla ni modificar cap transacció. Utilitza-ho abans
d'activar una regla per veure amb quina freqüència hauria coincidit i a
quants subjectes hauria afectat.
operationId: backtestTransactionRules
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/TransactionRuleBacktestRequest'
example:
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
evaluation_mode: ALL
scope:
transaction_types:
- finance
directions:
- INBOUND
period_days: 90
responses:
'200':
description: Estadístiques de backtest.
content:
application/json:
schema:
$ref: '#/components/schemas/TransactionRuleBacktestResult'
example:
evaluated: 4820
matched: 12
affected_entities: 4
period_days: 90
security:
- ApiKeyAuth: []
x-codeSamples:
- lang: curl
label: curl
source: >-
curl -X POST
'https://verification.didit.me/v3/transactions/rules/backtest/' \
-H 'x-api-key: YOUR_API_KEY' \
-H 'Content-Type: application/json' \
-d '{"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"}}], "evaluation_mode": "ALL", "scope": {"transaction_types": ["finance"], "directions": ["INBOUND"]}, "period_days": 90}'
- lang: python
label: Python
source: |-
from didit import Didit
# Reads DIDIT_API_KEY.
client = Didit()
result = client.transactions.rules.backtest(
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"},
}],
evaluation_mode="ALL",
scope={
"transaction_types": ["finance"],
"directions": ["INBOUND"],
},
period_days=90,
)
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.backtest({
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" },
}],
evaluation_mode: "ALL",
scope: {
transaction_types: ["finance"],
directions: ["INBOUND"],
},
period_days: 90,
});
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.Backtest(ctx, didit.TransactionRuleBacktestRequest{\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\tEvaluationMode: didit.Some(didit.TransactionRuleBacktestRequestEvaluationMode(\"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\tPeriodDays: didit.Int(90),\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.TransactionRuleAggregation;
import me.didit.types.TransactionRuleBacktestRequest;
import me.didit.types.TransactionRuleCondition;
import me.didit.types.TransactionRuleScope;
// Reads DIDIT_API_KEY.
Didit client = new Didit();
var result =
client.transactions().rules().backtest(TransactionRuleBacktestRequest.builder()
.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()))
.evaluationMode(TransactionRuleBacktestRequest.EvaluationMode.of("ALL"))
.scope(TransactionRuleScope.builder()
.transactionTypes(List.of("finance"))
.directions(List.of(TransactionRuleScope.Directions.of("INBOUND")))
.build())
.periodDays(90L)
.build());
System.out.println(result);
- lang: php
label: PHP
source: |-
transactions->rules->backtest([
'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'],
]],
'evaluation_mode' => 'ALL',
'scope' => [
'transaction_types' => ['finance'],
'directions' => ['INBOUND'],
],
'period_days' => 90,
]);
print_r($result->toArray());
- lang: ruby
label: Ruby
source: |-
require "didit"
# Reads DIDIT_API_KEY.
didit = Didit::Client.new
result = didit.transactions.rules.backtest(
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" },
}],
evaluation_mode: "ALL",
scope: {
transaction_types: ["finance"],
directions: ["INBOUND"],
},
period_days: 90
)
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.BacktestAsync(new
TransactionRuleBacktestRequest
{
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" },
},
},
EvaluationMode = new TransactionRuleBacktestRequestEvaluationMode("ALL"),
Scope = new TransactionRuleScope
{
TransactionTypes = new string[] { "finance" },
Directions = new TransactionRuleScopeDirections[] { "INBOUND" },
},
PeriodDays = 90,
});
Console.WriteLine(JsonSerializer.Serialize(result));
components:
schemas:
TransactionRuleBacktestRequest:
type: object
properties:
conditions:
type: array
items:
$ref: '#/components/schemas/TransactionRuleCondition'
default: []
aggregation:
type: array
items:
$ref: '#/components/schemas/TransactionRuleAggregation'
default: []
evaluation_mode:
type: string
enum:
- ALL
- ANY
default: ALL
scope:
$ref: '#/components/schemas/TransactionRuleScope'
period_days:
type: integer
minimum: 1
maximum: 365
default: 90
description: >-
Configuració hipotètica de la regla per avaluar-la en relació amb
transaccions recents. Només de lectura i gratuïta: no es crea ni es
modifica res. Envia les mateixes conditions, aggregation,
evaluation_mode i scope que la regla que pretens activar. Les
condicions, agregacions i abasts omesos no afegeixen restriccions
pròpies; ometre l'abast pot incloure direccions o tipus de transacció
que la regla desada omet. Si s'omet evaluation_mode, el valor per
defecte és ALL (la qual cosa pot reduir les coincidències per a una
regla ANY), i si s'omet period_days, el valor per defecte és de 90 dies,
no pas un historial il·limitat.
TransactionRuleBacktestResult:
type: object
properties:
evaluated:
type: integer
description: Transaccions avaluades (les més recents primer, limitades).
matched:
type: integer
description: Transaccions amb les quals la configuració hauria coincidit.
affected_entities:
type: integer
description: Subjectes diferents (per vendor_data) entre les coincidències.
period_days:
type: integer
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.
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.
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.