> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/ably/docs/llms.txt > Use this file to discover all available pages before exploring further. # Presence Presence enables you to track which clients are present on a channel, including their state and custom data. Each channel has a presence set containing all currently present members. ## Presence Object Access presence through a channel's `presence` property:


  ```javascript theme={null}
  const channel = realtime.channels.get('chat-room');
  const presence = channel.presence;
  ```

  ```python theme={null}
  channel = realtime.channels.get('chat-room')
  presence = channel.presence
  ```

## Properties Indicates whether the presence set is synchronized with the server. Returns `true` when sync is complete. ## Methods ### enter `enter(data?, callback?): Promise` Enter the presence set with optional data.


  ```javascript theme={null}
  // Enter without data
  await presence.enter();

  // Enter with data
  await presence.enter({
    status: 'online',
    name: 'Alice'
  });
  ```

  ```python theme={null}
  # Enter without data
  await presence.enter()

  # Enter with data
  await presence.enter({
      'status': 'online',
      'name': 'Alice'
  })
  ```

Optional data to associate with this member. Supported types: string, JSON object, binary data. Optional callback called on completion. Requirements: * Client must have a `clientId` configured * Client must have presence capability on the channel * Channel will be implicitly attached if not already ### update `update(data?, callback?): Promise` Update the data for this member without leaving and re-entering.


  ```javascript theme={null}
  await presence.update({
    status: 'away',
    lastSeen: Date.now()
  });
  ```

  ```python theme={null}
  await presence.update({
      'status': 'away',
      'lastSeen': time.time()
  })
  ```

New data to associate with this member. ### leave `leave(data?, callback?): Promise` Leave the presence set.


  ```javascript theme={null}
  // Leave without data
  await presence.leave();

  // Leave with data
  await presence.leave({
    reason: 'logged out'
  });
  ```

  ```python theme={null}
  # Leave without data
  await presence.leave()

  # Leave with data
  await presence.leave({
      'reason': 'logged out'
  })
  ```

Optional data emitted with the leave event. ### get `get(options?): Promise` Get the current presence set.


  ```javascript theme={null}
  const members = await presence.get();

  members.forEach(member => {
    console.log(member.clientId, member.data);
  });

  // Filter by clientId or connectionId
  const specificMember = await presence.get({
    clientId: 'user-123'
  });
  ```

  ```python theme={null}
  members = await presence.get()

  for member in members:
      print(member.client_id, member.data)

  # Filter by clientId or connectionId
  specific_member = await presence.get(
      client_id='user-123'
  )
  ```

Filter by specific client ID. Filter by specific connection ID. Wait for presence sync to complete before returning. ### subscribe `subscribe(action?, listener): Promise` Subscribe to presence events.


  ```javascript theme={null}
  // Subscribe to all presence events
  await presence.subscribe((presenceMessage) => {
    console.log(
      presenceMessage.action,
      presenceMessage.clientId,
      presenceMessage.data
    );
  });

  // Subscribe to specific action
  await presence.subscribe('enter', (presenceMessage) => {
    console.log(presenceMessage.clientId, 'entered');
  });

  // Subscribe to multiple actions
  await presence.subscribe(['enter', 'leave'], (presenceMessage) => {
    console.log(
      presenceMessage.clientId,
      presenceMessage.action
    );
  });
  ```

  ```python theme={null}
  # Subscribe to all presence events
  async def on_presence(presence_message):
      print(
          presence_message.action,
          presence_message.client_id,
          presence_message.data
      )

  await presence.subscribe(on_presence)

  # Subscribe to specific action
  async def on_enter(presence_message):
      print(presence_message.client_id, 'entered')

  await presence.subscribe('enter', on_enter)
  ```

Optional action(s) to filter events: `enter`, `leave`, `update`, or `present`. Callback function called for each presence event. ### unsubscribe `unsubscribe(action?, listener?): void` Unsubscribe from presence events.


  ```javascript theme={null}
  // Unsubscribe specific listener
  presence.unsubscribe('enter', myListener);

  // Unsubscribe all listeners for action
  presence.unsubscribe('enter');

  // Unsubscribe all listeners
  presence.unsubscribe();
  ```

### history `history(options?): Promise>` Retrieve presence event history.


  ```javascript theme={null}
  const result = await presence.history({
    limit: 50,
    direction: 'backwards'
  });

  result.items.forEach(event => {
    console.log(
      event.action,
      event.clientId,
      event.timestamp
    );
  });
  ```

  ```python theme={null}
  result = await presence.history(
      limit=50,
      direction='backwards'
  )

  for event in result.items:
      print(
          event.action,
          event.client_id,
          event.timestamp
      )
  ```

Start time in milliseconds since epoch. End time in milliseconds since epoch. Maximum number of events to return (max 1000). Query direction: `forwards` or `backwards`. ## PresenceMessage Presence messages contain: Presence action: `enter`, `leave`, `update`, or `present`. Client ID of the member. Connection ID of the member. Data associated with this member. Timestamp of the presence event. Unique event ID. ## Presence Actions Member entered the presence set. Member left the presence set. Member updated their data. Member was already present (sent during sync). ## Examples ### User Status Track user online status:


  ```javascript theme={null}
  // Enter presence when user logs in
  await presence.enter({
    status: 'online',
    username: 'alice'
  });

  // Update status
  await presence.update({
    status: 'away'
  });

  // Leave when user logs out
  await presence.leave();
  ```

### Display Active Users Show list of active users:


  ```javascript theme={null}
  // Get current users
  const members = await presence.get();
  updateUserList(members);

  // Subscribe to changes
  await presence.subscribe((presenceMsg) => {
    if (presenceMsg.action === 'enter') {
      addUserToList(presenceMsg);
    } else if (presenceMsg.action === 'leave') {
      removeUserFromList(presenceMsg);
    }
  });
  ```

### Typing Indicators Implement typing indicators:


  ```javascript theme={null}
  let typingTimeout;

  // User starts typing
  input.addEventListener('keydown', () => {
    presence.update({ typing: true });
    
    clearTimeout(typingTimeout);
    typingTimeout = setTimeout(() => {
      presence.update({ typing: false });
    }, 3000);
  });

  // Show who is typing
  await presence.subscribe('update', (msg) => {
    if (msg.data.typing) {
      showTypingIndicator(msg.clientId);
    } else {
      hideTypingIndicator(msg.clientId);
    }
  });
  ```

## Related Resources * [Presence Guide](/docs/presence-occupancy/presence) * [Channels API](/docs/api/realtime-sdk/channels) * [Occupancy](/docs/presence-occupancy/occupancy) * [Identified Clients](/docs/auth/identified-clients)