> ## 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.

# API para listar reglas de monitorización de transacciones

> Lista las reglas KYT de tu aplicación en Didit, predefinidas y personalizadas, con filtros por origen, categoría, modo, paquete y búsqueda.

Prompt de la API para listar reglas
Copiar el prompt al portapapeles

<pre>
  \`List the transaction-monitoring rules of my Didit application.

  Endpoint:
  GET [https://verification.didit.me/v3/transactions/rules/](https://verification.didit.me/v3/transactions/rules/)

  Authentication:
  Use the x-api-key header with my Didit API key.

  Query parameters (all optional):

  * source: PRESET | CUSTOM
  * category, mode (ACTIVE | DISABLED | TEST), bundle, search
  * ordering: comma-separated from run\_count, approved\_pct, reviewed\_pct, declined\_pct, latest\_triggered\_at, title, created\_at, source (prefix with - for descending; default source,-run\_count)
  * limit, offset for pagination

  Behavior:

  * The list returns your custom rules plus any library presets you have installed (see the install endpoint).
  * Each row carries the full rule configuration (scope, conditions, aggregation, actions) plus execution counters (run\_count, approved/reviewed/declined percentages, latest\_triggered\_at).
  * Titles are unique per application - read this list before creating a rule to avoid a duplicate-title 400.

  Full guide: /transaction-monitoring/rules-api.\`
</pre>

Pegar en


## OpenAPI

````yaml es/openapi-25.json GET /v3/transactions/rules/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de verificación de identidad. Autentícate con el encabezado x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/transactions/rules/:
    get:
      tags:
        - Transactions
      summary: Listar reglas
      description: >-
        Lista las reglas de monitorización de transacciones de la aplicación:
        tus reglas personalizadas más los presets de la biblioteca que hayas
        instalado. Filtra por origen, categoría, modo, paquete o búsqueda de
        texto libre; ordena con `ordering` (run_count, approved_pct,
        reviewed_pct, declined_pct, latest_triggered_at, title, created_at,
        source, cada uno con un prefijo `-` opcional).
      operationId: listTransactionRules
      parameters:
        - name: source
          in: query
          required: false
          schema:
            type: string
            enum:
              - PRESET
              - CUSTOM
          description: PRESET o CUSTOM
        - name: category
          in: query
          required: false
          schema:
            type: string
          description: Filtra por categoría de regla
        - name: mode
          in: query
          required: false
          schema:
            type: string
            enum:
              - ACTIVE
              - DISABLED
              - TEST
          description: ACTIVE, DISABLED o TEST
        - name: bundle
          in: query
          required: false
          schema:
            type: string
          description: Filtrar configuraciones predefinidas por paquete
        - name: search
          in: query
          required: false
          schema:
            type: string
          description: >-
            Coincidencia sin distinguir mayúsculas y minúsculas con el título y
            la descripción
        - name: ordering
          in: query
          required: false
          schema:
            type: string
          description: >-
            Campos de ordenación separados por comas; por defecto,
            source,-run_count
        - name: limit
          in: query
          required: false
          schema:
            type: integer
          description: Tamaño de página
        - name: offset
          in: query
          required: false
          schema:
            type: integer
          description: Desplazamiento de página
      responses:
        '200':
          description: Reglas paginadas.
          content:
            application/json:
              schema:
                type: object
                properties:
                  count:
                    type: integer
                  next:
                    type: string
                    nullable: true
                  previous:
                    type: string
                    nullable: true
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/TransactionRuleDetail'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X GET
            'https://verification.didit.me/v3/transactions/rules/?source=CUSTOM&ordering=-run_count'
            \
              -H 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            for item in client.transactions.rules.list():
                print(item)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            for await (const item of didit.transactions.rules.list()) {
              console.log(item);
            }
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\niter := client.Transactions.Rules.ListAutoPaging(ctx, didit.TransactionsRulesListParams{})\nfor iter.Next() {\n\tfmt.Printf(\"%+v\\n\", iter.Current())\n}\nif err := iter.Err(); err != nil {\n\tlog.Fatal(err)\n}"
        - lang: java
          label: Java
          source: |-
            import me.didit.Didit;

            // Reads DIDIT_API_KEY.
            Didit client = new Didit();

            for (var item : client.transactions().rules().list()) {
                System.out.println(item);
            }
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

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

            foreach ($didit->transactions->rules->list() as $item) {
                print_r($item->toArray());
            }
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            didit.transactions.rules.list.auto_paging_each do |item|
              puts item.to_h
            end
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            await foreach (var item in await
            client.Transactions.Rules.ListAsync())

            {
                Console.WriteLine(JsonSerializer.Serialize(item));
            }
components:
  schemas:
    TransactionRuleDetail:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        title:
          type: string
          description: >-
            Nombre de la regla. Único por aplicación entre las reglas no
            eliminadas; los duplicados devuelven 400.
        description:
          type: string
          nullable: true
        category:
          type: string
          description: >-
            Tema de riesgo que se usa para agrupar y generar informes, p. ej.,
            finance, aml_ctf, anomaly_detection, fatf, device_intelligence,
            crypto_monitoring, travel_rule, responsible_gaming, e_commerce.
        mode:
          type: string
          enum:
            - ACTIVE
            - DISABLED
            - TEST
          description: >-
            ACTIVE evalúa en vivo. TEST evalúa y registra las ejecuciones de
            reglas, pero nunca modifica la puntuación ni el estado: es el modo
            inicial recomendado. DISABLED se omite.
        evaluation_mode:
          type: string
          enum:
            - ALL
            - ANY
          default: ALL
          description: >-
            Indica si deben cumplirse todas las condiciones (ALL) o al menos una
            (ANY). Se ignora cuando las condiciones usan group_index.
        scope:
          $ref: '#/components/schemas/TransactionRuleScope'
        conditions:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleCondition'
        aggregation:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleAggregation'
        actions:
          type: array
          items:
            $ref: '#/components/schemas/TransactionRuleAction'
        metadata:
          type: object
          description: Metadatos libres guardados en la regla.
        severity:
          type: string
          enum:
            - UNKNOWN
            - LOW
            - MEDIUM
            - HIGH
            - CRITICAL
          nullable: true
          description: >-
            Gravedad informativa que incluyen las reglas de la biblioteca; no se
            puede establecer en reglas personalizadas.
        source:
          type: string
          enum:
            - PRESET
            - CUSTOM
          description: >-
            Las reglas PRESET provienen de la biblioteca (instalar/desinstalar,
            ediciones solo del modo); las reglas CUSTOM son completamente tuyas.
        library_key:
          type: string
          nullable: true
          description: >-
            Identificador estable de la biblioteca; null para reglas
            personalizadas.
        latest_triggered_at:
          type: string
          format: date-time
          nullable: true
        run_count:
          type: integer
          description: Cuántas transacciones coincidieron con esta regla.
        approved_count:
          type: integer
        reviewed_count:
          type: integer
        declined_count:
          type: integer
        awaiting_user_count:
          type: integer
        approved_pct:
          type: number
        reviewed_pct:
          type: number
        declined_pct:
          type: number
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
    TransactionRuleScope:
      type: object
      properties:
        transaction_types:
          type: array
          items:
            type: string
          description: >-
            Restringe a tipos de transacción, por ejemplo finance, kyc,
            travel_rule, user_event. Vacío o ausente = sin restricción.
        directions:
          type: array
          items:
            type: string
            enum:
              - INBOUND
              - OUTBOUND
          description: >-
            Restringe a direcciones de transacción (sin distinguir mayúsculas y
            minúsculas al escribir).
        action_types:
          type: array
          items:
            type: string
          description: >-
            Restringe a tus valores de action_type, por ejemplo withdrawal,
            deposit.
      description: >-
        A qué transacciones se aplica la regla. Solo se aceptan estas tres
        claves.
    TransactionRuleCondition:
      type: object
      required:
        - field
        - operator
      properties:
        field:
          type: string
          description: >-
            Ruta del campo de la transacción que se evalúa. Campos principales:
            amount, currency, direction, action_type, score, severity,
            transaction_type, payment_details, preferred_currency_amount (si no
            existe, se usa 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 (y sus equivalentes
            counterparty_payment_method_*), travel_rule_status,
            travel_rule_required, travel_rule_obligations_count,
            counterparty_dd_status (tu decisión sobre la contraparte de Travel
            Rule: APPROVED, RESTRICTED o BLOCKED; una entidad sigue la de su
            marca), counterparty_risk_level (LOW, MEDIUM o HIGH; HIGH mientras
            tu propio análisis de la contraparte esté marcado),
            counterparty_jurisdiction (el país del VASP de la contraparte),
            counterparty_responsiveness (RESPONSIVE, UNRESPONSIVE o UNKNOWN),
            subject_days_since_previous_transaction, tags y custom_values.<key>
            para cualquier clave enviada en custom_properties al crear la
            transacción. Los campos de código de país aceptan ISO-2 o ISO-3;
            ambos lados se normalizan a ISO-3 antes de la comparación.
        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: >-
            Operador de comparación. in/not_in comprueban la pertenencia (value
            puede ser una lista o un único valor escalar). contains/not_contains
            son comprobaciones de subcadena sin distinguir mayúsculas y
            minúsculas sobre un valor de tipo cadena. contains_any recibe una
            lista de cadenas y coincide cuando alguna de ellas es una subcadena
            del valor del campo, sin distinguir mayúsculas y minúsculas. regex
            compara el patrón de value con el campo. fuzzy_match compara con la
            cadena de value usando el umbral `score` requerido (0-100).
            gt/gte/lt/lte nunca coinciden cuando falta alguno de los dos lados.
            exists/is_not_empty/is_not_null (alias) y
            not_exists/is_empty/is_null (alias) son comprobaciones de presencia
            que ignoran `value`.
        value:
          description: >-
            Valor de comparación. Su forma depende del operador y de value_type;
            omítelo para los operadores de comprobación de presencia. Todos los
            demás operadores necesitan un valor que no sea `null` ni una lista
            vacía; de lo contrario, la regla se rechaza con `400`.
            `contains_any` necesita una lista de cadenas, y `contains`,
            `not_contains` y `regex` necesitan una única cadena.
        value_type:
          type: string
          enum:
            - list
            - field
            - relative_date
          description: >-
            Interpretación opcional del valor. `list`: el valor es el UUID de
            una lista y las entradas de la lista pasan a ser el valor de
            comparación. `field`: el valor es la ruta de otro campo y se compara
            campo con campo. `relative_date`: el valor es un objeto de fecha
            relativa, p. ej. {"direction": "past", "unit": "days", "amount":
            30}.
        score:
          type: number
          minimum: 0
          maximum: 100
          description: >-
            Obligatorio cuando operator es fuzzy_match: el umbral de similitud
            de 0 a 100.
        group_index:
          type: integer
          description: >-
            Lógica agrupada opcional. Cuando alguna condición incluye
            group_index, las condiciones que comparten un mismo índice forman un
            grupo y la evaluación agrupada sustituye a evaluation_mode.
        group_logic:
          type: string
          enum:
            - AND
            - OR
          default: AND
          description: Cómo se combinan las condiciones DENTRO de un grupo.
        groups_logic:
          type: string
          enum:
            - AND
            - OR
          default: OR
          description: >-
            Cómo se combinan los resultados ENTRE grupos. Se lee de la primera
            condición.
      description: >-
        Una condición lee solo la transacción que se está evaluando: nunca
        filtra la ventana de agregación.
    TransactionRuleAggregation:
      type: object
      required:
        - value
      properties:
        metric:
          type: string
          enum:
            - count
            - sum
            - max
            - min
            - avg
            - distinct_count
          default: count
          description: >-
            Cómo se agregan las transacciones históricas que coinciden.
            unique_count se acepta como alias de distinct_count.
        field:
          type: string
          default: amount
          description: >-
            Campo que se agrega mediante sum/max/min/avg/distinct_count. Se
            ignora con count.
        operator:
          type: string
          enum:
            - eq
            - ne
            - gt
            - gte
            - lt
            - lte
          default: eq
          description: Comparación aplicada a la métrica calculada.
        value:
          type: number
          description: Umbral con el que se compara la métrica calculada.
        window:
          type: string
          pattern: ^\d+(m|h|d)$
          default: 1d
          description: >-
            Ventana retrospectiva que termina en el txn_date de la transacción:
            <N>m (MINUTOS, no meses), <N>h (horas) o <N>d (días), por ejemplo
            30m, 24h, 7d, 30d.
        filters:
          type: object
          additionalProperties: true
          description: >-
            Restringe qué transacciones históricas se agregan. Las claves son
            rutas de campo del catálogo de campos de condición; un valor
            "__current__" se resuelve al valor del mismo campo en la transacción
            que se está evaluando (p. ej., {"subject_vendor_data":
            "__current__"} limita la ventana al mismo sujeto), y un valor de
            lista indica pertenencia. Los filtros comparan SOLO por igualdad o
            pertenencia: no hay filtro lt/gte, así que aquí no se puede expresar
            un rango como "transacciones históricas inferiores a 10,000". Aplica
            el rango a la métrica en su lugar (la métrica max con el operador lt
            mantiene todas las transacciones de la ventana por debajo del
            umbral).
      description: >-
        Control de velocidad sobre las transacciones históricas de la aplicación
        dentro de la ventana. Todas las entradas de agregación deben coincidir
        para que la regla coincida, independientemente de evaluation_mode. Una
        agregación solo restringe la ventana; la transacción que se evalúa está
        restringida por scope y conditions, así que repite direction, currency o
        transaction_type en ambas partes cuando la regla los garantice.
    TransactionRuleAction:
      oneOf:
        - $ref: '#/components/schemas/TransactionRuleActionAddScore'
        - $ref: '#/components/schemas/TransactionRuleActionChangeStatus'
        - $ref: '#/components/schemas/TransactionRuleActionAddTags'
        - $ref: '#/components/schemas/TransactionRuleActionAddNote'
        - $ref: '#/components/schemas/TransactionRuleActionAddToList'
        - $ref: '#/components/schemas/TransactionRuleActionOpenCase'
      discriminator:
        propertyName: type
        mapping:
          add_score: '#/components/schemas/TransactionRuleActionAddScore'
          change_status: '#/components/schemas/TransactionRuleActionChangeStatus'
          add_tags: '#/components/schemas/TransactionRuleActionAddTags'
          add_note: '#/components/schemas/TransactionRuleActionAddNote'
          add_to_list: '#/components/schemas/TransactionRuleActionAddToList'
          open_case: '#/components/schemas/TransactionRuleActionOpenCase'
      description: >-
        Una acción de regla. Una regla puede tener varias; todas se aplican a la
        vez cuando la regla coincide. Las reglas en modo TEST registran lo que
        habrían hecho sin aplicar ninguna acción.
    TransactionRuleActionAddScore:
      type: object
      required:
        - type
        - value
      properties:
        type:
          type: string
          enum:
            - add_score
        value:
          type: integer
          description: >-
            Puntos que se suman a la puntuación de riesgo de la transacción.
            Pueden ser negativos.
      description: >-
        Suma puntos a la puntuación de riesgo acumulada de la transacción; el
        total determina el estado según los umbrales de revisión/rechazo de la
        aplicación.
    TransactionRuleActionChangeStatus:
      type: object
      required:
        - type
        - value
      properties:
        type:
          type: string
          enum:
            - change_status
        value:
          type: string
          enum:
            - APPROVED
            - IN_REVIEW
            - DECLINED
            - AWAITING_USER
          description: >-
            Estado que se establece de inmediato, independientemente de la
            puntuación. Clave alias: status.
        workflow_id:
          type: string
          format: uuid
          description: >-
            OBLIGATORIO cuando el valor es AWAITING_USER: el flujo de
            verificación que se pide completar al sujeto. Clave alias:
            remediation_workflow_id. Didit crea una sesión de remediación
            alojada para el sujeto cuando se dispara la regla.
      description: >-
        Establece directamente el estado de la transacción. DECLINED siempre
        prevalece entre las reglas coincidentes.
    TransactionRuleActionAddTags:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - add_tags
        tag_uuid:
          type: string
          format: uuid
          description: Etiqueta existente de la aplicación que se va a asociar.
        tag_name:
          type: string
          description: >-
            Nombre de la etiqueta que se asociará; se crea en el primer uso (se
            almacena en mayúsculas). Indica tag_uuid o tag_name.
        tag_color:
          type: string
          description: >-
            Color hexadecimal que se usa cuando tag_name crea una etiqueta
            nueva, p. ej., #007AFE.
      description: Adjunta una etiqueta de la aplicación a la transacción coincidente.
    TransactionRuleActionAddNote:
      type: object
      required:
        - type
        - note
      properties:
        type:
          type: string
          enum:
            - add_note
        note:
          type: string
          description: >-
            Texto de la nota adjunta a la transacción (autor: Rule Engine).
            Clave alias: value.
      description: Adjunta una nota automática de analista a la transacción coincidente.
    TransactionRuleActionAddToList:
      type: object
      required:
        - type
        - list_id
      properties:
        type:
          type: string
          enum:
            - add_to_list
        list_id:
          type: string
          format: uuid
          description: Lista a la que se añade el vendor_data del sujeto.
      description: >-
        Añade el vendor_data del sujeto a una lista de bloqueo, una lista de
        permitidos o una lista personalizada.
    TransactionRuleActionOpenCase:
      type: object
      required:
        - type
      properties:
        type:
          type: string
          enum:
            - open_case
        blueprint:
          type: string
          format: uuid
          description: >-
            UUID de la plantilla de caso; por defecto, la plantilla
            predeterminada de la aplicación.
        grouping:
          type: string
          enum:
            - by_applicant
            - by_rule_and_applicant
          description: >-
            Indica si las coincidencias repetidas se agrupan en un caso por
            solicitante o en uno por regla+solicitante.
        attach_matched_transaction:
          type: boolean
          description: Adjunta la transacción coincidente al caso.
      description: >-
        Abrir un caso de investigación (o añadir a uno). Solo se aplica la
        primera acción open_case de una regla.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clave de API de tu aplicación, que encontrarás en Developers -> API
        keys en la Business Console. La clave principal tiene acceso completo.
        Una clave con nombre puede tener un alcance limitado: ninguno, lectura o
        escritura por recurso, limitada a algunos flujos o a sesiones aprobadas,
        a una lista de direcciones IP y a una fecha de caducidad. 401 significa
        que la clave es incorrecta, se revocó o expiró; 403 significa que no se
        envió ninguna clave, que la clave no tiene acceso a este recurso o
        acción, o que la solicitud provino de una dirección fuera de su lista de
        IP; 404 en una ruta de sesión significa que la sesión está fuera de los
        flujos o estados de la clave. Una clave sin acceso a contenido
        multimedia recibe las URL de imágenes, videos y PDF como null, y una
        clave sin permiso de escritura en sesiones recibe los enlaces y tokens
        de sesión como null. Consulta https://docs.didit.me/console/api-keys.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.