Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/jitsi/lib-jitsi-meet/llms.txt

Use this file to discover all available pages before exploring further.

Conference errors that can occur when joining, managing, or participating in Jitsi conferences.

​
Error Constants

​
AUTHENTICATION_REQUIRED

Value: conference.authenticationRequired Cause: Client must be authenticated to create the conference. When it occurs:
  • Conference requires authenticated users
  • Token-based authentication is enabled but not provided
  • JWT authentication is required
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.AUTHENTICATION_REQUIRED) {
    // Redirect to authentication flow
    window.location.href = '/login?redirect=' + encodeURIComponent(roomName);
  }
});

​
CHAT_ERROR

Value: conference.chatError Cause: An error occurred in chat functionality. When it occurs:
  • Chat message fails to send
  • XMPP MUC chat errors
  • Message validation failures
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_ERROR, (error, ...params) => {
  if (error === JitsiConferenceErrors.CHAT_ERROR) {
    console.warn('Chat error occurred:', params);
    // Notify user that message may not have been delivered
    showChatErrorNotification();
  }
});

​
CONFERENCE_ACCESS_DENIED

Value: conference.connectionError.accessDenied Cause: Access to the room was denied after joining a lobby room. When it occurs:
  • Moderators reject entry from lobby
  • User is explicitly denied access
  • Access control rules prevent entry
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED) {
    // Inform user they were denied access
    showNotification('Access denied by moderator.');
    // Leave the lobby and redirect
    room.leave().then(() => redirectToHomePage());
  }
});

​
CONFERENCE_DESTROYED

Value: conference.destroyed Cause: Conference has been destroyed. When it occurs:
  • All participants have left
  • Conference was explicitly terminated
  • Server shutdown the conference
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.CONFERENCE_DESTROYED) {
    // Clean up and notify user
    console.info('Conference has ended.');
    cleanupResources();
    showEndOfConferenceMessage();
  }
});

​
CONFERENCE_MAX_USERS

Value: conference.max_users Cause: Maximum users limit has been reached. When it occurs:
  • Conference has reached participant capacity
  • Server-side user limits enforced
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.CONFERENCE_MAX_USERS) {
    // Inform user conference is full
    showNotification('Conference is full. Please try again later.');
    // Optionally offer to join waiting list
  }
});

​
CONNECTION_ERROR

Value: conference.connectionError Cause: A connection error occurred when trying to join a conference. When it occurs:
  • Network connectivity issues
  • XMPP connection problems
  • WebSocket/BOSH transport failures
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.CONNECTION_ERROR) {
    // Attempt reconnection
    console.error('Failed to connect to conference.');
    retryJoinWithBackoff();
  }
});

​
DISPLAY_NAME_REQUIRED

Value: conference.display_name_required Cause: Display name is required when joining the room (common in lobby scenarios). When it occurs:
  • Lobby is enabled and requires display names
  • Conference settings mandate participant names
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error, ...params) => {
  if (error === JitsiConferenceErrors.DISPLAY_NAME_REQUIRED) {
    const lobbyEnabled = params[0]; // boolean indicating if lobby is enabled
    // Prompt user for display name
    const displayName = await promptForDisplayName();
    room.setDisplayName(displayName);
    room.join();
  }
});

​
FOCUS_DISCONNECTED

Value: conference.focusDisconnected Cause: Focus (jicofo) error occurred. When it occurs:
  • Jicofo service becomes unavailable
  • Connection to focus component lost
  • Conference orchestration failures
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.FOCUS_DISCONNECTED) {
    // Wait for focus to reconnect or rejoin
    console.warn('Focus disconnected. Attempting to rejoin...');
    setTimeout(() => rejoinConference(), 3000);
  }
});

​
FOCUS_LEFT

Value: conference.focusLeft Cause: Focus component left the conference. When it occurs:
  • Jicofo intentionally left the conference
  • Conference is shutting down gracefully
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.FOCUS_LEFT) {
    // Conference is ending
    console.info('Conference is ending (focus left).');
    cleanupAndExit();
  }
});

​
GRACEFUL_SHUTDOWN

Value: conference.gracefulShutdown Cause: Graceful shutdown is happening. When it occurs:
  • Server maintenance scheduled
  • Infrastructure upgrade in progress
  • Conference being migrated
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.GRACEFUL_SHUTDOWN) {
    // Notify user of planned shutdown
    showNotification('Server maintenance in progress. Please rejoin.');
    // Implement reconnection after brief delay
    setTimeout(() => reconnect(), 5000);
  }
});

​
ICE_FAILED

Value: conference.iceFailed Cause: The media connection (ICE) has failed. When it occurs:
  • WebRTC peer connection cannot establish
  • Firewall blocking UDP/TCP media ports
  • TURN server unavailable or misconfigured
  • Network address translation (NAT) issues
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.ICE_FAILED) {
    // Media connection failed - check network/firewall
    console.error('Media connection failed (ICE failure).');
    showNetworkDiagnostics();
    // Suggest checking firewall settings or using different network
  }
});

​
INCOMPATIBLE_SERVER_VERSIONS

Value: conference.incompatible_server_versions Cause: Server-side component versions are incompatible with the client. When it occurs:
  • Client library version doesn’t match server expectations
  • Server components out of sync
  • Major version mismatch
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.INCOMPATIBLE_SERVER_VERSIONS) {
    // Client needs to be updated
    console.error('Client version incompatible with server.');
    showUpdateRequiredMessage();
    // Force page reload to get latest client version
    setTimeout(() => window.location.reload(true), 2000);
  }
});

​
MEMBERS_ONLY_ERROR

Value: conference.connectionError.membersOnly Cause: Connection error due to members-only restriction (only approved members allowed). When it occurs:
  • Conference is restricted to specific members
  • User is not on the approved members list
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.MEMBERS_ONLY_ERROR) {
    // User is not an approved member
    showNotification('This conference is restricted to members only.');
    redirectToHomePage();
  }
});

​
NOT_ALLOWED_ERROR

Value: conference.connectionError.notAllowed Cause: Connection error due to not being allowed to join. When it occurs:
  • Various authorization failures (see AUTH_ERROR_TYPES)
  • Room creation restrictions
  • Authentication requirements not met
  • Visitor lobby restrictions
Additional context via AUTH_ERROR_TYPES:
  • GENERAL - General authorization failure
  • NO_MAIN_PARTICIPANTS - No main participants available
  • NO_VISITORS_LOBBY - Visitors not allowed in lobby
  • PROMOTION_NOT_ALLOWED - Promotion from visitor not allowed
  • ROOM_CREATION_RESTRICTION - Room creation is restricted
  • ROOM_UNAUTHENTICATED_ACCESS_DISABLED - Authentication required
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error, ...params) => {
  if (error === JitsiConferenceErrors.NOT_ALLOWED_ERROR) {
    const authErrorType = params[0]; // AUTH_ERROR_TYPES value
    
    switch (authErrorType) {
      case 'authentication-required':
        redirectToLogin();
        break;
      case 'room-creation-restriction':
        showNotification('You do not have permission to create rooms.');
        break;
      default:
        showNotification('You are not allowed to join this conference.');
    }
  }
});

​
OFFER_ANSWER_FAILED

Value: conference.offerAnswerFailed Cause: WebRTC offer/answer negotiation failed. When it occurs:
  • SDP negotiation failures
  • Codec mismatch between peers
  • Media capability incompatibilities
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.OFFER_ANSWER_FAILED) {
    // WebRTC negotiation failed
    console.error('Failed to negotiate media connection.');
    // Retry joining the conference
    retryJoin();
  }
});

​
PASSWORD_NOT_SUPPORTED

Value: conference.passwordNotSupported Cause: Password cannot be set for this conference. When it occurs:
  • Server doesn’t support password-protected rooms
  • Configuration prevents password usage
Handling recommendations: 
try {
  await room.lock(password);
} catch (error) {
  if (error === JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED) {
    showNotification('Password protection is not available.');
  }
}

​
PASSWORD_REQUIRED

Value: conference.passwordRequired Cause: A password is required to join the conference. When it occurs:
  • Conference room is password-protected
  • Joining without password credentials
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.PASSWORD_REQUIRED) {
    // Prompt for password and rejoin
    const password = await promptForPassword();
    room.join(password);
  }
});

​
RESERVATION_ERROR

Value: conference.reservationError Cause: Reservation system returned an error. When it occurs:
  • Conference reservation failed
  • Booking system integration issues
  • Reservation conflicts or validation failures
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.RESERVATION_ERROR) {
    console.error('Conference reservation failed.');
    showNotification('Unable to reserve conference. Please try again.');
  }
});

​
SETTINGS_ERROR

Value: conference.settingsError Cause: A settings error occurred. When it occurs:
  • Invalid conference settings
  • Configuration validation failures
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_ERROR, (error) => {
  if (error === JitsiConferenceErrors.SETTINGS_ERROR) {
    console.warn('Conference settings error.');
    // Review and fix settings
  }
});

​
VIDEOBRIDGE_NOT_AVAILABLE

Value: conference.videobridgeNotAvailable Cause: No available videobridge to handle the conference. When it occurs:
  • All videobridges are at capacity
  • Videobridge services are down
  • Infrastructure scaling issues
Handling recommendations: 
room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error) => {
  if (error === JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE) {
    console.error('No videobridge available.');
    showNotification('Service is at capacity. Please try again shortly.');
    // Implement retry with exponential backoff
    scheduleRetry();
  }
});

​
Usage Example

import { JitsiConferenceErrors, JitsiConferenceEvents } from 'lib-jitsi-meet';

room.on(JitsiConferenceEvents.CONFERENCE_FAILED, (error, ...params) => {
  console.error('Conference failed:', error, params);
  
  switch (error) {
    case JitsiConferenceErrors.AUTHENTICATION_REQUIRED:
      handleAuthRequired();
      break;
    case JitsiConferenceErrors.PASSWORD_REQUIRED:
      handlePasswordRequired();
      break;
    case JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED:
      handleAccessDenied();
      break;
    case JitsiConferenceErrors.CONFERENCE_MAX_USERS:
      handleConferenceFull();
      break;
    case JitsiConferenceErrors.ICE_FAILED:
      handleMediaConnectionFailure();
      break;
    default:
      handleGenericConferenceError(error, params);
  }
});

​
AUTH_ERROR_TYPES

Additional error type information for NOT_ALLOWED_ERROR: 
export enum AUTH_ERROR_TYPES {
  GENERAL = 'general',
  NO_MAIN_PARTICIPANTS = 'no-main-participants',
  NO_VISITORS_LOBBY = 'no-visitors-lobby',
  PROMOTION_NOT_ALLOWED = 'promotion-not-allowed',
  ROOM_CREATION_RESTRICTION = 'room-creation-restriction',
  ROOM_UNAUTHENTICATED_ACCESS_DISABLED = 'authentication-required'
}

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us