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

# Event RSVP

> Create, update, read, and query event RSVP responses from SDK event objects.

RSVP methods are exposed on the `AmityEvent` object returned by the event repository. Use them after you have loaded or created an event.

> [!NOTE]
>
> Flutter does not currently expose public scheduled-event RSVP APIs in the SDK source reviewed for this page.

## Status Values

| Meaning | TypeScript | iOS | Android |
| - | - | - | - |
| Going | `AmityEventResponseStatus.Going` | `.going` | `AmityEventResponseStatus.GOING` |
| Interested | Not exposed by the current TypeScript enum reviewed for this page | `.interested` | `AmityEventResponseStatus.INTERESTED` |
| Not going | `AmityEventResponseStatus.NotGoing` | `.notGoing` | `AmityEventResponseStatus.NOT_GOING` |

## Parameters

| Parameter | Methods | Platforms | Description |
| - | - | - | - |
| `event` | All RSVP methods | TypeScript, iOS, Android | Loaded `AmityEvent` object that exposes RSVP methods. |
| `status` | Create, update, query | TypeScript, iOS, Android | RSVP status to create, update, or filter. |
| `eventId` | Load before RSVP | TypeScript, iOS, Android | Event ID used to retrieve the event object first. |
| Pagination callback or collection | Query RSVPs | TypeScript, iOS, Android | Returned RSVP list or live collection for rendering attendees. |

## Create RSVP

Create an RSVP when a user responds to an event for the first time. The examples load the event first, then call `createRSVP` on the returned event object.

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

const unsubscribe = EventRepository.getEvent(
  'event-123',
  async ({ data: event, loading, error }) => {
    if (loading) return;
    if (error) {
      handleError(error);
      return;
    }
    if (!event) return;

    const rsvp = await event.createRSVP(AmityEventResponseStatus.Going);
    showSuccessMessage(rsvp?.status);
  },
);

unsubscribe();
```

```swift iOS theme={null}
token = AmityEventRepository().getEvent(id: "event-123").observe { eventObject, error in
    if let error {
        handleError(error)
        return
    }
    guard let event = eventObject.snapshot else { return }

    Task {
        do {
            let rsvp = try await event.createRSVP(status: .going)
            showSuccessMessage(rsvp.status.rawValue)
        } catch {
            handleError(error)
        }
    }
}
```

```kotlin Android theme={null}
AmitySocialClient.newEventRepository()
    .getEvent("event-123")
    .firstOrError()
    .flatMap { event: AmityEvent ->
        event.createRSVP(AmityEventResponseStatus.GOING)
    }
    .subscribe(
        { rsvp: AmityEventResponse -> showSuccessMessage(rsvp.getStatus()) },
        { error -> handleGeneralError(error) }
    )
```

## Update RSVP

Update an RSVP when a user changes their response. Use the same event object flow, but pass the new status to `updateRSVP`.

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

const unsubscribe = EventRepository.getEvent(
  'event-123',
  async ({ data: event, loading, error }) => {
    if (loading) return;
    if (error) {
      handleError(error);
      return;
    }
    if (!event) return;

    const rsvp = await event.updateRSVP(AmityEventResponseStatus.NotGoing);
    showSuccessMessage(rsvp?.status);
  },
);

unsubscribe();
```

```swift iOS theme={null}
token = AmityEventRepository().getEvent(id: "event-123").observe { eventObject, error in
    if let error {
        handleError(error)
        return
    }
    guard let event = eventObject.snapshot else { return }

    Task {
        do {
            let rsvp = try await event.updateRSVP(status: .notGoing)
            showSuccessMessage(rsvp.status.rawValue)
        } catch {
            handleError(error)
        }
    }
}
```

```kotlin Android theme={null}
AmitySocialClient.newEventRepository()
    .getEvent("event-123")
    .firstOrError()
    .flatMap { event: AmityEvent ->
        event.updateRSVP(AmityEventResponseStatus.NOT_GOING)
    }
    .subscribe(
        { rsvp: AmityEventResponse -> showSuccessMessage(rsvp.getStatus()) },
        { error -> handleGeneralError(error) }
    )
```

## Get My RSVP

Get the active user's RSVP for an event when the UI needs to show the current response before offering update actions.

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

const unsubscribe = EventRepository.getEvent(
  'event-123',
  async ({ data: event, loading, error }) => {
    if (loading) return;
    if (error) {
      handleError(error);
      return;
    }
    if (!event) return;

    const rsvp = await event.getMyRSVP();
    showSuccessMessage(rsvp?.status);
  },
);

unsubscribe();
```

```swift iOS theme={null}
token = AmityEventRepository().getEvent(id: "event-123").observe { eventObject, error in
    if let error {
        handleError(error)
        return
    }
    guard let event = eventObject.snapshot else { return }

    Task {
        do {
            let rsvp = try await event.getMyRSVP()
            showSuccessMessage(rsvp.status.rawValue)
        } catch {
            handleError(error)
        }
    }
}
```

```kotlin Android theme={null}
AmitySocialClient.newEventRepository()
    .getEvent("event-123")
    .firstOrError()
    .flatMap { event: AmityEvent ->
        event.getMyRSVP()
    }
    .subscribe(
        { rsvp: AmityEventResponse -> showSuccessMessage(rsvp.getStatus()) },
        { error -> handleGeneralError(error) }
    )
```

## Query RSVPs

Query RSVP responses when you need to render attendee lists, counts by status, or moderation views. Filter by status when the screen only needs one response group.

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

let rsvpUnsubscribe: Amity.Unsubscriber | undefined;

const unsubscribe = EventRepository.getEvent(
  'event-123',
  ({ data: event, loading, error }) => {
    if (loading) return;
    if (error) {
      handleError(error);
      return;
    }
    if (!event) return;

    rsvpUnsubscribe = event.getRSVPs(
      { status: AmityEventResponseStatus.Going },
      ({ data: responses, loading, error }) => {
        if (loading) return;
        if (error) {
          handleError(error);
          return;
        }

        renderResults(responses);
      },
    );
  },
);

rsvpUnsubscribe?.();
unsubscribe();
```

```swift iOS theme={null}
token = AmityEventRepository().getEvent(id: "event-123").observe { eventObject, error in
    if let error {
        handleError(error)
        return
    }
    guard let event = eventObject.snapshot else { return }

    token = event.getRSVPs(status: .going).observe { collection, error in
        if let error {
            handleError(error)
            return
        }

        showSuccessMessage(collection.snapshots.count)
    }
}
```

```kotlin Android theme={null}
AmitySocialClient.newEventRepository()
    .getEvent("event-123")
    .firstOrError()
    .flatMapPublisher { event: AmityEvent ->
        event.getRSVPs(AmityEventResponseStatus.GOING)
    }
    .subscribe(
        { pagingData: PagingData<AmityEventResponse> -> showSuccessMessage(pagingData) },
        { error -> handleGeneralError(error) }
    )
```

## Response Fields

`AmityEventResponse` includes the event ID, user ID, status, linked user when available, creation time, update time, and the time the user responded. Android also exposes an RSVP ID through `getRsvpId()`.

## Related Topics

> [card] [Create Event](/social-plus-sdk/social/events/create-event.md)
>
> Create the event before collecting RSVP responses.

> [card] [Manage Events](/social-plus-sdk/social/events/manage-events.md)
>
> Get and query event objects before calling RSVP methods.

> [card] [Events Overview](/social-plus-sdk/social/events/overview.md)
>
> Review event coverage, fields, and status values.


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