Listar Regras

curl --request GET \
  --url http://api.gu1.ai/rules \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('http://api.gu1.ai/rules', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "http://api.gu1.ai/rules",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "http://api.gu1.ai/rules"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("http://api.gu1.ai/rules")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "rules": [
    {}
  ],
  "total": "<string>",
  "page": 123,
  "pageSize": 123,
  "totalPages": 123
}

GET

rules

Listar Regras

curl --request GET \
  --url http://api.gu1.ai/rules \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('http://api.gu1.ai/rules', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "http://api.gu1.ai/rules",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "http://api.gu1.ai/rules"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("http://api.gu1.ai/rules")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

{
  "rules": [
    {}
  ],
  "total": "<string>",
  "page": 123,
  "pageSize": 123,
  "totalPages": 123
}

Visão Geral

Recupera una lista paginada de reglas con soporte para filtrado por estado, categoría, tipo de entidad, etiquetas y búsqueda. Útil para mostrar bibliotecas de reglas, dashboards e interfaces de administración.

Endpoint

GET http://api.gu1.ai/rules

Autenticação

Requer uma chave API válida no cabeçalho de Authorization:

Authorization: Bearer YOUR_API_KEY

Parâmetros de Consulta

number

default:"1"

Número de página para paginación

number

default:"20"

Número de reglas por página (máx: 100)

string

Filtrar por estado: draft, active, shadow, archived, inactive

string

Filtrar por categoría: kyc, kyb, aml, fraud, compliance, custom

boolean

Filtrar por estado habilitado: true o false

string

Filtrar por tipo de entidad: person, company, transaction

string

Filtrar por UUID de matriz de riesgo

string

Filtrar por etiquetas (separadas por comas): high-risk,pep,sanctions

string

Buscar en nombre y descripción de regla

string

default:"updatedAt"

Campo de ordenamiento: name, priority, createdAt, updatedAt, score

string

default:"desc"

Orden de clasificación: asc o desc

Respuesta

array

Array de objetos de regla

string

Número total de reglas que coinciden con los filtros

number

Número de página actual

number

Número de elementos por página

number

Número total de páginas

Exemplos de Requisições

Listar Todas las Reglas Activas

curl -X GET "http://api.gu1.ai/rules?status=active&enabled=true" \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules?status=active&enabled=true',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();
console.log(`Encontradas ${data.total} reglas activas`);
console.log('Reglas:', data.rules.map(r => r.name));

import requests

response = requests.get(
    'http://api.gu1.ai/rules',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    },
    params={
        'status': 'active',
        'enabled': True
    }
)

data = response.json()
print(f"Encontradas {data['total']} reglas activas")
for rule in data['rules']:
    print(f"  - {rule['name']}")

Buscar Reglas

curl -X GET "http://api.gu1.ai/rules?search=sanctions&category=aml" \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules?search=sanctions&category=aml',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();
console.log(`Encontradas ${data.total} reglas que coinciden con "sanctions"`);

response = requests.get(
    'http://api.gu1.ai/rules',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    },
    params={
        'search': 'sanctions',
        'category': 'aml'
    }
)

data = response.json()
print(f"Encontradas {data['total']} reglas que coinciden con 'sanctions'")

Filtrar por Tipo de Entidad y Matriz de Riesgo

curl -X GET "http://api.gu1.ai/rules?targetEntityType=company&riskMatrixId=d257247b-af7b-402a-ad8f-eac209e2990e&pageSize=50" \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules?' + new URLSearchParams({
    targetEntityType: 'company',
    riskMatrixId: 'd257247b-af7b-402a-ad8f-eac209e2990e',
    pageSize: 50
  }),
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();
console.log(`Encontradas ${data.total} reglas de empresas en esta matriz`);

response = requests.get(
    'http://api.gu1.ai/rules',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    },
    params={
        'targetEntityType': 'company',
        'riskMatrixId': 'd257247b-af7b-402a-ad8f-eac209e2990e',
        'pageSize': 50
    }
)

data = response.json()
print(f"Encontradas {data['total']} reglas de empresas en esta matriz")

Ordenar por Prioridad

curl -X GET "http://api.gu1.ai/rules?sortBy=priority&sortOrder=desc&status=active" \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules?sortBy=priority&sortOrder=desc&status=active',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();
console.log('Reglas ordenadas por prioridad:');
data.rules.forEach(rule => {
  console.log(`  [${rule.priority}] ${rule.name}`);
});

response = requests.get(
    'http://api.gu1.ai/rules',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    },
    params={
        'sortBy': 'priority',
        'sortOrder': 'desc',
        'status': 'active'
    }
)

data = response.json()
print('Reglas ordenadas por prioridad:')
for rule in data['rules']:
    print(f"  [{rule['priority']}] {rule['name']}")

Filtrar por Etiquetas

curl -X GET "http://api.gu1.ai/rules?tags=high-risk,pep" \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch(
  'http://api.gu1.ai/rules?tags=high-risk,pep',
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();
console.log(`Encontradas ${data.total} reglas etiquetadas con high-risk O pep`);

response = requests.get(
    'http://api.gu1.ai/rules',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY'
    },
    params={
        'tags': 'high-risk,pep'
    }
)

data = response.json()
print(f"Encontradas {data['total']} reglas etiquetadas con high-risk O pep")

Exemplo de Resposta

{
  "rules": [
    {
      "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,
      "targetEntityTypes": ["company"],
      "evaluationMode": "sync",
      "riskMatrixId": "d257247b-af7b-402a-ad8f-eac209e2990e",
      "version": 1,
      "tags": [],
      "createdBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
      "createdAt": "2024-12-22T14:10:28.131Z",
      "updatedAt": "2024-12-22T14:44:29.627Z",
      "stats": {
        "failures": 0,
        "successes": 7,
        "executions": 7
      }
    },
    {
      "id": "a5a29ed9-1e98-4a57-8e89-3aa819d5da0a",
      "organizationId": "71e8f908-e032-4fcb-b0ce-ad0cd0ffb236",
      "name": "Terrorism Sanctions Check",
      "description": "Detect entities with terrorism-related sanctions",
      "category": "aml",
      "status": "active",
      "enabled": true,
      "priority": 100,
      "score": 95,
      "targetEntityTypes": ["person", "company"],
      "evaluationMode": "sync",
      "riskMatrixId": "b6d543cb-1006-4bbb-8777-c43859d51c8a",
      "version": 1,
      "tags": ["sanctions", "terrorism", "critical"],
      "createdBy": "f35c10cb-9b67-4cda-9aea-f36567375dba",
      "createdAt": "2024-12-21T17:09:00.746Z",
      "updatedAt": "2024-12-22T14:41:32.821Z",
      "stats": {
        "failures": 12,
        "successes": 7,
        "executions": 19
      }
    }
  ],
  "total": "2",
  "page": 1,
  "pageSize": 20,
  "totalPages": 1
}

Ejemplo de Paginación

async function getAllRules() {
  const allRules = [];
  let page = 1;
  const pageSize = 100;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(
      `http://api.gu1.ai/rules?page=${page}&pageSize=${pageSize}`,
      {
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY'
        }
      }
    );

    const data = await response.json();
    allRules.push(...data.rules);

    hasMore = page < data.totalPages;
    page++;
  }

  return allRules;
}

// Uso
const rules = await getAllRules();
console.log(`Recuperadas ${rules.length} reglas en total`);

Casos de Uso

Construir Dashboard de Reglas

async function buildRuleDashboard() {
  // Obtener reglas activas agrupadas por categoría
  const categories = ['kyc', 'kyb', 'aml', 'fraud', 'compliance'];
  const dashboard = {};

  for (const category of categories) {
    const response = await fetch(
      `http://api.gu1.ai/rules?category=${category}&status=active`,
      {
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY'
        }
      }
    );

    const data = await response.json();
    dashboard[category] = {
      total: parseInt(data.total),
      rules: data.rules.map(r => ({
        id: r.id,
        name: r.name,
        enabled: r.enabled,
        priority: r.priority,
        score: r.score,
        executions: r.stats.executions,
        successRate: (r.stats.successes / r.stats.executions * 100).toFixed(1) + '%'
      }))
    };
  }

  return dashboard;
}

Monitorear Reglas de Alta Prioridad

def monitor_high_priority_rules():
    """Monitorear reglas con prioridad >= 90"""
    response = requests.get(
        'http://api.gu1.ai/rules',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        },
        params={
            'sortBy': 'priority',
            'sortOrder': 'desc',
            'pageSize': 100
        }
    )

    data = response.json()
    high_priority = [r for r in data['rules'] if r['priority'] >= 90]

    print(f"Encontradas {len(high_priority)} reglas de alta prioridad:\n")

    for rule in high_priority:
        status_icon = '✅' if rule['enabled'] else '❌'
        print(f"{status_icon} [{rule['priority']}] {rule['name']}")
        print(f"   Categoría: {rule['category']}")
        print(f"   Ejecuciones: {rule['stats']['executions']}")
        print(f"   Tasa de Éxito: {rule['stats']['successes'] / max(rule['stats']['executions'], 1) * 100:.1f}%")
        print()

    return high_priority

Buscar Reglas por Matriz de Riesgo

async function getRulesByMatrix(riskMatrixId) {
  const response = await fetch(
    `http://api.gu1.ai/rules?riskMatrixId=${riskMatrixId}&pageSize=100`,
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const data = await response.json();

  return {
    matrixId: riskMatrixId,
    totalRules: parseInt(data.total),
    active: data.rules.filter(r => r.enabled).length,
    inactive: data.rules.filter(r => !r.enabled).length,
    byCategory: data.rules.reduce((acc, rule) => {
      acc[rule.category] = (acc[rule.category] || 0) + 1;
      return acc;
    }, {}),
    rules: data.rules
  };
}

Buscar y Filtrar

def search_rules(search_term, filters=None):
    """Búsqueda avanzada de reglas con múltiples filtros"""
    params = {
        'search': search_term,
        'pageSize': 50
    }

    if filters:
        params.update(filters)

    response = requests.get(
        'http://api.gu1.ai/rules',
        headers={
            'Authorization': 'Bearer YOUR_API_KEY'
        },
        params=params
    )

    data = response.json()

    print(f"Búsqueda: '{search_term}'")
    if filters:
        print(f"Filtros: {filters}")
    print(f"Resultados: {data['total']} reglas encontradas\n")

    for rule in data['rules']:
        print(f"- {rule['name']}")
        print(f"  Categoría: {rule['category']} | Estado: {rule['status']}")
        print(f"  Puntaje: {rule['score']} | Prioridad: {rule['priority']}")
        print()

    return data['rules']

# Ejemplo de uso
search_rules('pep', {
    'category': 'aml',
    'status': 'active',
    'enabled': True
})

Exportar Reglas para Respaldo

async function exportAllRules() {
  const response = await fetch(
    'http://api.gu1.ai/rules?pageSize=100',
    {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    }
  );

  const data = await response.json();

  // Crear objeto de respaldo
  const backup = {
    exportDate: new Date().toISOString(),
    totalRules: parseInt(data.total),
    rules: data.rules.map(rule => ({
      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.scope,
      tags: rule.tags
    }))
  };

  // Guardar a archivo (Node.js)
  const fs = require('fs');
  fs.writeFileSync(
    `rules-backup-${Date.now()}.json`,
    JSON.stringify(backup, null, 2)
  );

  console.log(`Exportadas ${backup.totalRules} reglas`);

  return backup;
}

Melhores Práticas

Usar Paginación: Siempre paginar al recuperar conjuntos grandes de reglas
Filtrar Eficientemente: Combinar filtros para reducir resultados (categoría + estado + habilitado)
Cachear Resultados: Cachear listas de reglas accedidas frecuentemente
Ordenar Estratégicamente: Ordenar por prioridad para orden de ejecución, por updatedAt para cambios recientes
Monitorear Rendimiento: Rastrear reglas con altas tasas de fallo usando stats
Usar Etiquetas: Aprovechar etiquetas para organización y filtrado personalizado

Notas de Rendimiento

Tamaño de página predeterminado: 20 reglas
Tamaño máximo de página: 100 reglas
Tiempo de respuesta promedio: 50-150ms
Índices de búsqueda: nombre, descripción
Índices de filtro: status, category, enabled, targetEntityType, riskMatrixId

Veja Também

Obter Regra - Recuperar detalles específicos de regla
Criar Regra - Crear nuevas reglas
Atualizar Regra - Modificar reglas existentes
Executar Regra - Probar ejecución de regla

Obter Regra Atualizar Regra

⌘I

​Visão Geral

​Endpoint

​Autenticação

​Parâmetros de Consulta

​Respuesta

​Exemplos de Requisições

​Listar Todas las Reglas Activas

​Buscar Reglas

​Filtrar por Tipo de Entidad y Matriz de Riesgo

​Ordenar por Prioridad

​Filtrar por Etiquetas

​Exemplo de Resposta

​Ejemplo de Paginación

​Casos de Uso

​Construir Dashboard de Reglas

​Monitorear Reglas de Alta Prioridad

​Buscar Reglas por Matriz de Riesgo

​Buscar y Filtrar

​Exportar Reglas para Respaldo

​Melhores Práticas

​Notas de Rendimiento

​Veja Também

Visão Geral

Endpoint

Autenticação

Parâmetros de Consulta

Respuesta

Exemplos de Requisições

Listar Todas las Reglas Activas

Buscar Reglas

Filtrar por Tipo de Entidad y Matriz de Riesgo

Ordenar por Prioridad

Filtrar por Etiquetas

Exemplo de Resposta

Ejemplo de Paginación

Casos de Uso

Construir Dashboard de Reglas

Monitorear Reglas de Alta Prioridad

Buscar Reglas por Matriz de Riesgo

Buscar y Filtrar

Exportar Reglas para Respaldo

Melhores Práticas

Notas de Rendimiento

Veja Também