> ## 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. # Transaktionsüberwachungsregeln backtesten: Management API > Mit Didit KYT-Regeln vor der Aktivierung an der Transaktionshistorie testen: Treffer, Anzahl und betroffene Subjekte. Kostenlos, nur lesend. Prompt für die Backtest-Regeln-API Prompt in die Zwischenablage kopieren \

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

\
Einfügen in ## OpenAPI ````yaml de/openapi-25.json POST /v3/transactions/rules/backtest/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API für Ausweisverifizierung. Authentifizierung über den x-api-key-Header. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/transactions/rules/backtest/: post: tags: - Transactions summary: Regelkonfiguration für den Backtest description: >- Evaluieren Sie eine hypothetische Regelkonfiguration anhand Ihrer letzten Transaktionen (neueste zuerst, bis zum Backtest-Limit), ohne eine Regel zu erstellen oder Transaktionen zu verändern. Nutzen Sie dies vor der Aktivierung einer Regel, um zu sehen, wie oft sie zugetroffen hätte und wie viele Personen davon betroffen gewesen wären. 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: Backtest-Statistiken. 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: >- Hypothetische Regelkonfiguration zur Auswertung anhand der jüngsten Transaktionen. Schreibgeschützt und kostenlos: Es wird nichts erstellt oder geändert. Senden Sie dieselben Bedingungen, Aggregationen, evaluation_mode UND denselben Bereich wie bei der Regel, die Sie aktivieren möchten. Weggelassene Bedingungen, Aggregationen und Bereiche fügen keine eigenen Einschränkungen hinzu; das Weglassen des Bereichs kann Richtungen oder Transaktionstypen einschließen, die die gespeicherte Regel überspringt. Ein weggelassener evaluation_mode wird standardmäßig auf ALL gesetzt (was Übereinstimmungen bei einer ANY-Regel verringern kann), und ein weggelassener period_days wird standardmäßig auf 90 Tage gesetzt, nicht auf einen unbegrenzten Verlauf. TransactionRuleBacktestResult: type: object properties: evaluated: type: integer description: Ausgewertete Transaktionen (neueste zuerst, begrenzt). matched: type: integer description: Transaktionen, auf die die Konfiguration zugetroffen hätte. affected_entities: type: integer description: Unterschiedliche Subjekte (nach vendor_data) unter den Treffern. period_days: type: integer TransactionRuleCondition: type: object required: - field - operator properties: field: type: string description: >- Zu evaluierender Transaktionsfeldpfad. Kernfelder: amount, currency, direction, action_type, score, severity, transaction_type, payment_details, preferred_currency_amount (weicht auf amount_in_default_currency aus), 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 (und die counterparty_payment_method_*-Äquivalente), travel_rule_status, travel_rule_required, travel_rule_obligations_count, counterparty_dd_status (Ihre Entscheidung zur Travel-Rule-Gegenpartei: APPROVED, RESTRICTED oder BLOCKED, wobei eine Entität der Marke folgt), counterparty_risk_level (LOW, MEDIUM oder HIGH; HIGH, solange Ihr eigenes Gegenparteien-Screening markiert ist), counterparty_jurisdiction (das Land des VASP der Gegenpartei), counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE oder UNKNOWN), subject_days_since_previous_transaction, tags und custom_values. für jeden Schlüssel, der in custom_properties bei der Transaktionserstellung übermittelt wurde. Ländercode-Felder akzeptieren ISO-2 oder ISO-3; beide Seiten werden vor dem Vergleich auf ISO-3 normalisiert. 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: >- Vergleichsoperator. in/not_in prüfen die Zugehörigkeit (value kann eine Liste oder ein einzelner Skalar sein). contains/not_contains sind Substring-Prüfungen ohne Berücksichtigung der Groß-/Kleinschreibung gegen einen String-Wert. contains_any akzeptiert eine Liste von Strings und stimmt überein, wenn ein beliebiger Eintrag ein Substring des Feldwerts ohne Berücksichtigung der Groß-/Kleinschreibung ist. regex gleicht das Wertmuster mit dem Feld ab. fuzzy_match vergleicht mit dem Wert-String anhand des erforderlichen `score`-Schwellenwerts (0-100). gt/gte/lt/lte stimmen niemals überein, wenn eine der beiden Seiten fehlt. exists/is_not_empty/is_not_null (Aliase) und not_exists/is_empty/is_null (Aliase) sind Vorhandenseinsprüfungen, die `value` ignorieren. value: description: >- Vergleichswert. Dessen Struktur hängt vom Operator und value_type ab; lassen Sie ihn bei Vorhandenseinsprüfungs-Operatoren weg. Jeder andere Operator erfordert einen Wert, der weder `null` noch eine leere Liste ist, andernfalls wird die Regel mit `400` abgelehnt. `contains_any` erfordert eine Liste von Strings, und `contains`, `not_contains` sowie `regex` erfordern einen einzelnen String. value_type: type: string enum: - list - field - relative_date description: >- Optionale Interpretation des Werts. `list`: Der Wert ist eine Listen-UUID und die Einträge der Liste werden zum Vergleichswert. `field`: Der Wert ist ein anderer Feldpfad, bei dem Feld für Feld verglichen wird. `relative_date`: Der Wert ist ein Objekt für ein relatives Datum, z. B. {"direction": "past", "unit": "days", "amount": 30}. score: type: number minimum: 0 maximum: 100 description: >- Erforderlich, wenn operator fuzzy_match ist: der Ähnlichkeitsschwellenwert von 0-100. group_index: type: integer description: >- Optionale gruppierte Logik. Wenn eine Bedingung group_index enthält, bilden Bedingungen mit demselben Index eine Gruppe und die gruppierte Auswertung ersetzt evaluation_mode. group_logic: type: string enum: - AND - OR default: AND description: Wie Bedingungen INNERHALB einer Gruppe kombiniert werden. groups_logic: type: string enum: - AND - OR default: OR description: >- Wie Gruppenergebnisse GRUPPENÜBERGREIFEND kombiniert werden. Wird aus der ersten Bedingung gelesen. description: >- Eine Bedingung liest nur die ausgewertete Transaktion – sie filtert niemals das Aggregationsfenster. TransactionRuleAggregation: type: object required: - value properties: metric: type: string enum: - count - sum - max - min - avg - distinct_count default: count description: >- Wie die übereinstimmenden historischen Transaktionen aggregiert werden. unique_count wird als Alias von distinct_count akzeptiert. field: type: string default: amount description: >- Feld aggregiert nach sum/max/min/avg/distinct_count. Wird für count ignoriert. operator: type: string enum: - eq - ne - gt - gte - lt - lte default: eq description: Auf die berechnete Metrik angewendeter Vergleich. value: type: number description: Schwellenwert, mit dem die berechnete Metrik verglichen wird. window: type: string pattern: ^\d+(m|h|d)$ default: 1d description: >- Rückblickzeitraum, der am txn_date der Transaktion endet: m (MINUTEN, nicht Monate), h (Stunden) oder d (Tage), z. B. 30m, 24h, 7d, 30d. filters: type: object additionalProperties: true description: >- Grenzt ein, welche historischen Transaktionen aggregiert werden. Schlüssel sind Feldpfade aus dem Bedingungsfeldkatalog; ein Wert von „__current__“ wird zum Wert desselben Felds der ausgewerteten Transaktion aufgelöst (z. B. grenzt {"subject_vendor_data": "__current__"} das Zeitfenster auf dasselbe Subjekt ein), und ein Listenwert bedeutet Mitgliedschaft. Datensätze ohne den gruppierten Wert werden niemals zusammen gruppiert: Wenn die ausgewertete Transaktion keinen Wert für ein „__current__“-Feld aufweist (keine Gegenpartei, kein Geräte-Fingerprint), stimmt die Aggregation unabhängig von ihrem Operator nicht überein. Filter vergleichen NUR auf Gleichheit oder Mitgliedschaft – es gibt keinen lt/gte-Filter, daher kann ein Bereich wie „historische Transaktionen unter 10.000“ hier nicht ausgedrückt werden. Wenden Sie den Bereich stattdessen auf die Metrik an (Metrik max mit dem Operator lt hält jede Transaktion im Zeitfenster unter dem Schwellenwert). description: >- Velocity-Prüfung über die historischen Transaktionen der Anwendung innerhalb des Zeitfensters. Jeder Aggregationseintrag muss übereinstimmen, damit die Regel zutrifft, unabhängig von evaluation_mode. Eine Aggregation schränkt nur das Zeitfenster ein; die zu bewertende Transaktion wird durch Scope und Bedingungen eingeschränkt. Wiederholen Sie daher direction, currency oder transaction_type in beiden Teilen, wenn die Regel diese vorsieht. TransactionRuleScope: type: object properties: transaction_types: type: array items: type: string description: >- Auf Transaktionstypen einschränken, z. B. finance, kyc, travel_rule, user_event. Leer oder fehlend = keine Einschränkung. directions: type: array items: type: string enum: - INBOUND - OUTBOUND description: >- Auf Transaktionsrichtungen einschränken (beim Schreiben ohne Berücksichtigung von Groß-/Kleinschreibung). action_types: type: array items: type: string description: Auf Ihre action_type-Werte einschränken, z. B. withdrawal, deposit. description: >- Für welche Transaktionen die Regel gilt. Es werden nur diese drei Schlüssel akzeptiert. securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- Der API-Schlüssel Ihrer Anwendung, aus Entwickler -> API-Schlüssel in der Business Console. Der Primärschlüssel hat Vollzugriff. Ein benannter Schlüssel kann im Geltungsbereich eingeschränkt werden: keine, Lese- oder Schreibberechtigung pro Ressource, beschränkt auf bestimmte Workflows oder genehmigte Sitzungen, auf eine Liste von IP-Adressen und auf ein Ablaufdatum. 401 bedeutet, dass der Schlüssel falsch, widerrufen oder abgelaufen ist; 403 bedeutet, dass kein Schlüssel gesendet wurde, der Schlüssel keinen Zugriff auf diese Ressource oder Aktion hat oder die Anfrage von einer Adresse außerhalb seiner IP-Liste stammte; 404 bei einer Sitzungsroute bedeutet, dass die Sitzung außerhalb der Workflows oder Status des Schlüssels liegt. Ein Schlüssel ohne Medienzugriff erhält Bild-, Video- und PDF-URLs als null, und ein Schlüssel ohne Schreibberechtigung für Sitzungen erhält Sitzungslinks und Token als null. Siehe https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.