Join/Leave Community

Use community membership APIs to let the active user join or leave a community. Communities that require approval return a pending join request instead of immediate membership.

iOS, Android, and TypeScript support object-based community.join() flows that return a success or pending result. Flutter currently exposes repository-level joinCommunity() and leaveCommunity() methods.

Parameters

Operation	Parameter	Required	Description
Join community	Community object	Platform-dependent	iOS, Android, and TypeScript call `join()` on a fetched community object.
Join community	`communityId`	Platform-dependent	Flutter joins by community ID.
Check my join request	Community object	Yes	Fetched community object used to read the active user’s pending request.
Observe pending join requests	Community object	Yes	Fetched community object used by moderators to list join requests.
Observe pending join requests	`status` / `limit`	No	Optional request status and page-size controls where exposed.
Cancel, approve, or reject	Join request object	Yes	Join request object returned from a join-request query.
Leave community	`communityId`	Yes	Community ID the active user should leave.

Join Community

For approval-aware flows, fetch a community object first and call join() where the platform supports it. The result tells you whether membership was granted immediately or a join request is pending.

var community: AmityCommunity! // Fetched community

Task { @MainActor in
    do {
        let result = try await community.join()

        switch result {
        case .success:
            // Joined immediately
            break
        case .pending(let joinRequest):
            let status = joinRequest.status
            // Show pending state
        }
    } catch let error {
        handleError(error)
    }
}

fun joinCommunity(community: AmityCommunity) {
    community.join()
        .doOnSuccess { result ->
            when (result) {
                is AmityJoinResult.Success -> {
                    // Joined immediately
                }
                is AmityJoinResult.Pending -> {
                    val joinRequest = result.request
                    // Show pending state
                }
            }
        }
        .doOnError { throwable ->
            when (AmityError.from(throwable)) {
                AmityError.ITEM_NOT_FOUND -> {
                    // Community does not exist
                }
                AmityError.USER_IS_BANNED -> {
                    // Current user is banned
                }
                else -> {
                    // Handle other errors
                }
            }
        }
        .subscribe()
}

async function joinCommunity(community: Amity.Community): Promise<Amity.JoinResult> {
  const result = await community.join();

  if (result.status === 'pending') {
    const joinRequest = result.request;
    // Show pending state
  }

  return result;
}

Future<void> joinCommunity(String communityId) async {
  await AmitySocialClient.newCommunityRepository()
      .joinCommunity(communityId);
}

Join Requests

When a community requires approval, the SDK exposes the active user’s request and moderator review flows.

Check My Join Request

Fetch the active user’s join request when an approval-required community returns a pending state.

var community: AmityCommunity! // Fetched community

Task { @MainActor in
    do {
        let joinRequest = try await community.getMyJoinRequest()
        let status = joinRequest.status
        // Render status
    } catch let error {
        handleError(error)
    }
}

fun getMyJoinRequest(community: AmityCommunity) {
    community.getMyJoinRequest()
        .doOnSuccess { joinRequest ->
            val status = joinRequest.getStatus()
            // Render status
        }
        .doOnError { throwable ->
            // Handle error
        }
        .subscribe()
}

async function getMyJoinRequest(community: Amity.Community) {
  const joinRequest = await community.getMyJoinRequest();

  if (joinRequest?.status === 'pending') {
    // Render pending state
  }

  return joinRequest;
}

Observe Pending Join Requests

Moderators can observe join requests for a community and approve or reject individual requests.

var community: AmityCommunity! // Fetched community

token = community.getJoinRequests(status: .pending).observe { collection, error in
    if let error = error {
        handleError(error)
        return
    }

    let joinRequests = collection.snapshots
    // Render pending requests
}

fun observePendingJoinRequests(community: AmityCommunity) {
    community.getJoinRequests(status = AmityJoinRequestStatus.PENDING)
        .doOnNext { joinRequests: PagingData<AmityJoinRequest> ->
            // Render pending requests
        }
        .doOnError { throwable ->
            // Handle error
        }
        .subscribe()
}

import { JoinRequestStatusEnum } from '@amityco/ts-sdk';

function observePendingJoinRequests(community: Amity.Community) {
  return community.getJoinRequests(
    {
      communityId: community.communityId,
      type: 'communityJoinRequest',
      targetType: 'community',
      status: JoinRequestStatusEnum.Pending,
      options: { limit: 20 },
    },
    ({ data: joinRequests, loading, error }) => {
      if (error) {
        // Handle error
        return;
      }

      if (!loading && joinRequests) {
        // Render pending requests
      }
    },
  );
}

Cancel, Approve, or Reject

Cancel your own request or approve and reject pending requests from a moderator flow.

func cancelJoinRequest(_ joinRequest: AmityJoinRequest) {
    Task { @MainActor in
        do {
            try await joinRequest.cancel()
        } catch let error {
            handleError(error)
        }
    }
}

func approveJoinRequest(_ joinRequest: AmityJoinRequest) {
    Task { @MainActor in
        do {
            try await joinRequest.approve()
        } catch let error {
            handleError(error)
        }
    }
}

func rejectJoinRequest(_ joinRequest: AmityJoinRequest) {
    Task { @MainActor in
        do {
            try await joinRequest.reject()
        } catch let error {
            handleError(error)
        }
    }
}

fun cancelJoinRequest(joinRequest: AmityJoinRequest) {
    joinRequest.cancel()
        .doOnComplete {
            // Cancelled
        }
        .subscribe()
}

fun approveJoinRequest(joinRequest: AmityJoinRequest) {
    joinRequest.approve()
        .doOnComplete {
            // Approved
        }
        .subscribe()
}

fun rejectJoinRequest(joinRequest: AmityJoinRequest) {
    joinRequest.reject()
        .doOnComplete {
            // Rejected
        }
        .subscribe()
}

async function cancelJoinRequest(joinRequest: Amity.JoinRequest) {
  await joinRequest.cancel();
}

async function approveJoinRequest(joinRequest: Amity.JoinRequest) {
  await joinRequest.approve();
}

async function rejectJoinRequest(joinRequest: Amity.JoinRequest) {
  await joinRequest.reject();
}

Leave Community

Use leaveCommunity() to remove the active user from a community.

Leaving removes the current user’s community membership. If the community requires approval, the user may need to request access again before rejoining.

do {
    try await communityRepository.leaveCommunity(withId: communityId)
} catch let error {
    handleError(error)
}

fun leaveCommunity(communityRepository: AmityCommunityRepository, communityId: String) {
    communityRepository
        .leaveCommunity(communityId = communityId)
        .doOnComplete {
            // Left community
        }
        .doOnError { throwable ->
            when (AmityError.from(throwable)) {
                AmityError.ITEM_NOT_FOUND -> {
                    // Community does not exist
                }
                AmityError.PERMISSION_DENIED -> {
                    // Permission denied
                }
                else -> {
                    // Handle other errors
                }
            }
        }
        .subscribe()
}

import { CommunityRepository } from '@amityco/ts-sdk';

async function leaveCommunity(communityId: Amity.Community['communityId']) {
  const hasLeft = await CommunityRepository.leaveCommunity(communityId);
  return hasLeft;
}

Future<void> leaveCommunity(String communityId) async {
  await AmitySocialClient.newCommunityRepository()
      .leaveCommunity(communityId);
}

Query Community Members

View and search community member lists.

Member Management

Add and remove community members.

Community Moderation

Manage roles, bans, and permissions.

Community Invitation

Invitation-based member onboarding workflows.

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Release Notes

Migration Guides

Support

Parameters

Join Community

Join Requests

Check My Join Request

Observe Pending Join Requests

Cancel, Approve, or Reject

Leave Community

Query Community Members

Member Management

Community Moderation

Community Invitation

​Parameters

​Join Community

​Join Requests

​Check My Join Request

​Observe Pending Join Requests

​Cancel, Approve, or Reject

​Leave Community

​Related Topics

Query Community Members

Member Management

Community Moderation

Community Invitation

Parameters

Join Community

Join Requests

Check My Join Request

Observe Pending Join Requests

Cancel, Approve, or Reject

Leave Community

Related Topics