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

# Fluxo de Trabalho KYB

> Processo passo a passo para verificação automatizada de empresas — no fluxo KYB da gu1 para verificação empresarial, com exemplos para workflow.

## Fluxo de Trabalho Completo de Verificação KYB

O fluxo de trabalho KYB da gu1 automatiza todo o processo de verificação de empresas, desde a coleta inicial de dados até o monitoramento contínuo. Este guia percorre cada etapa com detalhes técnicos de implementação.

## Visão Geral do Fluxo de Trabalho

```mermaid theme={null}
graph TD
    A[Empresa Solicita] --> B[Coleta de Dados]
    B --> C[Criar Entidade]
    C --> D[Upload de Documentos]
    D --> E[Análise por IA]
    E --> F[Avaliação de Risco]
    F --> G{Pontuação de Risco}
    G -->|Baixo Risco| H[Auto-Aprovação]
    G -->|Médio Risco| I[Due Diligence Aprimorada]
    G -->|Alto Risco| J[Revisão Manual]
    H --> K[Monitoramento Contínuo]
    I --> K
    J --> K
    K --> L[Atualizações de Status]
```

## Etapa 1: Coleta de Dados Inicial

### O Que Coletar

Reúna informações básicas da empresa do seu formulário de solicitação:

* **Nome da Empresa**: Razão social e nome fantasia
* **Número de Registro**: Registro empresarial emitido pelo governo
* **ID Fiscal**: EIN (EUA), CNPJ (Brasil), RFC (México), etc.
* **Data de Constituição**: Quando a empresa foi constituída
* **País**: Jurisdição de constituição
* **Endereço Comercial**: Localização da sede registrada
* **Setor**: Tipo de atividade empresarial
* **Volume de Transações Esperado**: Estimativas mensais/anuais

### Exemplo de Formulário de Solicitação

```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"
};
```

## Etapa 2: Criar Entidade Empresarial

Use a API de Entidades para criar uma entidade de empresa na 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>

**Resposta:**

```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"
  }
}
```

## Etapa 3: Upload e Verificação de Documentos

Faça upload dos documentos empresariais necessários para verificação:

### Documentos Obrigatórios

1. **Contrato Social** - Documento de fundação
2. **Licença Comercial** - Permissão de operação emitida pelo governo
3. **Certificado Fiscal** - Comprovante de inscrição fiscal
4. **Comprovante de Endereço** - Conta de serviço público ou extrato bancário
5. **Declaração de Beneficiários Finais** - Informações sobre UBOs

### Fazer Upload de 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);
```

## Etapa 4: Análise por IA e Avaliação de Risco

Solicite análise alimentada por IA da entidade 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();
}
```

**Resposta da Análise por 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"
  ]
}
```

## Etapa 5: Decisão Baseada em Risco

Com base na pontuação de risco, direcione para o fluxo de trabalho apropriado:

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

  if (riskScore < 30) {
    // Baixo Risco - Auto-aprovação
    return await autoApprove(analysisResult.entityId);

  } else if (riskScore < 70) {
    // Médio Risco - Due Diligence Aprimorada
    return await enhancedDueDiligence(analysisResult.entityId);

  } else {
    // Alto Risco - Revisão Manual Necessária
    return await flagForManualReview(analysisResult.entityId, analysisResult.findings);
  }
}

async function autoApprove(entityId) {
  // Atualizar status da entidade para aprovado
  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 notificação de aprovação
  await sendApprovalEmail(entityId);

  // Ativar monitoramento
  await enableOngoingMonitoring(entityId);

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

async function enhancedDueDiligence(entityId) {
  // Solicitar informações adicionais
  await requestAdditionalDocs(entityId, [
    'financial_statements',
    'ownership_structure',
    'source_of_funds'
  ]);

  // Atualizar status
  await updateEntityStatus(entityId, 'enhanced_due_diligence');

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

async function flagForManualReview(entityId, findings) {
  // Criar tarefa de revisão
  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' };
}
```

## Etapa 6: Verificação de Beneficiários Finais

Identifique e verifique os Beneficiários Finais (UBOs):

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

  for (const owner of owners) {
    // Criar entidade pessoa 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();

    // Executar verificações KYC no UBO
    const kycResult = await runKYCCheck(ubo.entity.id);

    // Criar relacionamento entre empresa e 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;
}
```

## Etapa 7: Configurar Monitoramento Contínuo

Habilite o monitoramento contínuo para empresas aprovadas:

```javascript theme={null}
async function setupOngoingMonitoring(entityId) {
  // Configurar regras de monitoramento
  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 notificações por webhook
  await configureWebhook({
    entityId,
    events: [
      'sanctions_match',
      'adverse_media_found',
      'ownership_change',
      'transaction_anomaly'
    ],
    url: 'https://your-app.com/webhooks/kyb-alerts'
  });
}
```

## Etapa 8: Atualizações de Status e Notificações

Mantenha a empresa informada durante todo o processo:

```javascript theme={null}
async function sendStatusUpdate(entityId, status, details) {
  // Obter detalhes da entidade
  const entity = await getEntity(entityId);

  // Enviar notificação por e-mail
  await sendEmail({
    to: entity.attributes.contactEmail,
    subject: `Atualização de Verificação 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 para seu sistema
  await sendWebhook({
    event: 'kyb_status_changed',
    entityId: entityId,
    status: status,
    timestamp: new Date().toISOString(),
    details: details
  });
}

// Exemplos de atualização de status
await sendStatusUpdate(entityId, 'documents_received', {
  message: 'Recebemos seus documentos e estamos processando-os.'
});

await sendStatusUpdate(entityId, 'approved', {
  message: 'Sua empresa foi verificada e aprovada!',
  approvalDate: new Date().toISOString()
});

await sendStatusUpdate(entityId, 'additional_info_required', {
  message: 'Precisamos de informações adicionais para concluir sua verificação.',
  requiredDocuments: ['financial_statements', 'ownership_structure']
});
```

## Implementação Completa do Fluxo de Trabalho

Aqui está uma função completa que orquestra todo o fluxo de trabalho KYB:

```javascript theme={null}
async function executeKYBWorkflow(applicationData) {
  try {
    // Etapas 1 e 2: Criar entidade
    console.log('Criando entidade empresarial...');
    const entity = await createBusinessEntity(applicationData);

    // Etapa 3: Fazer upload de documentos
    console.log('Fazendo upload de documentos de verificação...');
    await uploadBusinessDocuments(entity.id, applicationData.documents);

    // Etapa 4: Solicitar análise por IA
    console.log('Executando análise por IA...');
    const analysis = await requestAIAnalysis(entity.id);

    // Etapa 5: Tomar decisão baseada em risco
    console.log('Processando decisão KYB...');
    const decision = await processKYBDecision(analysis);

    if (decision.status === 'approved') {
      // Etapa 6: Verificar UBOs (para entidades aprovadas)
      console.log('Verificando beneficiários finais...');
      await verifyBeneficialOwners(entity.id, applicationData.beneficialOwners);

      // Etapa 7: Configurar monitoramento
      console.log('Configurando monitoramento contínuo...');
      await setupOngoingMonitoring(entity.id);
    }

    // Etapa 8: Enviar atualização de status
    console.log('Enviando notificação de status...');
    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('Erro no fluxo de trabalho KYB:', error);
    return {
      success: false,
      error: error.message
    };
  }
}
```

## Estimativas de Prazo

| Nível de Risco  | Processamento Automatizado | Com Revisão Manual | Processo Tradicional |
| --------------- | -------------------------- | ------------------ | -------------------- |
| **Baixo Risco** | 2-5 minutos                | 30 minutos         | 2-3 dias             |
| **Médio Risco** | 15-30 minutos              | 2-4 horas          | 3-5 dias             |
| **Alto Risco**  | 30-60 minutos              | 1-2 dias           | 5-10 dias            |

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Requisitos de Dados" icon="database" href="/use-cases/kyb/data-requirements">
    Veja os campos de dados detalhados necessários para KYB
  </Card>

  <Card title="Exemplo Completo" icon="code" href="/use-cases/kyb/example">
    Implementação de código funcional completa
  </Card>

  <Card title="Referência da API" icon="book" href="/api-reference/entities/create">
    Documentação da API de criação de entidade
  </Card>

  <Card title="Webhooks" icon="bell" href="/pt/webhooks/overview">
    Configure notificações em tempo real
  </Card>
</CardGroup>