> ## Documentation Index
> Fetch the complete documentation index at: https://social-b97141fb-feat-user-history-moderation-detail.mintlify.site/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>


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