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

# Kick Member From A Group

> Learn how to kick, ban, and unban group members, fetch banned member lists, and receive real-time events using the CometChat iOS SDK.

<Accordion title="AI Integration Quick Reference">
  ```swift theme={null}
  // Kick a member
  CometChat.kickGroupMember(UID: "UID", GUID: "GUID", onSuccess: { response in }, onError: { error in })

  // Ban a member
  CometChat.banGroupMember(UID: "UID", GUID: "GUID", onSuccess: { response in }, onError: { error in })

  // Unban a member
  CometChat.unbanGroupMember(UID: "UID", GUID: "GUID", onSuccess: { response in }, onError: { error in })

  // Fetch banned members
  let request = BannedGroupMembersRequest.BannedGroupMembersRequestBuilder(guid: "GUID")
      .set(limit: 30).build()
  request.fetchNext(onSuccess: { members in }, onError: { error in })
  ```
</Accordion>

Remove members from a group by kicking or banning them. Kicked users can rejoin; banned users cannot until they're unbanned. Only admins and moderators can perform these actions.

## Kick a Group Member

Admins or Moderators can remove a member using `kickGroupMember()`. The kicked user can rejoin the group later.

| Parameter | Description                                           |
| --------- | ----------------------------------------------------- |
| `UID`     | The UID of the user to be kicked                      |
| `GUID`    | The GUID of the group from which user is to be kicked |

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let uid = "cometchat-uid-2"
    let guid = "cometchat-guid-1"

    CometChat.kickGroupMember(UID: uid, GUID: guid, onSuccess: { (response) in
        print("\(uid) is kicked from the group \(guid) successfully.")
    }, onError: { (error) in
        print("Error: \(error?.errorDescription)")
    })
    ```
  </Tab>

  <Tab title="Objective C">
    ```objc theme={null}
    NSString *UID = @"cometchat-uid-2";
    NSString *GUID = @"cometchat-guid-1";

    [CometChat kickGroupMemberWithUID:UID GUID:GUID onSuccess:^(NSString * response) {
        NSLog(@"%@ kicked from the group %@ successfully", UID, GUID);
    } onError:^(CometChatException * error) {
        NSLog(@"Error: %@", [error errorDescription]);
    }];
    ```
  </Tab>
</Tabs>

The kicked user will be no longer part of the group and can not perform any actions in the group, but the kicked user can rejoin the group.

## Ban a Group Member

Admins or Moderators can ban a member using `banGroupMember()`. Unlike kicked users, banned users cannot rejoin until unbanned.

| Parameter | Description                                           |
| --------- | ----------------------------------------------------- |
| `UID`     | The UID of the user to be banned                      |
| `GUID`    | The GUID of the group from which user is to be banned |

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let uid = "cometchat-uid-2"
    let guid = "cometchat-guid-1"

    CometChat.banGroupMember(UID: uid, GUID: guid, onSuccess: { (response) in
        print("\(uid) is banned from the group \(guid) successfully.")
    }, onError: { (error) in
        print("Error: \(error?.errorDescription)")
    })
    ```
  </Tab>

  <Tab title="Objective C">
    ```objc theme={null}
    NSString *UID = @"cometchat-uid-2";
    NSString *GUID = @"cometchat-guid-1";

    [CometChat banGroupMemberWithUID:UID GUID:GUID onSuccess:^(NSString * response) {
        NSLog(@"%@ banned from the group %@ successfully", UID, GUID);
    } onError:^(CometChatException * error) {
        NSLog(@"Error: %@", [error errorDescription]);
    }];
    ```
  </Tab>
</Tabs>

The banned user will be no longer part of the group and can not perform any actions in the group. A banned user cannot rejoin the same group without being unbanned.

## Unban a Group Member

Admins or Moderators can unban a previously banned member using `unbanGroupMember()`.

| Parameter | Description                                             |
| --------- | ------------------------------------------------------- |
| `UID`     | The UID of the user to be unbanned                      |
| `GUID`    | The GUID of the group from which user is to be unbanned |

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let uid = "cometchat-uid-2"
    let guid = "cometchat-guid-1"

    CometChat.unbanGroupMember(UID: uid, GUID: guid, onSuccess: { (response) in
        print("\(uid) is unbanned from the group \(guid) successfully.")
    }, onError: { (error) in
        print("Error: \(error?.errorDescription)")
    })
    ```
  </Tab>

  <Tab title="Objective C">
    ```objc theme={null}
    NSString *UID = @"cometchat-uid-2";
    NSString *GUID = @"cometchat-guid-1";

    [CometChat unbanGroupMemberWithUID:UID GUID:GUID onSuccess:^(NSString * response) {
        NSLog(@"%@ unbanned from the group %@ successfully", UID, GUID);
    } onError:^(CometChatException * error) {
        NSLog(@"Error: %@", [error errorDescription]);
    }];
    ```
  </Tab>
</Tabs>

Once unbanned, the user can rejoin the group.

## Get List of Banned Members for a Group

Use `BannedGroupMembersRequestBuilder` to fetch banned members of a group. The GUID must be specified in the constructor.

### Set Limit

Sets the number of banned members to fetch per request.

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let bannedGroupMembersRequest = BannedGroupMembersRequest.BannedGroupMembersRequestBuilder(guid: "cometchat-guid-1")
        .set(limit: 30)
        .build()
    ```
  </Tab>
</Tabs>

### Set Search Keyword

Filters banned members by a search string.

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let bannedGroupMembersRequest = BannedGroupMembersRequest.BannedGroupMembersRequestBuilder(guid: "cometchat-guid-1")
        .set(limit: 30)
        .set(searchKeyword: "abc")
        .build()
    ```
  </Tab>
</Tabs>

Once configured, call `build()` to create the request, then `fetchNext()` to retrieve banned members.

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    let limit = 30
    let guid = "cometchat-guid-1"

    let bannedGroupMembersRequest = BannedGroupMembersRequest.BannedGroupMembersRequestBuilder(guid: guid)
        .set(limit: limit)
        .build()

    bannedGroupMembersRequest.fetchNext(onSuccess: { (groupMembers) in
        for bannedMember in groupMembers {
            print("Banned member: \(bannedMember.stringValue())")
        }
    }, onError: { (error) in
        print("Error: \(error?.errorDescription)")
    })
    ```
  </Tab>

  <Tab title="Objective C">
    ```objc theme={null}
    NSString *GUID = @"cometchat-guid-1";
    NSInteger limit = 30;

    BannedGroupMembersRequest *bannedGroupMemberRequest = [[[[BannedGroupMembersRequestBuilder alloc]initWithGuid:GUID] setLimitWithLimit:limit] build];

    [bannedGroupMemberRequest fetchNextOnSuccess:^(NSArray<GroupMember *> * bannedMembers) {
        for (GroupMember *member in bannedMembers) {
            NSLog(@"Banned member: %@", [member stringValue]);
        }
    } onError:^(CometChatException * error) {
        NSLog(@"Error: %@", [error errorDescription]);
    }];
    ```
  </Tab>
</Tabs>

## Real-Time Kick/Ban/Unban Events

Implement these `CometChatGroupDelegate` methods to receive real-time notifications:

| Method                    | Triggered When       |
| ------------------------- | -------------------- |
| `onGroupMemberKicked()`   | A member is kicked   |
| `onGroupMemberBanned()`   | A member is banned   |
| `onGroupMemberUnbanned()` | A member is unbanned |

<Tabs>
  <Tab title="Swift">
    ```swift theme={null}
    class ViewController: UIViewController, CometChatGroupDelegate {
        
        override func viewDidLoad() {
            super.viewDidLoad()
            CometChat.groupdelegate = self
        }
        
        func onGroupMemberKicked(action: ActionMessage, kickedUser: User, kickedBy: User, kickedFrom: Group) {
            print("\(kickedUser.name ?? "") kicked from \(kickedFrom.name ?? "") by \(kickedBy.name ?? "")")
        }
        
        func onGroupMemberBanned(action: ActionMessage, bannedUser: User, bannedBy: User, bannedFrom: Group) {
            print("\(bannedUser.name ?? "") banned from \(bannedFrom.name ?? "") by \(bannedBy.name ?? "")")
        }
        
        func onGroupMemberUnbanned(action: ActionMessage, unbannedUser: User, unbannedBy: User, unbannedFrom: Group) {
            print("\(unbannedUser.name ?? "") unbanned from \(unbannedFrom.name ?? "") by \(unbannedBy.name ?? "")")
        }
    }
    ```
  </Tab>

  <Tab title="Objective C">
    ```objc theme={null}
    @interface ViewController ()<CometChatGroupDelegate>
    @end

    @implementation ViewController

    - (void)viewDidLoad {
        [super viewDidLoad];
        [CometChat setGroupdelegate:self];
    }

    - (void)onGroupMemberKickedWithAction:(Action *)action kickedUser:(User *)kickedUser kickedBy:(User *)kickedBy kickedFrom:(Group *)kickedFrom {
        // User was kicked
    }

    - (void)onGroupMemberBannedWithAction:(Action *)action bannedUser:(User *)bannedUser bannedBy:(User *)bannedBy bannedFrom:(Group *)bannedFrom {
        // User was banned
    }

    - (void)onGroupMemberUnbannedWithAction:(Action *)action unbannedUser:(User *)unbannedUser unbannedBy:(User *)unbannedBy unbannedFrom:(Group *)unbannedFrom {
        // User was unbanned
    }

    @end
    ```
  </Tab>
</Tabs>

<Warning>
  Set delegate in `viewDidLoad()`: `CometChat.groupdelegate = self`. Remove delegate when view is dismissed to avoid memory leaks.
</Warning>

## Missed Group Member Kicked/Banned Events

When fetching previous messages, kick/ban/unban actions appear as [`Action`](/sdk/reference/messages#action) messages (a subclass of [`BaseMessage`](/sdk/reference/messages#basemessage)).

**Kicked event:**

| Field       | Value/Type                               | Description                    |
| ----------- | ---------------------------------------- | ------------------------------ |
| `action`    | `"kicked"`                               | The action type                |
| `actionBy`  | [`User`](/sdk/reference/entities#user)   | The user who kicked the member |
| `actionOn`  | [`User`](/sdk/reference/entities#user)   | The member who was kicked      |
| `actionFor` | [`Group`](/sdk/reference/entities#group) | The group                      |

**Banned event:**

| Field       | Value/Type                               | Description                    |
| ----------- | ---------------------------------------- | ------------------------------ |
| `action`    | `"banned"`                               | The action type                |
| `actionBy`  | [`User`](/sdk/reference/entities#user)   | The user who banned the member |
| `actionOn`  | [`User`](/sdk/reference/entities#user)   | The member who was banned      |
| `actionFor` | [`Group`](/sdk/reference/entities#group) | The group                      |

**Unbanned event:**

| Field       | Value/Type                               | Description                      |
| ----------- | ---------------------------------------- | -------------------------------- |
| `action`    | `"unbanned"`                             | The action type                  |
| `actionBy`  | [`User`](/sdk/reference/entities#user)   | The user who unbanned the member |
| `actionOn`  | [`User`](/sdk/reference/entities#user)   | The member who was unbanned      |
| `actionFor` | [`Group`](/sdk/reference/entities#group) | The group                        |

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Add Members" icon="user-plus" href="/sdk/ios/group-add-members">
    Add new members to a group
  </Card>

  <Card title="Change Member Scope" icon="user-shield" href="/sdk/ios/group-change-member-scope">
    Promote or demote group members
  </Card>

  <Card title="Retrieve Group Members" icon="users" href="/sdk/ios/retrieve-group-members">
    Fetch the list of members in a group
  </Card>

  <Card title="Leave a Group" icon="right-from-bracket" href="/sdk/ios/leave-group">
    Allow members to leave a group
  </Card>
</CardGroup>