> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gu1.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Obtener Regla

> Recuperar detalles de una regla específica por ID — en el motor de reglas gu1 para compliance y detección de riesgo, con ejemplos para get.

## Descripción General

Recupera información completa sobre una regla específica, incluyendo sus condiciones, acciones, estadísticas de ejecución e historial de versiones.

## Endpoint

```
GET http://api.gu1.ai/rules/{id}
```

## Autenticación

Requiere una clave API válida en el encabezado de Authorization:

```bash theme={null}
Authorization: Bearer YOUR_API_KEY
```

## Parámetros de Ruta

<ParamField path="id" type="string" required>
  UUID de la regla a recuperar
</ParamField>

## Respuesta

<ResponseField name="id" type="string">
  UUID de la regla
</ResponseField>

<ResponseField name="organizationId" type="string">
  ID de su organización
</ResponseField>

<ResponseField name="name" type="string">
  Nombre de la regla
</ResponseField>

<ResponseField name="description" type="string">
  Descripción de la regla
</ResponseField>

<ResponseField name="category" type="string">
  Categoría de la regla (kyc, kyb, aml, fraud, compliance, custom)
</ResponseField>

<ResponseField name="status" type="string">
  Estado actual (draft, active, shadow, archived, inactive)
</ResponseField>

<ResponseField name="enabled" type="boolean">
  Si la regla está habilitada
</ResponseField>

<ResponseField name="priority" type="number">
  Prioridad de la regla (1-100)
</ResponseField>

<ResponseField name="score" type="number">
  Puntaje de riesgo asignado cuando la regla coincide
</ResponseField>

<ResponseField name="conditions" type="object">
  Estructura de condiciones completa con lógica anidada
</ResponseField>

<ResponseField name="conditionCode" type="string">
  Representación en cadena JSON de condiciones (para almacenamiento)
</ResponseField>

<ResponseField name="actions" type="array">
  Array de acciones a ejecutar cuando la regla coincide
</ResponseField>

<ResponseField name="scope" type="object">
  Configuración de alcance de la regla (países, tipos de entidad, ventanas temporales)
</ResponseField>

<ResponseField name="targetEntityTypes" type="array">
  Array de tipos de entidad a los que se aplica la regla
</ResponseField>

<ResponseField name="evaluationMode" type="string">
  Modo de evaluación (sync o async)
</ResponseField>

<ResponseField name="riskMatrixId" type="string">
  UUID de matriz de riesgo asociada (si existe)
</ResponseField>

<ResponseField name="version" type="number">
  Número de versión actual
</ResponseField>

<ResponseField name="previousVersionId" type="string">
  UUID de la versión anterior (si existe)
</ResponseField>

<ResponseField name="tags" type="array">
  Array de etiquetas para organización
</ResponseField>

<ResponseField name="stats" type="object">
  Estadísticas de ejecución (ejecuciones, éxitos, fallos)
</ResponseField>

<ResponseField name="createdBy" type="string">
  ID del usuario que creó la regla
</ResponseField>

<ResponseField name="createdAt" type="string">
  Marca de tiempo ISO de creación
</ResponseField>

<ResponseField name="updatedBy" type="string">
  ID del usuario que actualizó la regla por última vez
</ResponseField>

<ResponseField name="updatedAt" type="string">
  Marca de tiempo ISO de última actualización
</ResponseField>

## Ejemplos de Solicitudes

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    'http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea',
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const rule = await response.json();
  console.log('Rule:', rule.name);
  console.log('Status:', rule.status);
  console.log('Executions:', rule.stats.executions);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'http://api.gu1.ai/rules/e2cdd639-52cc-4749-9b16-927bfa5dfaea',
      headers={
          'Authorization': 'Bearer YOUR_API_KEY'
      }
  )

  rule = response.json()
  print(f"Rule: {rule['name']}")
  print(f"Status: {rule['status']}")
  print(f"Executions: {rule['stats']['executions']}")
  ```
</CodeGroup>

## Ejemplo de Respuesta

```json theme={null}
{
  "id": "e2cdd639-52cc-4749-9b16-927bfa5dfaea",
  "organizationId": "71e8f908-e032-4fcb-b0ce-ad0cd0ffb236",
  "name": "CNPJ Blocklist Check",
  "description": "Block companies with specific CNPJ",
  "category": "kyb",
  "status": "active",
  "enabled": true,
  "priority": 100,
  "score": 85,
  "conditions": {
    "operator": "AND",
    "conditions": [
      {
        "id": "cond-1766412627987-0",
        "type": "simple",
        "field": "enrichmentData.normalized.taxId",
        "value": "33.592.510/0001-54",
        "filters": [],
        "operator": "eq",
        "countryMetadata": {
          "reason": "Selected from BR enrichment fields",
          "confidence": 100,
          "countryCode": "BR",
          "manuallySet": true,
          "autoDetected": false
        }
      }
    ]
  },
  "conditionCode": "{\"operator\":\"AND\",\"conditions\":[{\"field\":\"enrichmentData.normalized.taxId\",\"operator\":\"eq\",\"value\":\"33.592.510/0001-54\",\"countryMetadata\":{\"countryCode\":\"BR\",\"autoDetected\":false,\"manuallySet\":true,\"confidence\":100,\"reason\":\"Selected from BR enrichment fields\"},\"filters\":[],\"id\":\"cond-1766412627987-0\",\"type\":\"simple\"}]}",
  "actions": [
    {
      "tags": ["blocklist", "high-priority"],
      "type": "createAlert",
      "createAlert": {
        "type": "COMPLIANCE",
        "title": "Blocklisted Company Detected",
        "severity": "CRITICAL",
        "recipients": ["compliance@company.com"],
        "description": "Company CNPJ found in blocklist"
      }
    },
    {
      "tags": [],
      "type": "updateEntityStatus",
      "updateEntityStatus": {
        "status": "blocked",
        "reason": "CNPJ in blocklist"
      }
    }
  ],
  "scope": {
    "type": "entity",
    "countries": ["BR"],
    "entityTypes": ["company"],
    "temporalWindow": {
      "days": 30,
      "hours": 24
    }
  },
  "targetEntityTypes": ["company"],
  "evaluationMode": "sync",
  "riskMatrixId": "d257247b-af7b-402a-ad8f-eac209e2990e",
  "version": 1,
  "previousVersionId": null,
  "abTest": null,
  "schedule": null,
  "tags": [],
  "createdBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
  "createdAt": "2024-12-22T14:10:28.131Z",
  "updatedBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
  "updatedAt": "2024-12-22T14:44:29.627Z",
  "stats": {
    "failures": 0,
    "successes": 7,
    "executions": 7
  }
}
```

## Respuestas de Error

### 404 Not Found

```json theme={null}
{
  "error": "Rule not found",
  "id": "e2cdd639-52cc-4749-9b16-927bfa5dfaea"
}
```

### 401 Unauthorized

```json theme={null}
{
  "error": "Invalid or missing API key"
}
```

### 403 Forbidden

```json theme={null}
{
  "error": "Access denied",
  "message": "You don't have permission to view this rule"
}
```

## Casos de Uso

### Mostrar Detalles de Regla en UI

```javascript theme={null}
async function loadRuleDetails(ruleId) {
  const response = await fetch(
    `http://api.gu1.ai/rules/${ruleId}`,
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const rule = await response.json();

  return {
    id: rule.id,
    name: rule.name,
    description: rule.description,
    status: rule.status,
    enabled: rule.enabled,
    priority: rule.priority,
    score: rule.score,
    category: rule.category,
    lastUpdated: new Date(rule.updatedAt),
    performance: {
      executions: rule.stats.executions,
      successRate: (rule.stats.successes / rule.stats.executions * 100).toFixed(1) + '%',
      failureRate: (rule.stats.failures / rule.stats.executions * 100).toFixed(1) + '%'
    },
    conditions: rule.conditions,
    actions: rule.actions.map(a => ({
      type: a.type,
      details: a[a.type]
    }))
  };
}
```

### Monitorear Rendimiento de Regla

```python theme={null}
def monitor_rule_performance(rule_id):
    """Monitorear estadísticas de ejecución de regla"""
    response = requests.get(
        f'http://api.gu1.ai/rules/{rule_id}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        }
    )

    rule = response.json()
    stats = rule['stats']

    total = stats['executions']
    if total == 0:
        print(f"Regla '{rule['name']}' no se ha ejecutado aún")
        return

    success_rate = (stats['successes'] / total) * 100
    failure_rate = (stats['failures'] / total) * 100

    print(f"Regla: {rule['name']}")
    print(f"Estado: {rule['status']}")
    print(f"Habilitada: {rule['enabled']}")
    print(f"\nRendimiento:")
    print(f"  Total de Ejecuciones: {total}")
    print(f"  Tasa de Éxito: {success_rate:.1f}%")
    print(f"  Tasa de Fallo: {failure_rate:.1f}%")
    print(f"\nÚltima Actualización: {rule['updatedAt']}")

    # Alertar si la tasa de fallo es alta
    if failure_rate > 10:
        print(f"\nADVERTENCIA: Tasa de fallo alta detectada!")

    return rule
```

### Clonar Configuración de Regla

```javascript theme={null}
async function cloneRule(sourceRuleId, newName) {
  // Obtener la regla origen
  const response = await fetch(
    `http://api.gu1.ai/rules/${sourceRuleId}`,
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const sourceRule = await response.json();

  // Crear nueva regla con nombre modificado
  const newRule = {
    name: newName,
    description: `Clonada de: ${sourceRule.name}`,
    category: sourceRule.category,
    targetEntityTypes: sourceRule.targetEntityTypes,
    conditions: sourceRule.conditions,
    actions: sourceRule.actions,
    enabled: false, // Iniciar deshabilitada
    priority: sourceRule.priority,
    score: sourceRule.score,
    status: 'draft', // Iniciar como borrador
    evaluationMode: sourceRule.evaluationMode,
    scope: sourceRule.scope,
    tags: [...sourceRule.tags, 'cloned']
  };

  // Crear la regla clonada
  const createResponse = await fetch(
    'http://api.gu1.ai/rules',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(newRule)
    }
  );

  const clonedRule = await createResponse.json();
  console.log('Regla clonada exitosamente:', clonedRule.id);

  return clonedRule;
}
```

### Exportar Configuración de Regla

```python theme={null}
import json

def export_rule_config(rule_id, output_file):
    """Exportar configuración de regla a archivo JSON"""
    response = requests.get(
        f'http://api.gu1.ai/rules/{rule_id}',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        }
    )

    rule = response.json()

    # Remover campos de runtime
    export_data = {
        'name': rule['name'],
        'description': rule['description'],
        'category': rule['category'],
        'targetEntityTypes': rule['targetEntityTypes'],
        'conditions': rule['conditions'],
        'actions': rule['actions'],
        'priority': rule['priority'],
        'score': rule['score'],
        'evaluationMode': rule['evaluationMode'],
        'scope': rule.get('scope'),
        'tags': rule.get('tags', [])
    }

    # Escribir a archivo
    with open(output_file, 'w') as f:
        json.dump(export_data, f, indent=2)

    print(f"Configuración de regla exportada a {output_file}")
    return export_data
```

## Mejores Prácticas

1. **Cache de Datos de Regla**: Cachear reglas accedidas frecuentemente para reducir llamadas API
2. **Monitorear Estadísticas**: Revisar regularmente el objeto `stats` para insights de rendimiento
3. **Rastrear Versiones**: Usar `version` y `previousVersionId` para pistas de auditoría
4. **Verificar Estado**: Siempre verificar `enabled` y `status` antes de la ejecución
5. **Usar Etiquetas**: Aprovechar etiquetas para organización y filtrado

## Ver También

* [Listar Reglas](/es/api-reference/rules/list) - Consultar y filtrar reglas
* [Actualizar Regla](/es/api-reference/rules/update) - Modificar configuración de regla
* [Ejecutar Regla](/es/api-reference/rules/execute) - Probar regla contra entidades
* [Crear Regla](/es/api-reference/rules/create) - Crear nuevas reglas