> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-llms-scoped-indexes.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Create A Group

> Create public, private, or password-protected groups and optionally add members during creation using the CometChat React Native SDK.

<Accordion title="AI Integration Quick Reference">
  | Field | Value |
  | - | - |
  | Package | `@cometchat/chat-sdk-react-native` |
  | Import | `import { CometChat } from "@cometchat/chat-sdk-react-native";` |
  | Key Methods | `createGroup()`, `createGroupWithMembers()` |
  | Key Classes | `CometChatException`, `GROUP_MEMBER_SCOPE`, `GROUP_TYPE`, `Group`, `GroupMember` |
  | Prerequisites | SDK initialized via [`CometChat.init()`](/sdk/react-native/setup-sdk) and a logged-in user via [`CometChat.login()`](/sdk/react-native/authentication-overview) |
  | Primary output | `createGroup()` → `Promise<CometChat.Group>`; `createGroupWithMembers()` → `Promise<Object>` (a per-member success/failure map) |
  | Constraints | GUIDs are immutable once created. A `password` group requires a password at creation; `public` and `private` must not carry one. `GROUP_TYPE.PROTECTED` and `GROUP_TYPE.PASSWORD` are **aliases** — both resolve to `"password"`. |
  | Related | [Join a Group](/sdk/react-native/join-group) · [Update a Group](/sdk/react-native/update-group) · [Add Members](/sdk/react-native/group-add-members) |
  | Full reference | [`Group`](/sdk/reference/entities#group) · [`GroupMember`](/sdk/reference/entities#groupmember) · [`CometChatException`](/sdk/reference/auxiliary#cometchatexception) |

  ```javascript theme={null}
  // Create a group
  let group = new CometChat.Group("GUID", "Group Name", CometChat.GROUP_TYPE.PUBLIC, "");
  let createdGroup = await CometChat.createGroup(group);

  // Create group with members
  let members = [new CometChat.GroupMember("UID", CometChat.GROUP_MEMBER_SCOPE.PARTICIPANT)];
  let result = await CometChat.createGroupWithMembers(group, members, []);
  ```

  **Group types:** `PUBLIC` | `PASSWORD` | `PRIVATE`
  **Member scopes:** `ADMIN` | `MODERATOR` | `PARTICIPANT`
</Accordion>

Create groups for multi-user conversations. You can create a group on its own with `createGroup()`, or create one and add members in a single call with `createGroupWithMembers()`. See the [Group Class](#group-class) reference at the bottom for all available fields.

## Create a Group

Use `createGroup()` to create a new group. Pass a [`Group`](/sdk/reference/entities#group) object with the group details.

| Group Type | Constant | Description |
| - | - | - |
| Public | `CometChat.GROUP_TYPE.PUBLIC` | Any user can join |
| Password | `CometChat.GROUP_TYPE.PASSWORD` | Users must provide the correct password |
| Private | `CometChat.GROUP_TYPE.PRIVATE` | Users must be added by an admin/moderator |

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    const GUID: string = "GUID";
    const groupName: string = "Hello Group!";
    const groupType: string = CometChat.GROUP_TYPE.PUBLIC;
    const password: string = "";

    const group: CometChat.Group = new CometChat.Group(GUID, groupName, groupType, password);

    CometChat.createGroup(group).then(
      (group: CometChat.Group) => {
          console.log("Group created successfully:", group);
      }, (error: CometChat.CometChatException) => {
          console.log("Group creation failed with exception:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    const GUID = "GUID";
    const groupName = "Hello Group!";
    const groupType = CometChat.GROUP_TYPE.PUBLIC;
    const password = "";

    const group = new CometChat.Group(GUID, groupName, groupType, password);

    CometChat.createGroup(group).then(
      group => {
      	console.log("Group created successfully:", group);
      }, error => {
      	console.log("Group creation failed with exception:", error);
      }
    );
    ```

    Alternatively, you can use the `async/await` syntax:

    ```javascript theme={null}
    const GUID = "GUID";
    const groupName = "Hello Group!";
    const groupType = CometChat.GROUP_TYPE.PUBLIC;
    const password = "";

    const group = new CometChat.Group(GUID, groupName, groupType, password);

    try {
      const createdGroup = await CometChat.createGroup(group);
      console.log("Group created successfully:", createdGroup);
    } catch (error) {
      console.log("Group creation failed with exception:", error);
    }
    ```
  </Tab>
</Tabs>

| Parameter | Description |
| - | - |
| `group` | An instance of [`Group`](/sdk/reference/entities#group) class |

On success, returns a [`Group`](/sdk/reference/entities#group) object with the created group's details.

<Warning>
  GUID can be alphanumeric with underscore and hyphen. Spaces, punctuation and other special characters are not allowed.
</Warning>

## Add Members While Creating a Group

Use `createGroupWithMembers()` to create a group and add members in one operation.

Parameters:

* `group` — The [`Group`](/sdk/reference/entities#group) object
* `members` — Array of [`GroupMember`](/sdk/reference/entities#groupmember) objects to add
* `bannedMembers` — Array of UIDs to ban (can be empty)

Create a [`GroupMember`](/sdk/reference/entities#groupmember) with: `new CometChat.GroupMember(UID, scope)`

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let GUID: string = "cometchat-guid-11";
    let UID: string = "cometchat-uid-1";
    let groupName: string = "Hello Group!";
    let groupType: string = CometChat.GROUP_TYPE.PUBLIC;

    let group: CometChat.Group = new CometChat.Group(GUID, groupName, groupType);
    let members: Array<CometChat.GroupMember> = [
    new CometChat.GroupMember(UID, CometChat.GROUP_MEMBER_SCOPE.PARTICIPANT)
    ];
    let banMembers: Array<String> = ["cometchat-uid-2"];

    CometChat.createGroupWithMembers(group, members, banMembers).then(
      (response: Object) => {
      	console.log("Group created successfully", response);
      }, (error: CometChat.CometChatException) => {
      	console.log("Some error occured while creating group", error)
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let GUID = "cometchat-guid-11";
    let UID = "cometchat-uid-1";
    let groupName = "Hello Group!";
    let groupType = CometChat.GROUP_TYPE.PUBLIC;

    let group = new CometChat.Group(GUID, groupName, groupType);
    let members = [
    new CometChat.GroupMember(UID, CometChat.GROUP_MEMBER_SCOPE.PARTICIPANT)
    ];
    let banMembers = ["cometchat-uid-2"];

    CometChat.createGroupWithMembers(group, members, banMembers).then(
      response => {
      	console.log("Group created successfully", response);
      }, error => {
      	console.log("Some error occured while creating group", error)
      }
    );
    ```

    Alternatively, you can use the `async/await` syntax:

    ```javascript theme={null}
    let GUID = "cometchat-guid-11";
    let UID = "cometchat-uid-1";
    let groupName = "Hello Group!";
    let groupType = CometChat.GROUP_TYPE.PUBLIC;

    let group = new CometChat.Group(GUID, groupName, groupType);
    let members = [
      new CometChat.GroupMember(UID, CometChat.GROUP_MEMBER_SCOPE.PARTICIPANT)
    ];
    let banMembers = ["cometchat-uid-2"];

    try {
      const response = await CometChat.createGroupWithMembers(group, members, banMembers);
      console.log("Group created successfully", response);
    } catch (error) {
      console.log("Some error occured while creating group", error);
    }
    ```
  </Tab>
</Tabs>

Returns an object with two keys:

* `group` — The created [`Group`](/sdk/reference/entities#group) object
* `members` — Object with UIDs as keys and `"success"` or error message as values

## Group Class

The [`Group`](/sdk/reference/entities#group) object has the following fields. Fields marked "Yes" in the Editable column can be modified after creation using `updateGroup()`.

| Field | Editable | Information |
| - | - | - |
| guid | Needs to be specified at group creation. Cannot be edited later | A unique identifier for a group |
| name | Yes | Name of the group |
| type | No | Type of the group: Can be 1. Public 2. Password 3. Private |
| password | No | Password for the group in case the group is of type password. |
| icon | Yes | An URL to group icon |
| description | Yes | Description about the group |
| owner | Yes | UID of the owner of the group. |
| metadata | Yes | Additional data for the group as JSON |
| createdAt | No | The unix timestamp of the time the group was created |
| updatedAt | No | The unix timestamp of the time the group was last updated |
| hasJoined | No | A boolean to determine if the logged in user is a member of the group. |
| joinedAt | No | The unix timestamp of the time the logged in user joined the group. |
| scope | Yes | Scope of the logged in user. Can be: 1. Admin 2. Moderator 3. Participant |
| membersCount | No | The number of members in the groups |
| tags | Yes | A list of tags to identify specific groups. |

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Join a Group" icon="right-to-bracket" href="/sdk/react-native/join-group">
    Join public, private, or password-protected groups
  </Card>

  <Card title="Add Members" icon="user-plus" href="/sdk/react-native/group-add-members">
    Add users to an existing group
  </Card>

  <Card title="Retrieve Groups" icon="list" href="/sdk/react-native/retrieve-groups">
    Fetch and filter group lists
  </Card>

  <Card title="Groups Overview" icon="users" href="/sdk/react-native/groups-overview">
    Overview of all group management features
  </Card>
</CardGroup>


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