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}'

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)

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);

ctx := context.Background()
// Reads DIDIT_API_KEY.
client := didit.NewClient()

result, err := client.Transactions.Rules.Backtest(ctx, didit.TransactionRuleBacktestRequest{
	Conditions: didit.Some([]didit.TransactionRuleConditionParam{{
		Field:    "currency",
		Operator: "eq",
		Value:    didit.Some[any]("EUR"),
	}, {
		Field:    "amount",
		Operator: "lt",
		Value:    didit.Some[any](10000),
	}}),
	Aggregation: didit.Some([]didit.TransactionRuleAggregationParam{{
		Metric:   didit.Some(didit.TransactionRuleAggregationMetric("count")),
		Operator: didit.Some(didit.TransactionRuleAggregationOperator("gte")),
		Value:    20.0,
		Window:   didit.String("30d"),
		Filters:  didit.Some(map[string]any{"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}),
	}, {
		Metric:   didit.Some(didit.TransactionRuleAggregationMetric("max")),
		Field:    didit.String("amount"),
		Operator: didit.Some(didit.TransactionRuleAggregationOperator("lt")),
		Value:    10000.0,
		Window:   didit.String("30d"),
		Filters:  didit.Some(map[string]any{"direction": "INBOUND", "transaction_type": "finance", "subject_vendor_data": "__current__", "currency": "EUR"}),
	}}),
	EvaluationMode: didit.Some(didit.TransactionRuleBacktestRequestEvaluationMode("ALL")),
	Scope: didit.Some(didit.TransactionRuleScopeParam{
		TransactionTypes: didit.Some([]string{"finance"}),
		Directions:       didit.Some([]didit.TransactionRuleScopeDirections{"INBOUND"}),
	}),
	PeriodDays: didit.Int(90),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)

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);

<?php

require 'vendor/autoload.php';

use Didit\DiditClient;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$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,
]);
print_r($result->toArray());

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

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<string, object> { ["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<string, object> { ["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));

{
  "evaluated": 4820,
  "matched": 12,
  "affected_entities": 4,
  "period_days": 90
}