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

# Criar Comunidade

> Criar uma nova comunidade no WhatsApp

Cria uma nova comunidade do WhatsApp, que permite agrupar múltiplos grupos relacionados sob uma única administração centralizada.

## Estrutura de Comunidades

> **O que são Comunidades**
>
> Entenda o conceito de Comunidades no WhatsApp.
>
> **Definição:**
>
> * Estrutura hierárquica para organizar grupos
> * Permite administração centralizada de múltiplos grupos
> * Cada comunidade tem um grupo de anúncios principal
> * Grupos vinculados compartilham contexto comum
> * Facilita gestão em larga escala
>
> **Benefícios:**
>
> * Organização de grupos relacionados
> * Comunicados centralizados via grupo de anúncios
> * Gerenciamento simplificado de múltiplos grupos
> * Identidade visual unificada
> * Controle administrativo centralizado

> **Criação e Configuração**
>
> Como funciona a criação de uma comunidade.
>
> **Processo:**
>
> * Comunidade criada com nome escolhido
> * Criador torna-se administrador automaticamente
> * Grupo de anúncios criado automaticamente
> * Grupos podem ser vinculados posteriormente
> * Use `/community/updategroups` para adicionar grupos
>
> **Grupo de Anúncios:**
>
> * Criado automaticamente com a comunidade
> * Canal de comunicação oficial
> * Todos os membros dos grupos vinculados têm acesso
> * Ideal para avisos e informações importantes

> **Limitações e Requisitos**
>
> Restrições aplicadas às comunidades.
>
> **Limites do WhatsApp:**
>
> * Número máximo de comunidades por conta
> * Limite de grupos por comunidade
> * Nome da comunidade tem limite de caracteres
> * Apenas o criador tem certos privilégios
>
> **Requisitos:**
>
> * Conexão válida e ativa
> * Permissões para criar comunidades
> * Nome não pode estar vazio
> * Conta em bom estado no WhatsApp

> **Casos de Uso**
>
> Situações ideais para usar comunidades.
>
> **Aplicações:**
>
> * Organizações com múltiplos departamentos
> * Escolas com turmas diferentes
> * Condomínios com blocos separados
> * Empresas com filiais regionais
> * Eventos com múltiplas áreas
> * Comunidades locais e bairros
> * Grupos de interesse com subcategorias
> * Organizações sem fins lucrativos

### Authorization

**api\_key** `string` *required*

Chave de autenticação da sua conexão, utilizada no header Authorization como
**Bearer** Token. \\

Você encontra sua API Key no botão **API** da sua conexão no painel ZapClass. \\

A chave sempre começa com o prefixo `zc_`. \\

Exemplo: `zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP`

### Body Parameters

**name** `string` *required*

Nome da comunidade. \\

Identifica a comunidade para todos os membros. \\

Exemplo: `"Comunidade do Bairro"`

> [!NOTE]
>
> **Próximos passos:** Após criar a comunidade, use o endpoint
> `/community/updategroups` para vincular grupos existentes ou criar novos
> grupos dentro da comunidade.

```bash cURL - Criar comunidade theme={null}
curl -X POST https://zapclass.com.br/api/communities/create \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP" \
  -d '{
    "name": "Comunidade do Bairro"
  }'
```

```bash cURL - Criar e capturar ID theme={null}
RESPONSE=$(curl -s -X POST https://zapclass.com.br/api/communities/create \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP" \
  -d '{
    "name": "Minha Comunidade"
  }')

COMMUNITY_ID=$(echo $RESPONSE | jq -r '.community.id')
echo "ID da comunidade criada: $COMMUNITY_ID"
```

```javascript JavaScript - Criar comunidade theme={null}
const response = await fetch("https://zapclass.com.br/api/communities/create", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
  },
  body: JSON.stringify({
    name: "Comunidade do Bairro",
  }),
});

const data = await response.json();
if (data.success) {
  console.log("Comunidade criada:", data.community.name);
  console.log("ID:", data.community.id);
  console.log("Grupo de anúncios:", data.community.announcementGroup);
}
```

```javascript JavaScript - Criar com validação theme={null}
async function createCommunity(name) {
  // Validações
  if (!name || name.trim().length === 0) {
    throw new Error("Nome da comunidade é obrigatório");
  }

  if (name.length > 50) {
    throw new Error("Nome muito longo (máximo 50 caracteres)");
  }

  console.log(`Criando comunidade: "${name}"...`);

  const response = await fetch("https://zapclass.com.br/api/communities/create", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
    },
    body: JSON.stringify({ name }),
  });

  const data = await response.json();

  if (!data.success) {
    throw new Error(data.message);
  }

  console.log("✓ Comunidade criada com sucesso");
  console.log(`  ID: ${data.community.id}`);
  console.log(`  Nome: ${data.community.name}`);
  console.log(
    `  Grupo de anúncios: ${data.community.announcementGroup || "Criado"}`
  );

  return data.community;
}

// Uso
try {
  const community = await createCommunity("Condomínio Parque das Flores");
  console.log("\nComunidade:", community);
} catch (error) {
  console.error("Erro:", error.message);
}
```

```javascript JavaScript - Criar e configurar theme={null}
async function createAndSetupCommunity(name, description) {
  // Cria a comunidade
  const createResponse = await fetch(
    "https://zapclass.com.br/api/communities/create",
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
      },
      body: JSON.stringify({ name }),
    }
  );

  const community = await createResponse.json();

  if (!community.success) {
    throw new Error(community.message);
  }

  console.log("✓ Comunidade criada");

  // Configura descrição do grupo de anúncios (se tiver o JID)
  if (community.community.announcementGroup) {
    try {
      await fetch("https://zapclass.com.br/api/groups/updateDescription", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
        },
        body: JSON.stringify({
          groupjid: community.community.announcementGroup,
          description: description,
        }),
      });

      console.log("✓ Descrição do grupo de anúncios configurada");
    } catch (error) {
      console.warn("Falha ao configurar descrição:", error.message);
    }
  }

  return community.community;
}

// Uso
const community = await createAndSetupCommunity(
  "Escola Municipal",
  "📚 Comunidade da Escola Municipal\n\nCanal oficial de comunicação com pais e alunos."
);
```

```javascript JavaScript - Criar múltiplas comunidades theme={null}
async function createMultipleCommunities(names) {
  const results = [];

  for (const name of names) {
    try {
      const response = await fetch(
        "https://zapclass.com.br/api/communities/create",
        {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
          },
          body: JSON.stringify({ name }),
        }
      );

      const data = await response.json();

      results.push({
        name,
        success: data.success,
        community: data.success ? data.community : null,
        error: data.success ? null : data.message,
      });

      // Aguarda 2 segundos entre criações
      await new Promise((resolve) => setTimeout(resolve, 2000));
    } catch (error) {
      results.push({
        name,
        success: false,
        community: null,
        error: error.message,
      });
    }
  }

  return results;
}

// Uso - criar comunidades para cada filial
const branches = [
  "Empresa - Filial São Paulo",
  "Empresa - Filial Rio de Janeiro",
  "Empresa - Filial Belo Horizonte",
];

const results = await createMultipleCommunities(branches);

console.log("=== RESULTADOS ===");
results.forEach((result) => {
  if (result.success) {
    console.log(`✓ ${result.name}`);
    console.log(`  ID: ${result.community.id}`);
  } else {
    console.log(`✗ ${result.name}`);
    console.log(`  Erro: ${result.error}`);
  }
});
```

```javascript JavaScript - Criar com estrutura completa theme={null}
async function createCommunityWithStructure(config) {
  const { name, description, initialGroups } = config;

  console.log(`Criando comunidade: ${name}...`);

  // 1. Cria a comunidade
  const createResponse = await fetch(
    "https://zapclass.com.br/api/communities/create",
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
      },
      body: JSON.stringify({ name }),
    }
  );

  const communityData = await createResponse.json();

  if (!communityData.success) {
    throw new Error(communityData.message);
  }

  const community = communityData.community;
  console.log("✓ Comunidade criada:", community.id);

  // 2. Cria grupos iniciais (se fornecidos)
  const createdGroups = [];

  if (initialGroups && initialGroups.length > 0) {
    console.log(`\nCriando ${initialGroups.length} grupos...`);

    for (const groupConfig of initialGroups) {
      try {
        const groupResponse = await fetch(
          "https://zapclass.com.br/api/groups/create",
          {
            method: "POST",
            headers: {
              "Content-Type": "application/json",
              Authorization:
                "Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP",
            },
            body: JSON.stringify({
              name: groupConfig.name,
              participants: groupConfig.participants || [],
            }),
          }
        );

        const groupData = await groupResponse.json();

        if (groupData.success) {
          createdGroups.push(groupData.group);
          console.log(`  ✓ Grupo criado: ${groupConfig.name}`);
        }

        await new Promise((resolve) => setTimeout(resolve, 1000));
      } catch (error) {
        console.warn(`  ✗ Falha ao criar grupo: ${groupConfig.name}`);
      }
    }
  }

  console.log("\n✓ Estrutura da comunidade criada com sucesso!");

  return {
    community,
    groups: createdGroups,
  };
}

// Uso
const structure = await createCommunityWithStructure({
  name: "Condomínio Parque das Flores",
  description: "Comunidade oficial do condomínio",
  initialGroups: [
    { name: "Bloco A", participants: ["5511999999999"] },
    { name: "Bloco B", participants: ["5511888888888"] },
    { name: "Área de Lazer", participants: [] },
  ],
});

console.log("\nComunidade ID:", structure.community.id);
console.log("Grupos criados:", structure.groups.length);
```

```php PHP - Criar comunidade theme={null}
<?php
$ch = curl_init('https://zapclass.com.br/api/communities/create');

$payload = [
    "name" => "Comunidade do Bairro"
];

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$data = json_decode($response, true);

if ($data['success']) {
    echo "Comunidade criada: {$data['community']['name']}\n";
    echo "ID: {$data['community']['id']}\n";
} else {
    echo "Erro: " . $data['message'];
}

curl_close($ch);
?>
```

```php PHP - Criar com validação theme={null}
<?php
function createCommunity($name) {
    // Validações
    if (empty(trim($name))) {
        throw new Exception("Nome da comunidade é obrigatório");
    }

    if (strlen($name) > 50) {
        throw new Exception("Nome muito longo (máximo 50 caracteres)");
    }

    echo "Criando comunidade: \"{$name}\"...\n";

    $ch = curl_init('https://zapclass.com.br/api/communities/create');

    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
        'name' => $name
    ]));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP'
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    $data = json_decode($response, true);
    curl_close($ch);

    if (!$data['success']) {
        throw new Exception($data['message']);
    }

    echo "✓ Comunidade criada com sucesso\n";
    echo "  ID: {$data['community']['id']}\n";
    echo "  Nome: {$data['community']['name']}\n";

    return $data['community'];
}

// Uso
try {
    $community = createCommunity("Condomínio Parque das Flores");
    print_r($community);
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage();
}
?>
```

```php PHP - Criar múltiplas comunidades theme={null}
<?php
function createMultipleCommunities($names) {
    $results = [];

    foreach ($names as $name) {
        $ch = curl_init('https://zapclass.com.br/api/communities/create');

        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
            'name' => $name
        ]));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json',
            'Authorization: Bearer zc_6FrX2qjM4bHT9pR6cC0sD8wLkG3nE2tZfV5uN1aP'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $data = json_decode($response, true);
        curl_close($ch);

        $results[] = [
            'name' => $name,
            'success' => $data['success'],
            'community' => $data['success'] ? $data['community'] : null,
            'error' => $data['success'] ? null : $data['message']
        ];

        // Aguarda 2 segundos entre criações
        sleep(2);
    }

    return $results;
}

// Uso
$branches = [
    "Empresa - Filial São Paulo",
    "Empresa - Filial Rio de Janeiro",
    "Empresa - Filial Belo Horizonte"
];

$results = createMultipleCommunities($branches);

echo "=== RESULTADOS ===\n\n";
foreach ($results as $result) {
    if ($result['success']) {
        echo "✓ {$result['name']}\n";
        echo "  ID: {$result['community']['id']}\n\n";
    } else {
        echo "✗ {$result['name']}\n";
        echo "  Erro: {$result['error']}\n\n";
    }
}
?>
```

```php PHP - Classe gerenciadora completa theme={null}
<?php
class CommunityManager {
    private $token;
    private $baseUrl = 'https://zapclass.com.br/api';

    public function __construct($token) {
        $this->token = $token;
    }

    private function makeRequest($endpoint, $payload) {
        $ch = curl_init($this->baseUrl . $endpoint);

        curl_setopt($ch, CURLOPT_POST, 1);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json',
            "Token: {$this->token}"
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        curl_close($ch);

        return json_decode($response, true);
    }

    public function create($name) {
        if (empty(trim($name))) {
            throw new Exception("Nome é obrigatório");
        }

        if (strlen($name) > 50) {
            throw new Exception("Nome muito longo");
        }

        $data = $this->makeRequest('/community/create', [
            'name' => $name
        ]);

        if (!$data['success']) {
            throw new Exception($data['message']);
        }

        return $data['community'];
    }

    public function createWithGroups($name, $groupNames) {
        // Cria a comunidade
        $community = $this->create($name);

        echo "✓ Comunidade criada: {$community['id']}\n";

        // Cria grupos
        $groups = [];

        foreach ($groupNames as $groupName) {
            try {
                $groupData = $this->makeRequest('/groups/create', [
                    'name' => $groupName,
                    'participants' => []
                ]);

                if ($groupData['success']) {
                    $groups[] = $groupData['group'];
                    echo "  ✓ Grupo criado: {$groupName}\n";
                }

                sleep(1);
            } catch (Exception $e) {
                echo "  ✗ Falha ao criar grupo: {$groupName}\n";
            }
        }

        return [
            'community' => $community,
            'groups' => $groups
        ];
    }

    public function createMultiple($names, $delay = 2) {
        $results = [];

        foreach ($names as $name) {
            try {
                $community = $this->create($name);
                $results[$name] = [
                    'success' => true,
                    'community' => $community
                ];
            } catch (Exception $e) {
                $results[$name] = [
                    'success' => false,
                    'error' => $e->getMessage()
                ];
            }

            if ($delay > 0) {
                sleep($delay);
            }
        }

        return $results;
    }
}

// Uso
$manager = new CommunityManager('zt_BppKZWtzvj1X2SbJAuOSkA0Z63uDBQ0wkb28NJaloKeOUnHk');

try {
    // Criar comunidade simples
    $community = $manager->create("Minha Comunidade");
    echo "Comunidade criada: {$community['id']}\n\n";

    // Criar com grupos
    $structure = $manager->createWithGroups(
        "Condomínio ABC",
        ["Bloco A", "Bloco B", "Área Comum"]
    );

    echo "\nComunidade: {$structure['community']['id']}\n";
    echo "Grupos criados: " . count($structure['groups']) . "\n";
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage();
}
?>
```

```json 200 - Comunidade criada theme={null}
{
  "success": true,
  "message": "Community created successfully",
  "community": {
    "id": "120363308883996631@g.us",
    "name": "Comunidade do Bairro",
    "announcementGroup": "120363308883996632@g.us",
    "createdAt": 1672531200000
  }
}
```

```json 400 - Nome vazio theme={null}
{
  "success": false,
  "message": "O nome da comunidade não pode estar vazio"
}
```

```json 400 - Nome muito longo theme={null}
{
  "success": false,
  "message": "O nome da comunidade excede o limite de caracteres permitido"
}
```

```json 401 - Token inválido theme={null}
{
  "success": false,
  "message": "Token de autenticação inválido ou expirado"
}
```

```json 403 - Sem permissão theme={null}
{
  "success": false,
  "message": "Sem permissão para criar comunidades"
}
```

```json 429 - Limite atingido theme={null}
{
  "success": false,
  "message": "Limite de criação de comunidades atingido. Tente novamente mais tarde"
}
```

```json 500 - Erro no servidor theme={null}
{
  "success": false,
  "message": "Erro ao criar comunidade. Tente novamente"
}
```


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