> ## 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 Aturan Pemantauan Transaksi API > Uji aturan KYT hipotetis Didit pada riwayat transaksi sebelum diaktifkan: kecocokan, jumlah dievaluasi, dan subjek terdampak. Hanya baca dan gratis. Prompt API Aturan Backtest Salin prompt ke papan klip \

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

\
Tempel ke ## OpenAPI ````yaml id/openapi-25.json POST /v3/transactions/rules/backtest/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API Verifikasi Identitas. Lakukan autentikasi dengan header x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/transactions/rules/backtest/: post: tags: - Transactions summary: Konfigurasi aturan backtest description: >- Evaluasi konfigurasi aturan hipotetis terhadap transaksi terkini Anda (paling baru terlebih dahulu, hingga batas backtest) tanpa membuat aturan atau mengubah transaksi apa pun. Gunakan ini sebelum mengaktifkan aturan untuk melihat seberapa sering aturan tersebut cocok dan berapa banyak subjek yang terpengaruh. 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: Statistik 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: >- Konfigurasi aturan hipotetis untuk dievaluasi terhadap transaksi terkini. Bersifat hanya-baca dan gratis: tidak ada yang dibuat atau dimodifikasi. Kirim conditions, aggregation, evaluation_mode, DAN scope yang sama seperti aturan yang ingin Anda aktifkan. Conditions, aggregation, dan scope yang dihilangkan tidak menambahkan batasan tersendiri; menghapus scope dapat menyertakan arah atau jenis transaksi yang dilewati oleh aturan yang disimpan. evaluation_mode yang dihilangkan secara default bernilai ALL (yang dapat mengurangi kecocokan untuk aturan ANY), dan period_days yang dihilangkan secara default bernilai 90 hari, bukan riwayat tanpa batas. TransactionRuleBacktestResult: type: object properties: evaluated: type: integer description: Transaksi yang dievaluasi (terbaru lebih dulu, dibatasi). matched: type: integer description: Transaksi yang akan sesuai dengan konfigurasi tersebut. affected_entities: type: integer description: Subjek unik (berdasarkan vendor_data) di antara hasil yang cocok. period_days: type: integer TransactionRuleCondition: type: object required: - field - operator properties: field: type: string description: >- Jalur kolom transaksi yang akan dievaluasi. Kolom inti: amount, currency, direction, action_type, score, severity, transaction_type, payment_details, preferred_currency_amount (beralih ke amount_in_default_currency jika tidak tersedia), 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 (dan padanan counterparty_payment_method_*), travel_rule_status, travel_rule_required, travel_rule_obligations_count, counterparty_dd_status (keputusan Anda tentang pihak lawan Travel Rule: APPROVED, RESTRICTED, atau BLOCKED, suatu entitas yang mengikuti keputusan mereknya), counterparty_risk_level (LOW, MEDIUM, atau HIGH; HIGH saat skrining pihak lawan Anda sendiri ditandai), counterparty_jurisdiction (negara VASP pihak lawan), counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE, atau UNKNOWN), subject_days_since_previous_transaction, tags, dan custom_values. untuk kunci apa pun yang dikirimkan dalam custom_properties saat pembuatan transaksi. Kolom kode negara menerima ISO-2 atau ISO-3; kedua sisi dinormalisasi ke ISO-3 sebelum dibandingkan. 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: >- Operator perbandingan. in/not_in menguji keanggotaan (nilai dapat berupa daftar atau skalar tunggal). contains/not_contains adalah pemeriksaan substring tanpa membedakan huruf besar/kecil terhadap nilai string. contains_any menerima daftar string dan cocok jika salah satunya merupakan substring tanpa membedakan huruf besar/kecil dari nilai kolom. regex mencocokkan pola nilai terhadap kolom. fuzzy_match membandingkan terhadap string nilai dengan ambang batas `score` yang diperlukan (0-100). gt/gte/lt/lte tidak pernah cocok jika salah satu sisi tidak ada. exists/is_not_empty/is_not_null (alias) dan not_exists/is_empty/is_null (alias) adalah pemeriksaan keberadaan yang mengabaikan `value`. value: description: >- Nilai perbandingan. Bentuknya bergantung pada operator dan value_type; jangan sertakan untuk operator pemeriksaan keberadaan. Setiap operator lainnya memerlukan nilai yang bukan `null` atau daftar kosong, jika tidak, aturan akan ditolak dengan `400`. `contains_any` memerlukan daftar string, dan `contains`, `not_contains`, serta `regex` memerlukan string tunggal. value_type: type: string enum: - list - field - relative_date description: >- Interpretasi nilai opsional. `list`: nilai adalah UUID Daftar dan entri daftar menjadi nilai perbandingan. `field`: nilai adalah jalur kolom lain, dibandingkan antarkolom. `relative_date`: nilai adalah objek tanggal relatif, mis. {"direction": "past", "unit": "days", "amount": 30}. score: type: number minimum: 0 maximum: 100 description: >- Wajib jika operator adalah fuzzy_match: ambang batas kemiripan 0-100. group_index: type: integer description: >- Logika terkelompok opsional. Ketika kondisi apa pun membawa group_index, kondisi yang berbagi indeks membentuk sebuah grup dan evaluasi terkelompok menggantikan evaluation_mode. group_logic: type: string enum: - AND - OR default: AND description: Cara kondisi digabungkan DI DALAM grup. groups_logic: type: string enum: - AND - OR default: OR description: >- Cara hasil grup digabungkan DI SELURUH grup. Dibaca dari kondisi pertama. description: >- Kondisi hanya membaca transaksi yang sedang dievaluasi - kondisi ini tidak pernah memfilter jendela agregasi. TransactionRuleAggregation: type: object required: - value properties: metric: type: string enum: - count - sum - max - min - avg - distinct_count default: count description: >- Bagaimana transaksi historis yang cocok diagregasikan. unique_count diterima sebagai alias dari distinct_count. field: type: string default: amount description: >- Kolom yang diagregasikan berdasarkan sum/max/min/avg/distinct_count. Diabaikan untuk count. operator: type: string enum: - eq - ne - gt - gte - lt - lte default: eq description: Perbandingan yang diterapkan pada metrik yang dihitung. value: type: number description: Ambang batas yang dibandingkan dengan metrik terhitung. window: type: string pattern: ^\d+(m|h|d)$ default: 1d description: >- Periode penelusuran mundur yang berakhir pada txn_date transaksi: m (MENIT, bukan bulan), h (jam), atau d (hari), misalnya 30m, 24h, 7d, 30d. filters: type: object additionalProperties: true description: >- Mempersempit transaksi historis mana yang diagregasi. Kunci berupa jalur kolom dari katalog kolom kondisi; nilai "__current__" diselesaikan ke nilai kolom yang sama pada transaksi yang sedang dievaluasi (misalnya {"subject_vendor_data": "__current__"} membatasi rentang waktu pada subjek yang sama), dan nilai daftar berarti keanggotaan. Catatan tanpa nilai yang dikelompokkan tidak akan pernah dikelompokkan bersama: ketika transaksi yang dievaluasi tidak memiliki nilai untuk kolom "__current__" (tidak ada pihak lawan, tidak ada sidik jari perangkat), agregasi tidak cocok, apa pun operatornya. Filter HANYA membandingkan berdasarkan kesetaraan atau keanggotaan - tidak ada filter lt/gte, sehingga rentang seperti "transaksi historis di bawah 10.000" tidak dapat dinyatakan di sini. Tempatkan rentang pada metrik sebagai gantinya (metrik max dengan operator lt mempertahankan setiap transaksi di dalam rentang waktu di bawah ambang batas). description: >- Pemeriksaan kecepatan (velocity check) terhadap riwayat transaksi aplikasi di dalam jendela waktu. Setiap entri agregasi harus cocok agar aturan cocok, terlepas dari evaluation_mode. Agregasi hanya membatasi jendela waktu; transaksi yang sedang dievaluasi dibatasi oleh cakupan dan kondisi, jadi ulangi direction, currency, atau transaction_type di kedua bagian saat aturan memerlukannya. TransactionRuleScope: type: object properties: transaction_types: type: array items: type: string description: >- Batasi ke jenis transaksi, mis. finance, kyc, travel_rule, user_event. Kosong atau tidak ada = tanpa pembatasan. directions: type: array items: type: string enum: - INBOUND - OUTBOUND description: >- Batasi ke arah transaksi (tidak peka huruf besar/kecil saat penulisan). action_types: type: array items: type: string description: Batasi ke nilai action_type Anda, mis. withdrawal, deposit. description: >- Transaksi mana yang dikenai aturan ini. Hanya ketiga kunci ini yang diterima. securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- Kunci API aplikasi Anda, dari Developers -> API keys di Business Console. Kunci utama memiliki akses penuh. Kunci bernama dapat diberi cakupan: none, read, atau write per sumber daya, dibatasi pada beberapa alur kerja atau pada sesi yang disetujui, pada daftar alamat IP, dan pada tanggal kedaluwarsa. 401 berarti kuncinya salah, dicabut, atau kedaluwarsa; 403 berarti tidak ada kunci yang dikirimkan, kunci tidak memiliki akses ke sumber daya atau tindakan ini, atau permintaan datang dari alamat di luar daftar IP-nya; 404 pada rute sesi berarti sesi berada di luar alur kerja atau status kunci tersebut. Kunci tanpa akses media menerima URL gambar, video, dan PDF sebagai null, dan kunci tanpa izin tulis sesi menerima tautan sesi dan token sebagai null. Lihat https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.