> ## Documentation Index
> Fetch the complete documentation index at: https://replyke-feat-push-rich-payload-fields.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Events
> Create and manage events, RSVPs, hosts, and invites from the server
The `events` module covers the full events surface: creating and editing events, the RSVP lifecycle, host and invite management, and the guest list. It maps directly to the [Events API](/api-reference/events/create-event).
Because the Node SDK authenticates with a **service key** (it acts as the whole project, not a single end user), most write functions take an explicit `userId` naming the user the action is performed as. For host- and invite-management functions, `userId` is instead the **target** user (the host/invitee), and the action is authorized as the project.
**Image upload caveat.** The Node SDK does not support inline cover/gallery
upload on `createEvent`/`updateEvent` yet. Create the event first, then attach
images with [`sublay.storage.uploadImage`](/v7/node-sdk/storage) using its
`eventId` parameter. (The browser [JS SDK](/v7/js-sdk/events) and the
[React SDK](/sdk/events/overview) do support inline upload.)
Requires the `events` bundle. Space-scoping needs the `spaces` bundle; images need `files-images`; notifications need `notifications`.
***
### createEvent
Creates an event. The `userId` you pass becomes the creator and is auto-added to `hostIds`. Returns the event with inline `rsvpCounts`.
```typescript theme={null}
const event = await sublay.events.createEvent({
userId: "usr_abc123",
title: "Launch Party",
type: "physical",
startTime: "2026-09-01T18:00:00.000Z",
endTime: "2026-09-01T22:00:00.000Z",
timezone: "America/New_York",
venueName: "The Loft",
address: "123 Main St, New York, NY",
location: { latitude: 40.7128, longitude: -74.006 },
capacity: 100,
visibility: "public",
});
```
Event title. 1–300 characters.
ISO datetime when the event starts.
Event format. `online` requires `url`; `physical` requires `address` or `location`; `hybrid` requires both.
The user to create the event as (creator + first host). With a service key this may be any user.
Optional description.
Optional ISO end datetime.
Optional IANA timezone.
Join/stream URL.
Venue name.
Street address.
Coordinates for proximity search.
Scope the event to a space. Required when `visibility` is `"members"`.
Defaults to `"public"`.
Max `going` RSVPs. Omit for unlimited.
Allow `"maybe"` RSVPs. Defaults to `true`.
Expose the named guest list to non-hosts. Defaults to `true`.
Additional host user IDs (the creator is always added).
Arbitrary key-value data. Up to 1 MB.
**Returns** — `Promise`
***
### fetchEvent
Fetches a single event by ID. Pass `userId` to resolve visibility for that user and to populate `userRsvp` (with the `userRsvp` include).
```typescript theme={null}
const event = await sublay.events.fetchEvent({
eventId: "evt_abc123",
include: "user,space,files,userRsvp",
userId: "usr_abc123",
});
```
The event ID.
Comma-separated associations: `"user"`, `"space"`, `"files"`, `"userRsvp"`.
The requester id, for visibility resolution and `userRsvp` enrichment.
**Returns** — `Promise`
***
### fetchManyEvents
Lists events with visibility enforced, plus filtering, sorting, geo, and free-text search. Pass `userId` to resolve member/invite/host visibility and to use the `myRsvp` filter.
```typescript theme={null}
const { data, pagination } = await sublay.events.fetchManyEvents({
timeWindow: "upcoming",
sortBy: "startTime",
sortDir: "asc",
type: "physical",
page: 1,
limit: 20,
userId: "usr_abc123",
include: "user,userRsvp",
});
```
Page number (1-indexed). Defaults to `1`.
Results per page. Capped at `100`.
Sort field. Defaults to `"startTime"`.
Sort direction. Defaults to `"asc"`.
Derived time window.
ISO datetime lower bound on `startTime`.
ISO datetime upper bound on `startTime`.
Restrict to one space.
Only events this user hosts.
Filter by type.
Defaults to `"active"`.
Comma-separated statuses the requester RSVP'd with, e.g. `"going,maybe"`. Requires `userId`.
Proximity filter (radius in meters).
Free-text filter on `title`.
Free-text filter on `description`.
Comma-separated associations.
The requester id (visibility + `myRsvp` + `userRsvp`).
**Returns** — `Promise>`
***
### updateEvent
Edits an event's mutable fields. Host-only at the API level; with a service key the call is authorized as the project. `hostIds`, `status`, and `spaceId` are not editable here.
```typescript theme={null}
const event = await sublay.events.updateEvent({
eventId: "evt_abc123",
capacity: 150,
description: "Now with more space!",
});
```
The event ID.
New title.
New description.
New ISO start datetime.
New ISO end datetime.
New timezone.
New type (re-validates location fields).
New URL.
New venue name.
New address.
New coordinates.
New visibility.
New capacity.
Allow `"maybe"` RSVPs.
Expose the guest list.
New metadata.
**Returns** — `Promise`
***
### cancelEvent
Cancels an event (sets `status: "cancelled"`). The event stays fetchable but rejects new RSVPs.
```typescript theme={null}
const event = await sublay.events.cancelEvent({ eventId: "evt_abc123" });
```
The event ID.
**Returns** — `Promise`
***
### deleteEvent
Permanently (or soft-, per the project's `eventDeletion` settings) deletes an event and cleans up its RSVPs and invites.
```typescript theme={null}
await sublay.events.deleteEvent({ eventId: "evt_abc123" });
```
The event ID.
**Returns** — `Promise`
***
### setRsvp
Sets or changes a user's RSVP. Transitions into `going` are capacity-checked.
```typescript theme={null}
const event = await sublay.events.setRsvp({
eventId: "evt_abc123",
status: "going",
userId: "usr_abc123",
});
```
The event ID.
The RSVP response.
The user to RSVP as. With a service key this may be any user.
**Returns** — `Promise` (with refreshed `rsvpCounts`)
***
### withdrawRsvp
Removes a user's RSVP. Idempotent.
```typescript theme={null}
const event = await sublay.events.withdrawRsvp({
eventId: "evt_abc123",
userId: "usr_abc123",
});
```
The event ID.
The user to withdraw. With a service key this may be any user.
**Returns** — `Promise`
***
### addHost
Grants a user host privileges. The `userId` is the **target** host; the action is authorized as the project.
```typescript theme={null}
const event = await sublay.events.addHost({
eventId: "evt_abc123",
userId: "usr_cohost",
});
```
The event ID.
The user to grant host on the event.
**Returns** — `Promise`
***
### removeHost
Revokes a user's host privileges. Rejected if it would leave the event with no hosts.
```typescript theme={null}
const event = await sublay.events.removeHost({
eventId: "evt_abc123",
userId: "usr_cohost",
});
```
The event ID.
The host to remove.
**Returns** — `Promise`
***
### addInvite
Invites a user to the event. Idempotent. The `userId` is the **target** invitee.
```typescript theme={null}
const event = await sublay.events.addInvite({
eventId: "evt_abc123",
userId: "usr_guest",
});
```
The event ID.
The user to invite (userId only — never a foreign ID).
**Returns** — `Promise`
***
### removeInvite
Removes a user's invite, revoking their access and dropping their RSVP.
```typescript theme={null}
const event = await sublay.events.removeInvite({
eventId: "evt_abc123",
userId: "usr_guest",
});
```
The event ID.
The invitee to remove.
**Returns** — `Promise`
***
### fetchInvitees
Host-only invitee (guest) list. Returns paginated [EventInvite](/data-models/event-invite) records with the invited user populated.
```typescript theme={null}
const { data, pagination } = await sublay.events.fetchInvitees({
eventId: "evt_abc123",
page: 1,
limit: 20,
});
```
The event ID.
Page number (1-indexed).
Results per page. Capped at `100`.
**Returns** — `Promise>`
***
### fetchEventRsvps
Named RSVP (guest) list. Returns paginated [EventRsvp](/data-models/event-rsvp) records with the user populated. Visible to hosts always, to any viewer when `guestListVisible` is `true`, or to service keys. RSVP counts themselves are public via the event's `rsvpCounts`.
```typescript theme={null}
const { data, pagination } = await sublay.events.fetchEventRsvps({
eventId: "evt_abc123",
status: "going,maybe",
page: 1,
limit: 20,
});
```
The event ID.
Comma-separated statuses to filter by, e.g. `"going,maybe"`. Omit for all.
Page number (1-indexed).
Results per page. Capped at `100`.
**Returns** — `Promise>`
***
## Attaching images
Create the event, then upload a cover or gallery image and associate it with `eventId`:
```typescript theme={null}
import { readFile } from "node:fs/promises";
const event = await sublay.events.createEvent({
userId: "usr_abc123",
title: "Launch Party",
type: "online",
url: "https://meet.example.com/launch",
startTime: "2026-09-01T18:00:00.000Z",
});
const buffer = await readFile("./cover.jpg");
await sublay.storage.uploadImage({
file: new Uint8Array(buffer),
filename: "cover.jpg",
mimeType: "image/jpeg",
imageOptions: { mode: "original-aspect", sizes: { full: 1600 }, format: "webp" },
eventId: event.id,
userId: "usr_abc123",
});
```
Uploading via `storage.uploadImage` attaches a gallery image (a `File` with the
event's `eventId`). Setting it as the event's single cover (`coverImageId`) is
done by the inline-upload path, which the Node SDK does not yet expose.