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

# Flujo de trabajo KYB

> Proceso paso a paso para la verificación automatizada de empresas — en el flujo KYB de gu1 para verificación empresarial, con ejemplos para workflow.

## Flujo de trabajo completo de verificación KYB

El flujo de trabajo KYB de gu1 automatiza todo el proceso de verificación de empresas desde la recopilación inicial de datos hasta el monitoreo continuo. Esta guía recorre cada paso con detalles técnicos de implementación.

## Descripción general del flujo de trabajo

```mermaid theme={null}
graph TD
    A[Solicitud de la Empresa] --> B[Recopilación de Datos]
    B --> C[Crear Entidad]
    C --> D[Carga de Documentos]
    D --> E[Análisis con IA]
    E --> F[Evaluación de Riesgo]
    F --> G{Puntuación de Riesgo}
    G -->|Riesgo Bajo| H[Aprobación Automática]
    G -->|Riesgo Medio| I[Debida Diligencia Reforzada]
    G -->|Riesgo Alto| J[Revisión Manual]
    H --> K[Monitoreo Continuo]
    I --> K
    J --> K
    K --> L[Actualizaciones de Estado]
```

## Paso 1: Recopilación inicial de datos

### Qué recopilar

Reúna información básica de la empresa desde su formulario de solicitud:

* **Nombre de la Empresa**: Nombre legal y nombre comercial
* **Número de Registro**: Registro empresarial emitido por el gobierno
* **ID Fiscal**: EIN (EE.UU.), CNPJ (Brasil), RFC (México), etc.
* **Fecha de Constitución**: Cuándo se formó la empresa
* **País**: Jurisdicción de constitución
* **Dirección de la Empresa**: Ubicación de la oficina registrada
* **Industria**: Tipo de actividad empresarial
* **Volumen de Transacciones Esperado**: Estimaciones mensuales/anuales

### Ejemplo de formulario de solicitud

```javascript theme={null}
const businessApplication = {
  legalName: "Tech Solutions Sociedade Anônima",
  tradeName: "Tech Solutions",
  registrationNumber: "12.345.678/0001-90",
  taxId: "12.345.678/0001-90",
  incorporationDate: "2020-06-15",
  country: "BR",
  address: {
    street: "Av. Paulista, 1000",
    city: "São Paulo",
    state: "SP",
    postalCode: "01310-100"
  },
  industry: "Software Development",
  website: "https://techsolutions.com.br",
  expectedMonthlyVolume: 250000,
  businessDescription: "B2B SaaS platform for enterprise clients"
};
```

## Paso 2: Crear entidad empresarial

Use la API de Entidades para crear una entidad de empresa en gu1:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST http://api.gu1.ai/entities \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "company",
      "externalId": "business_12345",
      "name": "Tech Solutions Sociedade Anônima",
      "taxId": "12.345.678/0001-90",
      "countryCode": "BR",
      "entityData": {
        "company": {
          "legalName": "Tech Solutions Sociedade Anônima",
          "tradeName": "Tech Solutions",
          "incorporationDate": "2020-06-15",
          "industry": "Software Development",
          "employeeCount": 50,
          "revenue": 5000000
        }
      },
      "attributes": {
        "registrationNumber": "12.345.678/0001-90",
        "website": "https://techsolutions.com.br",
        "registeredAddress": "Av. Paulista, 1000, São Paulo",
        "expectedMonthlyVolume": 250000,
        "applicationDate": "2024-10-03T10:00:00Z"
      }
    }'
  ```

  ```javascript JavaScript theme={null}
  async function createBusinessEntity(applicationData) {
    const response = await fetch('http://api.gu1.ai/entities', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        type: 'company',
        externalId: applicationData.businessId,
        name: applicationData.legalName,
        taxId: applicationData.taxId,
        countryCode: applicationData.country,
        entityData: {
          company: {
            legalName: applicationData.legalName,
            tradeName: applicationData.tradeName,
            incorporationDate: applicationData.incorporationDate,
            industry: applicationData.industry,
            employeeCount: applicationData.employeeCount,
            revenue: applicationData.estimatedRevenue
          }
        },
        attributes: {
          registrationNumber: applicationData.registrationNumber,
          website: applicationData.website,
          registeredAddress: applicationData.address,
          expectedMonthlyVolume: applicationData.expectedVolume,
          applicationDate: new Date().toISOString()
        }
      })
    });

    const result = await response.json();
    return result.entity;
  }
  ```

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

  def create_business_entity(application_data):
      response = requests.post(
          'http://api.gu1.ai/entities',
          headers={
              'Authorization': f'Bearer {API_KEY}',
              'Content-Type': 'application/json'
          },
          json={
              'type': 'company',
              'externalId': application_data['business_id'],
              'name': application_data['legal_name'],
              'taxId': application_data['tax_id'],
              'countryCode': application_data['country'],
              'entityData': {
                  'company': {
                      'legalName': application_data['legal_name'],
                      'tradeName': application_data['trade_name'],
                      'incorporationDate': application_data['incorporation_date'],
                      'industry': application_data['industry'],
                      'employeeCount': application_data.get('employee_count'),
                      'revenue': application_data.get('estimated_revenue')
                  }
              },
              'attributes': {
                  'registrationNumber': application_data['registration_number'],
                  'website': application_data.get('website'),
                  'registeredAddress': application_data['address'],
                  'expectedMonthlyVolume': application_data['expected_volume'],
                  'applicationDate': datetime.now().isoformat()
              }
          }
      )

      return response.json()['entity']
  ```
</CodeGroup>

**Respuesta:**

```json theme={null}
{
  "success": true,
  "entity": {
    "id": "660e9511-f39c-52e5-b827-557766551111",
    "externalId": "business_12345",
    "type": "company",
    "name": "Tech Solutions Sociedade Anônima",
    "riskScore": 0,
    "status": "under_review",
    "createdAt": "2024-10-03T10:00:00Z"
  }
}
```

## Paso 3: Carga y verificación de documentos

Cargue los documentos empresariales requeridos para la verificación:

### Documentos requeridos

1. **Acta Constitutiva** - Documento de fundación
2. **Licencia de Negocio** - Permiso de operación emitido por el gobierno
3. **Certificado Fiscal** - Comprobante de registro fiscal
4. **Comprobante de Domicilio** - Factura de servicios o estado de cuenta bancario
5. **Declaración de Propiedad Beneficiaria** - Información de beneficiarios finales

### Cargar documentos

```javascript theme={null}
async function uploadBusinessDocuments(entityId, documents) {
  const documentUploads = [];

  for (const doc of documents) {
    const formData = new FormData();
    formData.append('file', doc.file);
    formData.append('documentType', doc.type);
    formData.append('entityId', entityId);

    const response = await fetch('http://api.gu1.ai/documents', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`
      },
      body: formData
    });

    documentUploads.push(await response.json());
  }

  return documentUploads;
}

// Uso
const documents = [
  { file: articlesOfIncorporation, type: 'articles_of_incorporation' },
  { file: businessLicense, type: 'business_license' },
  { file: taxCertificate, type: 'tax_certificate' },
  { file: proofOfAddress, type: 'proof_of_address' }
];

const uploadedDocs = await uploadBusinessDocuments(entityId, documents);
```

## Paso 4: Análisis con IA y evaluación de riesgo

Solicite un análisis impulsado por IA de la entidad empresarial:

```javascript theme={null}
async function requestAIAnalysis(entityId) {
  const response = await fetch(
    `http://api.gu1.ai/entities/${entityId}/ai-analysis`,
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        analysisType: 'kyb_verification',
        includeDocuments: true,
        checkSanctions: true,
        checkAdverseMedia: true
      })
    }
  );

  return await response.json();
}
```

**Respuesta del análisis con IA:**

```json theme={null}
{
  "analysisId": "analysis_abc123",
  "entityId": "660e9511-f39c-52e5-b827-557766551111",
  "riskScore": 35,
  "riskLevel": "medium",
  "findings": {
    "documentVerification": {
      "status": "verified",
      "confidence": 0.95,
      "articlesOfIncorporation": "valid",
      "businessLicense": "valid",
      "taxCertificate": "valid"
    },
    "businessLegitimacy": {
      "status": "verified",
      "registrationVerified": true,
      "taxIdValid": true,
      "addressConfirmed": true
    },
    "sanctionsScreening": {
      "status": "clear",
      "listsChecked": ["OFAC", "UN", "EU", "UK"],
      "matches": []
    },
    "adverseMedia": {
      "status": "minor_flags",
      "findings": [
        {
          "source": "news_article",
          "date": "2023-05-15",
          "summary": "Small tax dispute resolved",
          "severity": "low"
        }
      ]
    },
    "riskFactors": [
      {
        "factor": "new_business",
        "impact": 20,
        "description": "Company incorporated less than 5 years ago"
      },
      {
        "factor": "high_growth_industry",
        "impact": 15,
        "description": "Software industry has elevated fraud risk"
      },
      {
        "factor": "clean_compliance_history",
        "impact": -10,
        "description": "No regulatory violations found"
      }
    ]
  },
  "recommendation": "approve_with_monitoring",
  "nextSteps": [
    "Verify beneficial ownership",
    "Set transaction monitoring thresholds",
    "Schedule 6-month review"
  ]
}
```

## Paso 5: Decisión basada en riesgo

Según la puntuación de riesgo, enrute al flujo de trabajo apropiado:

```javascript theme={null}
async function processKYBDecision(analysisResult) {
  const { riskScore, riskLevel, recommendation } = analysisResult;

  if (riskScore < 30) {
    // Riesgo Bajo - Aprobación automática
    return await autoApprove(analysisResult.entityId);

  } else if (riskScore < 70) {
    // Riesgo Medio - Debida Diligencia Reforzada
    return await enhancedDueDiligence(analysisResult.entityId);

  } else {
    // Riesgo Alto - Revisión Manual Requerida
    return await flagForManualReview(analysisResult.entityId, analysisResult.findings);
  }
}

async function autoApprove(entityId) {
  // Actualizar estado de la entidad a aprobado
  await fetch(`http://api.gu1.ai/entities/${entityId}`, {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      attributes: {
        kybStatus: 'approved',
        approvedAt: new Date().toISOString(),
        approvedBy: 'automated_system',
        reviewNotes: 'Low risk - auto-approved'
      }
    })
  });

  // Enviar notificación de aprobación
  await sendApprovalEmail(entityId);

  // Habilitar monitoreo
  await enableOngoingMonitoring(entityId);

  return { status: 'approved', action: 'auto_approved' };
}

async function enhancedDueDiligence(entityId) {
  // Solicitar información adicional
  await requestAdditionalDocs(entityId, [
    'financial_statements',
    'ownership_structure',
    'source_of_funds'
  ]);

  // Actualizar estado
  await updateEntityStatus(entityId, 'enhanced_due_diligence');

  return { status: 'pending', action: 'edd_required' };
}

async function flagForManualReview(entityId, findings) {
  // Crear tarea de revisión
  await createReviewTask({
    entityId,
    priority: 'high',
    assignTo: 'compliance_team',
    findings,
    dueDate: new Date(Date.now() + 24 * 60 * 60 * 1000) // 24 horas
  });

  return { status: 'manual_review', action: 'flagged_for_review' };
}
```

## Paso 6: Verificación de beneficiarios finales

Identifique y verifique los Beneficiarios Finales (UBO):

```javascript theme={null}
async function verifyBeneficialOwners(entityId, owners) {
  const verifiedOwners = [];

  for (const owner of owners) {
    // Crear entidad persona para cada UBO
    const uboEntity = await fetch('http://api.gu1.ai/entities', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        type: 'person',
        externalId: `ubo_${owner.id}`,
        name: `${owner.firstName} ${owner.lastName}`,
        countryCode: owner.nationality,
        entityData: {
          person: {
            firstName: owner.firstName,
            lastName: owner.lastName,
            dateOfBirth: owner.dateOfBirth,
            nationality: owner.nationality
          }
        },
        attributes: {
          ownershipPercentage: owner.ownership,
          isPEP: owner.isPEP,
          relationshipToCompany: 'beneficial_owner'
        }
      })
    });

    const ubo = await uboEntity.json();

    // Ejecutar verificaciones KYC en el UBO
    const kycResult = await runKYCCheck(ubo.entity.id);

    // Crear relación entre la empresa y el UBO
    await createRelationship({
      fromEntityId: entityId,
      toEntityId: ubo.entity.id,
      relationshipType: 'beneficial_owner',
      ownershipPercentage: owner.ownership
    });

    verifiedOwners.push({
      ...ubo.entity,
      kycStatus: kycResult.status,
      riskScore: kycResult.riskScore
    });
  }

  return verifiedOwners;
}
```

## Paso 7: Configurar monitoreo continuo

Habilite el monitoreo continuo para empresas aprobadas:

```javascript theme={null}
async function setupOngoingMonitoring(entityId) {
  // Configurar reglas de monitoreo
  await fetch('http://api.gu1.ai/rules', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: `KYB Monitoring - ${entityId}`,
      entityId: entityId,
      rules: [
        {
          type: 'sanctions_screening',
          frequency: 'daily',
          action: 'alert_compliance_team'
        },
        {
          type: 'adverse_media',
          frequency: 'weekly',
          action: 'create_review_task'
        },
        {
          type: 'ownership_changes',
          frequency: 'realtime',
          action: 'trigger_reverification'
        },
        {
          type: 'transaction_anomalies',
          threshold: 'high',
          action: 'flag_for_review'
        }
      ]
    })
  });

  // Configurar notificaciones webhook
  await configureWebhook({
    entityId,
    events: [
      'sanctions_match',
      'adverse_media_found',
      'ownership_change',
      'transaction_anomaly'
    ],
    url: 'https://your-app.com/webhooks/kyb-alerts'
  });
}
```

## Paso 8: Actualizaciones de estado y notificaciones

Mantenga informada a la empresa durante todo el proceso:

```javascript theme={null}
async function sendStatusUpdate(entityId, status, details) {
  // Obtener detalles de la entidad
  const entity = await getEntity(entityId);

  // Enviar notificación por correo electrónico
  await sendEmail({
    to: entity.attributes.contactEmail,
    subject: `Actualización de Verificación KYB - ${status}`,
    template: 'kyb_status_update',
    data: {
      companyName: entity.name,
      status: status,
      details: details,
      nextSteps: getNextSteps(status),
      dashboardUrl: `https://app.gu1.ai/onboarding/${entityId}`
    }
  });

  // Enviar webhook a su sistema
  await sendWebhook({
    event: 'kyb_status_changed',
    entityId: entityId,
    status: status,
    timestamp: new Date().toISOString(),
    details: details
  });
}

// Ejemplos de actualización de estado
await sendStatusUpdate(entityId, 'documents_received', {
  message: 'Hemos recibido sus documentos y los estamos procesando.'
});

await sendStatusUpdate(entityId, 'approved', {
  message: '¡Su empresa ha sido verificada y aprobada!',
  approvalDate: new Date().toISOString()
});

await sendStatusUpdate(entityId, 'additional_info_required', {
  message: 'Necesitamos información adicional para completar su verificación.',
  requiredDocuments: ['financial_statements', 'ownership_structure']
});
```

## Implementación completa del flujo de trabajo

Aquí hay una función completa que orquesta todo el flujo de trabajo KYB:

```javascript theme={null}
async function executeKYBWorkflow(applicationData) {
  try {
    // Paso 1 y 2: Crear entidad
    console.log('Creando entidad empresarial...');
    const entity = await createBusinessEntity(applicationData);

    // Paso 3: Cargar documentos
    console.log('Cargando documentos de verificación...');
    await uploadBusinessDocuments(entity.id, applicationData.documents);

    // Paso 4: Solicitar análisis con IA
    console.log('Ejecutando análisis con IA...');
    const analysis = await requestAIAnalysis(entity.id);

    // Paso 5: Tomar decisión basada en riesgo
    console.log('Procesando decisión KYB...');
    const decision = await processKYBDecision(analysis);

    if (decision.status === 'approved') {
      // Paso 6: Verificar UBOs (para entidades aprobadas)
      console.log('Verificando beneficiarios finales...');
      await verifyBeneficialOwners(entity.id, applicationData.beneficialOwners);

      // Paso 7: Configurar monitoreo
      console.log('Configurando monitoreo continuo...');
      await setupOngoingMonitoring(entity.id);
    }

    // Paso 8: Enviar actualización de estado
    console.log('Enviando notificación de estado...');
    await sendStatusUpdate(entity.id, decision.status, analysis.findings);

    return {
      success: true,
      entityId: entity.id,
      status: decision.status,
      riskScore: analysis.riskScore,
      decision: decision
    };

  } catch (error) {
    console.error('Error en el flujo de trabajo KYB:', error);
    return {
      success: false,
      error: error.message
    };
  }
}
```

## Estimaciones de tiempo

| Nivel de Riesgo  | Procesamiento Automatizado | Con Revisión Manual | Proceso Tradicional |
| ---------------- | -------------------------- | ------------------- | ------------------- |
| **Riesgo Bajo**  | 2-5 minutos                | 30 minutos          | 2-3 días            |
| **Riesgo Medio** | 15-30 minutos              | 2-4 horas           | 3-5 días            |
| **Riesgo Alto**  | 30-60 minutos              | 1-2 días            | 5-10 días           |

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Requisitos de datos" icon="database" href="/use-cases/kyb/data-requirements">
    Vea los campos de datos detallados necesarios para KYB
  </Card>

  <Card title="Ejemplo completo" icon="code" href="/use-cases/kyb/example">
    Implementación de código completa y funcional
  </Card>

  <Card title="Referencia de API" icon="book" href="/api-reference/entities/create">
    Documentación de la API de creación de entidades
  </Card>

  <Card title="Webhooks" icon="bell" href="/es/webhooks/overview">
    Configure notificaciones en tiempo real
  </Card>
</CardGroup>