> ## 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. # Backtest regole di Monitoraggio delle transazioni API > Didit: testa una regola KYT sullo storico delle transazioni prima di attivarla. Corrispondenze, conteggio e soggetti. Sola lettura e gratuita. Prompt API per il backtest delle regole Copia il prompt negli appunti \

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

\
Incolla in ## OpenAPI ````yaml it/openapi-25.json POST /v3/transactions/rules/backtest/ 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/backtest/: post: tags: - Transactions summary: Configurazione della regola di backtest description: >- Valuta una configurazione ipotetica di una regola rispetto alle tue transazioni recenti (dalla più recente, fino al limite massimo di backtest) senza creare una regola né modificare alcuna transazione. Utilizzala prima di attivare una regola per verificare con quale frequenza avrebbe trovato corrispondenze e quanti soggetti avrebbe interessato. 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: Statistiche di 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: >- Configurazione ipotetica della regola da valutare rispetto alle transazioni recenti. Di sola lettura e gratuita: non viene creato né modificato nulla. Invia le stesse condizioni, aggregazione, evaluation_mode E ambito (scope) della regola che intendi attivare. Condizioni, aggregazione e ambito omessi non aggiungono vincoli propri; tralasciare l'ambito può includere direzioni o tipi di transazione che la regola salvata salta. L'evaluation_mode omesso assume per impostazione predefinita il valore ALL (il che può ridurre le corrispondenze per una regola ANY), e period_days omesso assume per impostazione predefinita il valore di 90 giorni, non una cronologia illimitata. TransactionRuleBacktestResult: type: object properties: evaluated: type: integer description: Transazioni valutate (dalla più recente, con limite). matched: type: integer description: >- Transazioni per le quali la configurazione avrebbe trovato corrispondenza. affected_entities: type: integer description: Soggetti distinti (in base a vendor_data) tra le corrispondenze. period_days: type: integer 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. 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. 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.