Integrate groups into your game

Last updated on May 13, 2024

Overview

AccelByte Gaming Services (AGS) Group provides game developers a way to boost interaction between players that can increase overall player retention by allowing players to form a group, gather, interact, and collaborate to achieve common goals. In this guide, you will learn how to integrate groups into your game using the AGS Group service with the Client SDK.

Goals

By following this guide, you will:

Learn how to integrate groups into your game with Client SDKs.
Gain an understanding of how to allow players to manage groups.
Gain an understanding of how to retrieve group information.
Gain an understanding of how to allow players to interact with groups.
Gain an understanding of how to send group-related notifications to the player.

Prerequisites

You will need access to:

The AGS Admin Portal.
The AccelByte Unreal or Unity SDK, including the required permissions:
- Client ID
- Client Secret
The AGS Group API documentation for reference.

Manage groups

The following sections detail how to integrate group management into your game.

Create a new group

You can allow your players to create a new group once you have a group configuration in your namespace. The player who created the group will be group admin by default. Use the following function to create a new group:

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsCreateGroupRequest RequestContent = {};
RequestContent.ConfigurationCode = "YourGroupConfigurationCode";
RequestContent.GroupName = "YourGroupName";
RequestContent.GroupDescription = "YourGroupDescription";
RequestContent.GroupMaxMember = 50;
RequestContent.GroupType = EAccelByteGroupType::PUBLIC;

ApiClient->Group.CreateGroup(RequestContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if CreateGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CreateGroup has an error
}));

CreateGroupRequest createGroupRequest = new CreateGroupRequest
{
    configurationCode = "YourGroupConfigurationCode",
    groupName = "YourGroupName",
    groupDescription = "YourGroupDescription",
    groupMaxMember = 50,
    groupType = GroupType.PUBLIC
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CreateGroup(createGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if CreateGroup has an error
        Debug.Log($"Error CreateGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if CreateGroup is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsCreateGroupRequest RequestContent = {};
RequestContent.ConfigurationCode = "YourGroupConfigurationCode";
RequestContent.GroupName = "YourGroupName";
RequestContent.GroupDescription = "YourGroupDescription";
RequestContent.GroupMaxMember = 50;
RequestContent.GroupType = EAccelByteGroupType::PUBLIC;

ApiClient->Group.CreateV2Group(RequestContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if CreateV2Group is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CreateV2Group has an error
}));

CreateGroupRequest createGroupRequest = new CreateGroupRequest
{
    configurationCode = "YourGroupConfigurationCode",
    groupName = "YourGroupName",
    groupDescription = "YourGroupDescription",
    groupMaxMember = 50,
    groupType = GroupType.PUBLIC
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CreateGroupV2(createGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if CreateGroupV2 has an error
        Debug.Log($"Error CreateGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if CreateGroupv2 is successful
});

Update group information

Information that is tied to a specific group, such as a group name, icon, description, region, or type, can be updated. Only members with an admin role can update the group’s information. Use this function to update group information:

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";
bool bCompletelyReplace = true;

FAccelByteModelsGroupUpdatable UpdateContent = {};
UpdateContent.GroupName = "UpdatedGroupName";
UpdateContent.GroupDescription = "UpdatedGroupDescription";
UpdateContent.GroupType = EAccelByteGroupType::PRIVATE;

ApiClient->Group.UpdateGroup(GroupId, bCompletelyReplace, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateGroup has an error
}));

string groupId = "YourGroupId";

UpdateGroupRequest updateGroupRequest = new UpdateGroupRequest
{
    groupName = "UpdatedGroupName",
    groupDescription = "UpdatedGroupDescription",
    groupType = GroupType.PRIVATE
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroup(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroup has an error
        Debug.Log($"Error UpdateGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroup is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsUpdateGroupRequest UpdateContent = {};
UpdateContent.GroupName = "UpdatedGroupName";
UpdateContent.GroupDescription = "UpdatedGroupDescription";
UpdateContent.GroupType = EAccelByteGroupType::PRIVATE;

ApiClient->Group.UpdateV2Group(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateV2Group is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateV2Group has an error
}));

string groupId = "YourGroupId";

UpdateGroupRequest updateGroupRequest = new UpdateGroupRequest
{
    groupName = "UpdatedGroupName",
    groupDescription = "UpdatedGroupDescription",
    groupType = GroupType.PRIVATE
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupV2(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupV2 has an error
        Debug.Log($"Error UpdateGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupV2 is successful
});

Update a group’s custom attributes

You can update a group’s custom attributes separately using this function. Just like updating group information, only members with an admin role can update the group’s custom attributes.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

FJsonObjectWrapper UpdatedCustomAttributes;
UpdatedCustomAttributes.JsonObject = MakeShared<FJsonObject>();
UpdatedCustomAttributes.JsonObject->SetStringField("Attribute String Key", "Updated Attribute");

FAccelByteModelsUpdateGroupCustomAttributesRequest UpdateContent = {};
UpdateContent.CustomAttributes = UpdatedCustomAttributes;

ApiClient->Group.UpdateGroupCustomAttributes(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateGroupCustomAttributes is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateGroupCustomAttributes has an error
}));

string groupId = "YourGroupId";

Dictionary<string, object> updateGroupRequest = new Dictionary<string, object>
{
    {"Attribute String Key", "Updated Attribute" }
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupCustomAttributes(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupCustomAttributes has an error
        Debug.Log($"Error UpdateGroupCustomAttributes, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupCustomAttributes is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

FJsonObjectWrapper UpdatedCustomAttributes;
UpdatedCustomAttributes.JsonObject = MakeShared<FJsonObject>();
UpdatedCustomAttributes.JsonObject->SetStringField("Attribute String Key", "Updated Attribute");

FAccelByteModelsUpdateGroupCustomAttributesRequest UpdateContent = {};
UpdateContent.CustomAttributes = UpdatedCustomAttributes;

ApiClient->Group.UpdateV2GroupCustomAttributes(GroupId, UpdateContent, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if UpdateV2GroupCustomAttributes is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if UpdateV2GroupCustomAttributes has an error
}));

string groupId = "YourGroupId";

Dictionary<string, object> updateGroupRequest = new Dictionary<string, object>
{
    {"Attribute String Key", "Updated Attribute" }
};

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().UpdateGroupCustomAttributesV2(groupId, updateGroupRequest, result =>
{
    if (result.IsError)
    {
        // Do something if UpdateGroupCustomAttributesV2 has an error
        Debug.Log($"Error UpdateGroupCustomAttributesV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if UpdateGroupCustomAttributesV2 is successful
});

Display group information

The following sections detail how to display different types of group information.

Retrieve a list of groups

You can allow your players to search the available groups created by the players by searching using a group name or region. The results will be appear in pages, and you can use offset and limit parameters to limit the list. Use the following function to retrieve a list of groups:

note

The function below only shows PUBLIC and OPEN groups. You can learn more about group types in the section on group interactions.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsGetGroupListRequest FilterContent = {};
FilterContent.GroupName = "YourGroupName";
FilterContent.GroupRegion = "US";

ApiClient->Group.GetGroupList(FilterContent, THandler<FAccelByteModelsGetGroupListResponse>::CreateLambda([](const FAccelByteModelsGetGroupListResponse& Result)
{
    // Do something if GetGroupList is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupList has an error
}));

string groupName = "YourGroupName";
string groupRegion = "US";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().SearchGroups(groupName, groupRegion, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if SearchGroups has an error
        Debug.Log($"Error SearchGroups, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if SearchGroups is successful
});

Retrieve group information by group ID

To give more clear information about the group to the players, you can use the following function to get information about a group by using the group ID:

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.GetGroup(GroupId, THandler<FAccelByteModelsGroupInformation>::CreateLambda([](const FAccelByteModelsGroupInformation& Result)
{
    // Do something if GetGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroup has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroup(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroup has an error
        Debug.Log($"Error GetGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroup is successful
});

Retrieve group information by user ID

You can let your players get their group information by using their user Id with the following function:

note

If the player you requested doesn't belong to any group, the returned status will be ErrorCode.UserNotBelongToAnyGroup, and the player will be able to be invited to a group.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.GetUserGroupInfoByUserId(UserId, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if GetUserGroupInfoByUserId is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetUserGroupInfoByUserId has an error
}));

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetMyGroupInfo(result =>
{
    if (result.IsError)
    {
        // Do something if GetMyGroupInfo has an error
        Debug.Log($"Error GetMyGroupInfo, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetMyGroupInfo is successful
})

Retrieve a player’s group information

You can allow your player to retrieve the group information of the user with a specific user Id.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.GetUserGroupInfoByUserId(UserId, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if GetUserGroupInfoByUserId is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetUserGroupInfoByUserId has an error
}));

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetOtherGroupInfo(userId, result =>
{
    if (result.IsError)
    {
        // Do something if GetOtherGroupInfo has an error
        Debug.Log($"Error GetOtherGroupInfo, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetOtherGroupInfo is successful
});

Retrieve a group’s member list

You can let your players retrieve a list of members within a specific group. Use the following function to get a group’s member list by using a group Id.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsGetGroupMembersListByGroupIdRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;
RequestContent.SortBy = EAccelByteGroupListSortBy::ASCENDING;

ApiClient->Group.GetGroupMembersListByGroupId(GroupId, RequestContent, THandler<FAccelByteModelsGetGroupMemberListResponse>::CreateLambda([](const FAccelByteModelsGetGroupMemberListResponse& Result)
{
    // Do something if GetGroupMembersListByGroupId is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupMembersListByGroupId has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupMemberList(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupMemberList has an error
        Debug.Log($"Error GetGroupMemberList, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupMemberList is successful
});

Interact with groups

The follow sections details players' interactions with groups.

Join a group

Players can request to join OPEN or PUBLIC groups. Each group type will have a different behavior:

OPEN groups will allow players to automatically join.
PUBLIC groups will require players to make a join request which needs to be approved by a group admin before the player can join.

Use the following function to allow players join to a specific group.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.JoinGroup(GroupId, THandler<FAccelByteModelsJoinGroupResponse>::CreateLambda([](const FAccelByteModelsJoinGroupResponse& Result)
{
    // Do something if JoinGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if JoinGroup has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().JoinGroup(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroup has an error
        Debug.Log($"Error JoinGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroup is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.JoinV2Group(GroupId, THandler<FAccelByteModelsJoinGroupResponse>::CreateLambda([](const FAccelByteModelsJoinGroupResponse& Result)
{
    // Do something if JoinV2Group is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if JoinV2Group has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().JoinGroupV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroupV2 has an error
        Debug.Log($"Error JoinGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroupV2 is successful
});

Cancel a join request

After a player requests to join a PUBLIC group, that request can be canceled.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.CancelJoinGroupRequest(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if CancelJoinGroupRequest is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if CancelJoinGroupRequest has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().CancelJoinGroupRequest(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if JoinGroupV2 has an error
        Debug.Log($"Error JoinGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if JoinGroupV2 is successful
});

Leave a group

To allow players to leave a group, you can use the following function:

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

ApiClient->Group.LeaveGroup(THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if LeaveGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if LeaveGroup has an error
}));

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().LeaveGroup(result =>
{
    if (result.IsError)
    {
        // Do something if LeaveGroup has an error
        Debug.Log($"Error LeaveGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if LeaveGroup is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.LeaveV2Group(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if LeaveV2Group is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if LeaveV2Group has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().LeaveGroupV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if LeaveGroupV2 has an error
        Debug.Log($"Error LeaveGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if LeaveGroupV2 is successful
});

Invite a player to a group

Group admins can invite players to join their group. A PRIVATE group can use this function to add new members. Players need to accept the invitation before they can join the group.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.InviteUserToGroup(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if InviteUserToGroup is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if InviteUserToGroup has an error
}));

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().InviteOtherUserToGroup(userId, result =>
{
    if (result.IsError)
    {
        // Do something if InviteOtherUserToGroup has an error
        Debug.Log($"Error InviteOtherUserToGroup, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if InviteOtherUserToGroup is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.InviteUserToV2Group(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if InviteUserToV2Group is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if InviteUserToV2Group has an error
}));

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().InviteOtherUserToGroupV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if InviteOtherUserToGroupV2 has an error
        Debug.Log($"Error InviteOtherUserToGroupV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    // Do something if InviteOtherUserToGroupV2 is successful
});

Remove/kick a group member

Group admins can also remove (kick) group members from the group.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.KickGroupMember(UserId, THandler<FAccelByteModelsKickGroupMemberResponse>::CreateLambda([](const FAccelByteModelsKickGroupMemberResponse& Result)
{
    // Do something if KickGroupMember is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if KickGroupMember has an error
}));

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().KickGroupMember(userId, result =>
{
    if (result.IsError)
    {
        // Do something if KickGroupMember has an error
        Debug.Log($"Error KickGroupMember, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    // Do something if KickGroupMember is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.KickV2GroupMember(UserId, GroupId, THandler<FAccelByteModelsKickGroupMemberResponse>::CreateLambda([](const FAccelByteModelsKickGroupMemberResponse& Result)
{
    // Do something if KickV2GroupMember is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if KickV2GroupMember has an error
}));

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().KickGroupMemberV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if KickGroupMemberV2 has an error
        Debug.Log($"Error KickGroupMemberV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if KickGroupMemberV2 is successful
});

Get a list of group invitation requests

Players can get the list of group invitation requests to either accept or reject these invitations.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupInvitationRequests(RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupInvitationRequests is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupInvitationRequests has an error
}));

int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupInvitationRequests(limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupInvitationRequests has an error
        Debug.Log($"Error GetGroupInvitationRequests, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupInvitationRequests is successful
});

Accept a group invitation request

After getting the invitation list, players can accept an invitation.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.AcceptGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupInvitation is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupInvitation has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptGroupInvitation(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptGroupInvitation has an error
        Debug.Log($"Error AcceptGroupInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptGroupInvitation is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.AcceptGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupInvitation is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupInvitation has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptGroupInvitationV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptGroupInvitationV2 has an error
        Debug.Log($"Error AcceptGroupInvitationV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptGroupInvitationV2 is successful
});

Reject a group invitation request

Players can reject any invitation request.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.RejectGroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectGroupInvitation is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectGroupInvitation has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectGroupInvitation(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectGroupInvitation has an error
        Debug.Log($"Error RejectGroupInvitation, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectGroupInvitation is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

ApiClient->Group.RejectV2GroupInvitation(GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectV2GroupInvitation is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectV2GroupInvitation has an error
}));

string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectGroupInvitationV2(groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectGroupInvitationV2 has an error
        Debug.Log($"Error RejectGroupInvitationV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectGroupInvitationV2 is successful
});

Get a list of group member join requests

Group admins can get a list of group member join requests to either approve or reject them.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupJoinRequests(GroupId, RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupJoinRequests is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupJoinRequests has an error
}));

string groupId = "YourGroupId";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupJoinRequests(groupId, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupJoinRequests has an error
        Debug.Log($"Error GetGroupJoinRequests, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupJoinRequests is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString GroupId = "YourGroupId";

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetGroupJoinRequestList(GroupId, RequestContent, THandler<FAccelByteModelsGetMemberRequestsListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRequestsListResponse& Result)
{
    // Do something if GetGroupJoinRequestList is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetGroupJoinRequestList has an error
}));

string groupId = "YourGroupId";
int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetGroupJoinRequestsV2(groupId, limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetGroupJoinRequestsV2 has an error
        Debug.Log($"Error GetGroupJoinRequestsV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if GetGroupJoinRequestsV2 is successful
});

Accept a group member join request

After getting the list of join requests, a group admin can accept them to the group.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.AcceptGroupJoinRequest(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptGroupJoinRequest is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptGroupJoinRequest has an error
}));

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptOtherJoinRequest(userId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptOtherJoinRequest has an error
        Debug.Log($"Error AcceptOtherJoinRequest, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if AcceptOtherJoinRequest is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.AcceptV2GroupJoinRequest(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if AcceptV2GroupJoinRequest is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AcceptV2GroupJoinRequest has an error
}));

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AcceptOtherJoinRequestV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AcceptOtherJoinRequestV2 has an error
        Debug.Log($"Error AcceptOtherJoinRequestV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AcceptOtherJoinRequestV2 is successful
});

Reject a group member join request

Group admins can reject any member join request.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";

ApiClient->Group.RejectGroupJoinRequest(UserId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectGroupJoinRequest is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectGroupJoinRequest has an error
}));

string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectOtherJoinRequest(userId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectOtherJoinRequest has an error
        Debug.Log($"Error RejectOtherJoinRequest, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if RejectOtherJoinRequest is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString UserId = "YourUserId";
FString GroupId = "YourGroupId";

ApiClient->Group.RejectV2GroupJoinRequest(UserId, GroupId, THandler<FAccelByteModelsMemberRequestGroupResponse>::CreateLambda([](const FAccelByteModelsMemberRequestGroupResponse& Result)
{
    // Do something if RejectV2GroupJoinRequest is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if RejectV2GroupJoinRequest has an error
}));

string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RejectOtherJoinRequestV2(userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RejectOtherJoinRequestV2 has an error
        Debug.Log($"Error RejectOtherJoinRequestV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }

    // Do something if RejectOtherJoinRequestV2 is successful
});

Manage group roles

Every group member has roles assigned to them which can be used to restrict or allow access to features such as inviting a member or kicking a member, among others. Every group member will be automatically assigned to the default member role that is already defined in the group configuration. This can either be an admin group role or a member group role.

Get a list of group member roles

An admin can get a list of the member roles that have already been created in the AGS Admin Portal.

Unreal Engine V1
Unity V1
Unreal Engine V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetMemberRoles(RequestContent, THandler<FAccelByteModelsGetMemberRolesListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRolesListResponse& Result)
{
    // Do something if GetMemberRoles is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetMemberRoles has an error
}));

int limit = 100;
int offset = 0;

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().GetMemberRoles(limit, offset, result =>
{
    if (result.IsError)
    {
        // Do something if GetMemberRoles has an error
        Debug.Log($"Error GetMemberRoles, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if GetMemberRoles is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FAccelByteModelsLimitOffsetRequest RequestContent = {};
RequestContent.Limit = 100;
RequestContent.Offset = 0;

ApiClient->Group.GetAllMemberRoles(RequestContent, THandler<FAccelByteModelsGetMemberRolesListResponse>::CreateLambda([](const FAccelByteModelsGetMemberRolesListResponse& Result)
{
    // Do something if GetAllMemberRoles is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if GetAllMemberRoles has an error
}));

Promote a member to a role

A group admin can promote a group member to a specific role if the role has been defined for that group.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString MemberRoleId = "YourMemberRoleId";

FAccelByteModelsUserIdWrapper RequestContent = {};
RequestContent.UserId = "YourUserId";

ApiClient->Group.AssignMemberRole(MemberRoleId, RequestContent, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if AssignMemberRole is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AssignMemberRole has an error
}));

string memberRoleId = "YourMemberRoleId";
string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AssignRoleToMember(memberRoleId, userId, result =>
{
    if (result.IsError)
    {
        // Do something if AssignRoleToMember has an error
        Debug.Log($"Error AssignRoleToMember, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AssignRoleToMember is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString MemberRoleId = "YourMemberRoleId";
FString GroupId = "YourGroupId";

FAccelByteModelsUserIdWrapper RequestContent = {};
RequestContent.UserId = "YourUserId";

ApiClient->Group.AssignV2MemberRole(MemberRoleId, GroupId, RequestContent, THandler<FAccelByteModelsGetUserGroupInfoResponse>::CreateLambda([](const FAccelByteModelsGetUserGroupInfoResponse& Result)
{
    // Do something if AssignV2MemberRole is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if AssignV2MemberRole has an error
}));

string memberRoleId = "YourMemberRoleId";
string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().AssignRoleToMemberV2(memberRoleId, userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if AssignRoleToMemberV2 has an error
        Debug.Log($"Error AssignRoleToMemberV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if AssignRoleToMemberV2 is successful
});

Remove a member’s role

An admin can remove a role from a member.

Unreal Engine V1
Unity V1
Unreal Engine V2
Unity V2

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString MemberRoleId = "YourMemberRoleId";

FAccelByteModelsUserIdWrapper RequestContent = {};
RequestContent.UserId = "YourUserId";

ApiClient->Group.DeleteMemberRole(MemberRoleId, RequestContent, FVoidHandler::CreateLambda([]()
{
    // Do something if DeleteMemberRole is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if DeleteMemberRole has an error
}));

string memberRoleId = "YourMemberRoleId";
string userId = "YourUserId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RemoveRoleFromMember(memberRoleId, userId, result =>
{
    if (result.IsError)
    {
        // Do something if RemoveRoleFromMember has an error
        Debug.Log($"Error RemoveRoleFromMember, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if RemoveRoleFromMember is successful
});

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

FString MemberRoleId = "YourMemberRoleId";
FString GroupId = "YourGroupId";

FAccelByteModelsUserIdWrapper RequestContent = {};
RequestContent.UserId = "YourUserId";

ApiClient->Group.DeleteV2MemberRole(MemberRoleId, GroupId, RequestContent, FVoidHandler::CreateLambda([]()
{
    // Do something if DeleteV2MemberRole is successful
}), FErrorHandler::CreateLambda([](int32 ErrorCode, const FString& ErrorMessage)
{
    // Do something if DeleteV2MemberRole has an error
}));

string memberRoleId = "YourMemberRoleId";
string userId = "YourUserId";
string groupId = "YourGroupId";

AccelByteSDK.GetClientRegistry().GetApi().GetGroup().RemoveRoleFromMemberV2(memberRoleId, userId, groupId, result =>
{
    if (result.IsError)
    {
        // Do something if RemoveRoleFromMemberV2 has an error
        Debug.Log($"Error RemoveRoleFromMemberV2, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    
    // Do something if RemoveRoleFromMemberV2 is successful
});

Manage group notifications

Some group activities will trigger notifications that will be sent to individual players, to group admins, or to all group members. The notification payload will be a JSON formatted string that contains data related to the triggered activity. To retrieve these notifications, you need to add a callback to the SetMessageNotifDelegate and the OnNotification functions.

Unreal Engine
Unity

FApiClientPtr ApiClient = FMultiRegistry::GetApiClient();

ApiClient->Lobby.Connect();

FString NotificationTopic = "group";

ApiClient->Lobby.SetMessageNotifDelegate(AccelByte::Api::Lobby::FMessageNotif::CreateLambda([&](FAccelByteModelsNotificationMessage const& Notif)
    {
    if (Notif.Topic == NotificationTopic)
    {
        // Do something if there's a new notification under group topic
    }
    }));

AccelByteSDK.GetClientRegistry().GetApi().GetLobby().Connect();

string notificationTopic = "group";

AccelByteSDK.GetClientRegistry().GetApi().GetLobby().OnNotification += result =>
{
    if (result.IsError)
    {
        // Do something if OnNotification has an error
        Debug.Log($"Error OnNotification, Error Code: {result.Error.Code} Error Message: {result.Error.Message}");
        return;
    }
    if (result.Value.topic == notificationTopic)
    {
        // Do something if there's a new notification under group topic
    }
};

Notify a player of a group invitation

Here’s an example of the payload for a notification sent to a player when they’ve been invited to join a group:

Group Invitation Notification

{
  "groupName": "nameOfGroup",
  "groupId": "groupId",
  "kind": "invitation"
}

Notify a player of an accepted join request

Here’s an example of the payload for a notification sent to a player when their request to join a group has been accepted:

Group Acceptance Notification

{
  "groupName": "nameOfGroup",
  "groupId": "groupId",
  "kind": "accepted-request"
}

Notify a player of a rejected join request

Here’s an example of the payload for a notification sent to a player when their request to join a group has been rejected:

Group Rejection Notifications

{
  "groupName": "nameOfGroup",
  "groupId": "groupId",
  "kind": "rejected-request"
}

New Group Member Notifications

Here’s an example of the payload for a notification sent to all group members when a new member has joined their group:

New Group Member Notifications

{
  "groupName": "nameOfGroup",
  "groupId": "groupId",
  "newGroupMember": "newGroupMember",
  "kind": "new-member"
}

Notify a group admin of a request to join a group

Here’s an example of the payload for a notification sent to group admins when a player has requested to join their group:

Member Request Notifications

{
  "groupName": "nameOfGroup",
  "groupId": "groupId",
  "newGroupMember": "newGroupMember",
  "kind": "join-request"
}

Notify a player of a new role assignment

Here’s an example of the payload for a notification sent to a player when a group admin has assigned a role to them:

Member Role Assignment Notifications

{
  "groupName": "nameofgroup",
  "groupId": "groupId",
  "roleName": "Chief",
  "roleId": "roleId",
  "kind": "assigned-role"
}

Notify a member of a role removal

Here’s an example of the payload for a notification sent to a player when a group admin has removed a role from them:

Member Role Removal Notifications

{
  "groupName": "nameofgroup",
  "groupId": "groupId",
  "roleName": "Chief",
  "roleId": "roleId",
  "kind": "removed-role"
}

Overview​

Goals​

Prerequisites​

Manage groups​

Create a new group​

Update group information​

Update a group’s custom attributes​

Display group information​

Retrieve a list of groups​

Retrieve group information by group ID​

Retrieve group information by user ID​

Retrieve a player’s group information​

Retrieve a group’s member list​

Interact with groups​

Join a group​

Cancel a join request​

Leave a group​

Invite a player to a group​

Remove/kick a group member​

Get a list of group invitation requests​

Accept a group invitation request​

Reject a group invitation request​

Get a list of group member join requests​

Accept a group member join request​

Reject a group member join request​

Manage group roles​

Get a list of group member roles​

Promote a member to a role​

Remove a member’s role​

Manage group notifications​

Notify a player of a group invitation​

Notify a player of an accepted join request​

Notify a player of a rejected join request​

New Group Member Notifications​

Notify a group admin of a request to join a group​

Notify a player of a new role assignment​

Notify a member of a role removal​

On this page