> ## 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.

# 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.

<Info>
  Flutter does not currently expose public scheduled-event RSVP APIs in the SDK source reviewed for this page.
</Info>

## 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.

<CodeGroup>
  ```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) }
      )
  ```
</CodeGroup>

## Update RSVP

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

<CodeGroup>
  ```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) }
      )
  ```
</CodeGroup>

## 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.

<CodeGroup>
  ```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) }
      )
  ```
</CodeGroup>

## 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.

<CodeGroup>
  ```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) }
      )
  ```
</CodeGroup>

## 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

<CardGroup cols={3}>
  <Card title="Create Event" href="./create-event" icon="calendar-plus">
    Create the event before collecting RSVP responses.
  </Card>

  <Card title="Manage Events" href="./manage-events" icon="calendar-days">
    Get and query event objects before calling RSVP methods.
  </Card>

  <Card title="Events Overview" href="./overview" icon="calendar">
    Review event coverage, fields, and status values.
  </Card>
</CardGroup>