> ## Documentation Index
> Fetch the complete documentation index at: https://social-b97141fb-auto-generate-llmstxt.mintlify.site/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.

```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;
}
```

## Get My Community Invitations

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

```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
      }
    },
  );
}
```

## Check a Community Invitation

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

```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;
}
```

## Accept or Reject an Invitation

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

```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();
}
```

## Create Invitations

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

```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);
}
```

## Get Member Invitations

Moderators can observe invitations sent for a community.

```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
      }
    },
  );
}
```

## Related Topics

> **[Join / Leave Community](/social-plus-sdk/social/communities-spaces/organization/join-leave-community.md)**
>
> Manage user-initiated joining and leaving

> **[Query Community Members](/social-plus-sdk/social/communities-spaces/organization/query-community-members.md)**
>
> Query and search community members

> **[Member Management](/social-plus-sdk/social/communities-spaces/organization/member-management.md)**
>
> Add and remove community members directly

> **[Community Discovery](/social-plus-sdk/social/communities-spaces/discovery/query-communities.md)**
>
> Discover and filter communities


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