> ## Documentation Index
> Fetch the complete documentation index at: https://learn.social.plus/llms.txt
> Use this file to discover all available pages before exploring further.

# Community Invitation Management

> Read, send, accept, and reject community invitations

Community invitations let moderators invite users to join a community. Depending on network settings, invited users may become members automatically or may need to accept the invitation.

## Parameters

| Operation                         | Platforms                | Parameter            | Required | Description                                                                                 |
| --------------------------------- | ------------------------ | -------------------- | -------- | ------------------------------------------------------------------------------------------- |
| Get membership acceptance setting | iOS, Android, TypeScript | None                 | No       | Reads social settings to determine whether invited users join automatically or must accept. |
| Get my community invitations      | iOS, Android, TypeScript | `limit` / page size  | No       | Page size for the signed-in user's invitation list where the platform exposes pagination.   |
| Check a community invitation      | iOS, Android, TypeScript | Community object     | Yes      | Fetched community object used to read the current user's invitation state.                  |
| Accept or reject an invitation    | iOS, Android, TypeScript | Invitation object    | Yes      | Invitation object returned from a community or invitation query.                            |
| Create invitations                | iOS, Android, TypeScript | Community object     | Yes      | Fetched community object used to create invitations.                                        |
| Create invitations                | iOS, Android, TypeScript | `userIds`            | Yes      | User IDs to invite to the community.                                                        |
| Get member invitations            | iOS, Android, TypeScript | Community object     | Yes      | Fetched community object used to query invitations sent for that community.                 |
| Get member invitations            | iOS, Android, TypeScript | `statuses` / `limit` | No       | Optional invitation status filters and page size where exposed.                             |

## Membership Acceptance Setting

Use social settings to check whether the network uses automatic membership or invitation acceptance.

<CodeGroup>
  ```swift iOS theme={null}
  let socialSettings = client.getSocialSettings()

  switch socialSettings?.membershipAcceptance {
  case .automatic:
      // Invitations add users automatically
      break
  case .invitation:
      // Invited users must accept
      break
  case .none:
      // Settings are not available locally yet
      break
  @unknown default:
      break
  }
  ```

  ```kotlin Android theme={null}
  fun observeMembershipAcceptance() {
      AmitySocialClient.getSettings()
          .doOnNext { socialSettings ->
              when (socialSettings.getMembershipAcceptanceType()) {
                  AmityMembershipAcceptanceType.AUTOMATIC -> {
                      // Invitations add users automatically
                  }
                  AmityMembershipAcceptanceType.INVITATION -> {
                      // Invited users must accept
                  }
                  AmityMembershipAcceptanceType.UNKNOWN -> {
                      // Setting is unknown
                  }
              }
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  import { MembershipAcceptanceTypeEnum } from '@amityco/ts-sdk';

  async function getMembershipAcceptance() {
    const settings = await client.getSocialSettings();

    if (settings.membershipAcceptance === MembershipAcceptanceTypeEnum.Invitation) {
      // Invited users must accept
    }

    return settings.membershipAcceptance;
  }
  ```
</CodeGroup>

## Get My Community Invitations

Use this flow for the current user to list pending community invitations.

<CodeGroup>
  ```swift iOS theme={null}
  let invitationRepository = AmityInvitationRepository()
  let liveCollection = invitationRepository.getMyCommunityInvitations()

  token = liveCollection.observe { collection, error in
      if let error = error {
          handleError(error)
          return
      }

      let invitations = collection.snapshots
      // Render pending invitations
  }
  ```

  ```kotlin Android theme={null}
  fun getMyCommunityInvitations() {
      AmityCoreClient.newInvitationRepository()
          .getMyCommunityInvitations()
          .doOnNext { invitations: PagingData<AmityInvitation> ->
              // Render pending invitations
          }
          .doOnError { throwable ->
              // Handle error
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  import { InvitationRepository } from '@amityco/ts-sdk';

  function getMyCommunityInvitations() {
    return InvitationRepository.getMyCommunityInvitations(
      { limit: 20 },
      ({ data: invitations, loading, error }) => {
        if (error) {
          // Handle error
          return;
        }

        if (!loading && invitations) {
          // Render pending invitations
        }
      },
    );
  }
  ```
</CodeGroup>

## Check a Community Invitation

Use `community.getInvitation()` when the user needs to know whether they have a pending invitation for a specific community.

<CodeGroup>
  ```swift iOS theme={null}
  var community: AmityCommunity! // Fetched community

  if let invitation = await community.getInvitation() {
      switch invitation.status {
      case .pending:
          // Can accept or reject
          break
      case .approved, .rejected, .canceled:
          // Invitation already resolved
          break
      @unknown default:
          break
      }
  }
  ```

  ```kotlin Android theme={null}
  fun getInvitation(community: AmityCommunity) {
      community.getInvitation()
          .doOnSuccess { invitations: List<AmityInvitation> ->
              invitations.forEach { invitation ->
                  val status = invitation.getStatus()
                  // Render status
              }
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  import { InvitationStatusEnum } from '@amityco/ts-sdk';

  async function getInvitation(community: Amity.Community) {
    const invitation = await community.getInvitation();

    if (invitation?.status === InvitationStatusEnum.Pending) {
      // Can accept or reject
    }

    return invitation;
  }
  ```
</CodeGroup>

## Accept or Reject an Invitation

Invitation linked objects expose `accept()` and `reject()` across TypeScript, iOS, and Android.

<CodeGroup>
  ```swift iOS theme={null}
  var community: AmityCommunity! // Fetched community

  if let invitation = await community.getInvitation() {
      do {
          try await invitation.accept()
      } catch let error {
          handleError(error)
      }
  }
  ```

  ```kotlin Android theme={null}
  fun acceptInvitation(invitation: AmityInvitation) {
      invitation.accept()
          .doOnComplete {
              // Invitation accepted
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  async function acceptInvitation(invitation: Amity.Invitation) {
    await invitation.accept();
  }
  ```

  ```swift iOS theme={null}
  var community: AmityCommunity! // Fetched community

  if let invitation = await community.getInvitation() {
      do {
          try await invitation.reject()
      } catch let error {
          handleError(error)
      }
  }
  ```

  ```kotlin Android theme={null}
  fun rejectInvitation(invitation: AmityInvitation) {
      invitation.reject()
          .doOnComplete {
              // Invitation rejected
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  async function rejectInvitation(invitation: Amity.Invitation) {
    await invitation.reject();
  }
  ```
</CodeGroup>

## Create Invitations

Use `createInvitations()` on a fetched community object to invite users.

<CodeGroup>
  ```swift iOS theme={null}
  var community: AmityCommunity! // Fetched community

  do {
      try await community.createInvitations(["user1", "user2"])
  } catch let error {
      handleError(error)
  }
  ```

  ```kotlin Android theme={null}
  fun createInvitations(community: AmityCommunity) {
      community.createInvitations(userIds = listOf("user1", "user2"))
          .doOnComplete {
              // Invitations created
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  async function createInvitations(
    community: Amity.Community,
    userIds: Amity.User['userId'][],
  ) {
    await community.createInvitations(userIds);
  }
  ```
</CodeGroup>

## Get Member Invitations

Moderators can observe invitations sent for a community.

<CodeGroup>
  ```swift iOS theme={null}
  var community: AmityCommunity! // Fetched community

  let liveCollection = community.getMemberInvitations()

  token = liveCollection.observe { collection, error in
      if let error = error {
          handleError(error)
          return
      }

      let invitations = collection.snapshots
      // Render community invitations
  }
  ```

  ```kotlin Android theme={null}
  fun getMemberInvitations(community: AmityCommunity) {
      community.getMemberInvitations()
          .doOnNext { invitations: PagingData<AmityInvitation> ->
              // Render community invitations
          }
          .subscribe()
  }
  ```

  ```typescript TypeScript theme={null}
  import { InvitationStatusEnum } from '@amityco/ts-sdk';

  function getMemberInvitations(community: Amity.Community) {
    return community.getMemberInvitations(
      {
        statuses: [InvitationStatusEnum.Pending],
        limit: 20,
      },
      ({ data: invitations, loading, error }) => {
        if (error) {
          // Handle error
          return;
        }

        if (!loading && invitations) {
          // Render community invitations
        }
      },
    );
  }
  ```
</CodeGroup>

## Related Topics

<CardGroup cols={2}>
  <Card title="Join / Leave Community" href="./join-leave-community" icon="user-plus">
    Manage user-initiated joining and leaving
  </Card>

  <Card title="Query Community Members" href="./query-community-members" icon="magnifying-glass">
    Query and search community members
  </Card>

  <Card title="Member Management" href="./member-management" icon="users-cog">
    Add and remove community members directly
  </Card>

  <Card title="Community Discovery" href="../discovery/query-communities" icon="compass">
    Discover and filter communities
  </Card>
</CardGroup>