> ## 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 de règles de surveillance des transactions : API > Didit : testez une règle KYT sur votre historique avant activation. Correspondances, transactions évaluées, sujets concernés. Gratuit. Prompt de l'API de backtest des règles Copier le prompt dans le presse-papiers \

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

\
Coller dans ## OpenAPI ````yaml fr/openapi-25.json POST /v3/transactions/rules/backtest/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/transactions/rules/backtest/: post: tags: - Transactions summary: Configuration de la règle de backtest description: >- Évaluez une configuration de règle hypothétique par rapport à vos transactions récentes (les plus récentes en premier, jusqu'au plafond de test rétrospectif) sans créer de règle ni modifier de transaction. Utilisez-la avant d'activer une règle pour voir à quelle fréquence elle aurait été satisfaite et combien de sujets elle aurait affectés. 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: Statistiques 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: >- Configuration de règle hypothétique à évaluer par rapport aux transactions récentes. En lecture seule et gratuit : rien n'est créé ni modifié. Envoyez les mêmes conditions, agrégation, mode d'évaluation (evaluation_mode) ET portée (scope) que la règle que vous prévoyez d'activer. Les conditions, l'agrégation et la portée omises n'ajoutent aucune contrainte propre ; omettre la portée peut inclure des sens ou des types de transaction que la règle enregistrée ignore. Si evaluation_mode est omis, la valeur par défaut est ALL (ce qui peut réduire les correspondances pour une règle ANY), et si period_days est omis, la valeur par défaut est de 90 jours, et non un historique illimité. TransactionRuleBacktestResult: type: object properties: evaluated: type: integer description: Transactions évaluées (les plus récentes en premier, plafonnées). matched: type: integer description: Transactions auxquelles la configuration aurait correspondu. affected_entities: type: integer description: Sujets distincts (par vendor_data) parmi les correspondances. period_days: type: integer TransactionRuleCondition: type: object required: - field - operator properties: field: type: string description: >- Chemin du champ de transaction à évaluer. Champs principaux : amount, currency, direction, action_type, score, severity, transaction_type, payment_details, preferred_currency_amount (se rabat sur amount_in_default_currency), default_currency_code, subject_country, counterparty_country, subject_vendor_data, counterparty_vendor_data, subject_device_fingerprint, counterparty_device_fingerprint, subject_browser_family, subject_browser_version, subject_platform, subject_accept_language, subject_session_age_ms, subject_ip_country, counterparty_ip_country, subject_ip_address, counterparty_ip_address, subject_payment_method_type, subject_payment_method_country, subject_payment_method_fingerprint, subject_payment_method_account_id (et les équivalents counterparty_payment_method_*), travel_rule_status, travel_rule_required, travel_rule_obligations_count, counterparty_dd_status (votre décision sur la contrepartie Travel Rule : APPROVED, RESTRICTED ou BLOCKED, une entité suivant celle de sa marque), counterparty_risk_level (LOW, MEDIUM ou HIGH ; HIGH tant que votre propre filtrage de la contrepartie est signalé), counterparty_jurisdiction (le pays du VASP de la contrepartie), counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE ou UNKNOWN), subject_days_since_previous_transaction, tags, et custom_values. pour toute clé fournie dans custom_properties lors de la création de la transaction. Les champs de code pays acceptent ISO-2 ou ISO-3 ; les deux côtés sont normalisés en ISO-3 avant la comparaison. operator: type: string enum: - eq - ne - gt - gte - lt - lte - in - not_in - contains - not_contains - contains_any - regex - fuzzy_match - exists - is_not_empty - is_not_null - not_exists - is_empty - is_null description: >- Opérateur de comparaison. in/not_in testent l'appartenance (la valeur peut être une liste ou un scalaire unique). contains/not_contains sont des vérifications de sous-chaîne insensibles à la casse par rapport à une valeur de chaîne. contains_any prend une liste de chaînes et correspond lorsque l'une d'elles est une sous-chaîne insensible à la casse de la valeur du champ. regex fait correspondre le motif de la valeur avec le champ. fuzzy_match compare avec la chaîne de valeur selon le seuil de `score` requis (0-100). gt/gte/lt/lte ne correspondent jamais lorsque l'un des côtés est manquant. exists/is_not_empty/is_not_null (alias) et not_exists/is_empty/is_null (alias) sont des vérifications de présence qui ignorent `value`. value: description: "Valeur de comparaison. Sa forme dépend de l'opérateur et de value_type\_; omettez-la pour les opérateurs de vérification de présence. Tout autre opérateur nécessite une valeur qui n'est pas `null` ou une liste vide, sinon la règle est refusée avec `400`. `contains_any` nécessite une liste de chaînes, et `contains`, `not_contains` et `regex` nécessitent une seule chaîne." value_type: type: string enum: - list - field - relative_date description: "Interprétation de la valeur optionnelle. `list`\_: la valeur est un UUID de liste et les entrées de la liste deviennent la valeur de comparaison. `field`\_: la valeur est un chemin vers un autre champ, comparé champ à champ. `relative_date`\_: la valeur est un objet de date relative, par exemple {\"direction\": \"past\", \"unit\": \"days\", \"amount\": 30}." score: type: number minimum: 0 maximum: 100 description: >- Requis lorsque l'opérateur est fuzzy_match : le seuil de similarité de 0 à 100. group_index: type: integer description: >- Logique groupée optionnelle. Lorsqu'une condition porte group_index, les conditions partageant un index forment un groupe et l'évaluation groupée remplace evaluation_mode. group_logic: type: string enum: - AND - OR default: AND description: Manière dont les conditions se combinent AU SEIN d'un groupe. groups_logic: type: string enum: - AND - OR default: OR description: >- Manière dont les résultats des groupes se combinent ENTRE les groupes. Lu à partir de la première condition. description: "Une condition lit uniquement la transaction en cours d'évaluation\_- elle ne filtre jamais la fenêtre d'agrégation." TransactionRuleAggregation: type: object required: - value properties: metric: type: string enum: - count - sum - max - min - avg - distinct_count default: count description: >- Manière dont les transactions historiques correspondantes sont agrégées. unique_count est accepté en tant qu'alias de distinct_count. field: type: string default: amount description: Champ agrégé par sum/max/min/avg/distinct_count. Ignoré pour count. operator: type: string enum: - eq - ne - gt - gte - lt - lte default: eq description: Comparaison appliquée à la métrique calculée. value: type: number description: Seuil auquel la métrique calculée est comparée. window: type: string pattern: ^\d+(m|h|d)$ default: 1d description: >- Fenêtre rétrospective se terminant à la date txn_date de la transaction : m (MINUTES, et non mois), h (heures) ou d (jours), par ex. 30m, 24h, 7d, 30d. filters: type: object additionalProperties: true description: "Restreint les transactions historiques qui sont agrégées. Les clés sont des chemins de champs issus du catalogue de champs de conditions\_; une valeur de \"__current__\" prend la valeur du même champ sur la transaction en cours d'évaluation (par exemple {\"subject_vendor_data\": \"__current__\"} restreint la fenêtre au même sujet), et une liste indique une appartenance. Les enregistrements dépourvus de la valeur de regroupement ne sont jamais regroupés ensemble\_: lorsque la transaction en cours d'évaluation n'a pas de valeur pour un champ \"__current__\" (pas de contrepartie, pas d'empreinte d'appareil), l'agrégation ne correspond pas, quel que soit son opérateur. Les filtres comparent UNIQUEMENT par égalité ou appartenance\_- il n'y a pas de filtre lt/gte, donc une plage telle que \"transactions historiques inférieures à 10 000\" ne peut pas être formulée ici. Définissez plutôt la plage sur la métrique (la métrique max avec l'opérateur lt conserve chaque transaction de la fenêtre sous le seuil)." description: >- Contrôle de vélocité sur les transactions historiques de l'application dans la fenêtre. Chaque entrée d'agrégation doit correspondre pour que la règle s'applique, quel que soit evaluation_mode. Une agrégation ne restreint que la fenêtre ; la transaction en cours d'évaluation est restreinte par le périmètre et les conditions, donc répétez la direction, la devise ou le transaction_type sur les deux moitiés lorsque la règle les prévoit. TransactionRuleScope: type: object properties: transaction_types: type: array items: type: string description: >- Restreindre aux types de transaction, par ex. finance, kyc, travel_rule, user_event. Vide ou manquant = aucune restriction. directions: type: array items: type: string enum: - INBOUND - OUTBOUND description: >- Restreindre aux directions de transaction (insensible à la casse à l'écriture). action_types: type: array items: type: string description: Restreindre à vos valeurs action_type, par ex. withdrawal, deposit. description: >- À quelles transactions la règle s'applique. Seules ces trois clés sont acceptées. securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- La clé API de votre application, issue de Développeurs -> Clés API dans la Business Console. La clé principale dispose d'un accès complet. Une clé nommée peut être restreinte : aucun, lecture ou écriture par ressource, limitée à certains workflows ou aux sessions approuvées, à une liste d'adresses IP et à une date d'expiration. 401 signifie que la clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a été envoyée, que la clé n'a pas accès à cette ressource ou action, ou que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur une route de session signifie que la session est hors des workflows ou des statuts de la clé. Une clé sans accès aux médias reçoit les URL d'images, de vidéos et de PDF à null, et une clé sans accès en écriture aux sessions reçoit les liens et tokens de session à null. Voir https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.