Daily room URL

Daily room token

Name of the bot in the room

Transport configuration parameters

Daily API endpoint URL

Daily API key for authentication

Enable audio output capabilities

Enable live audio streaming mode

Audio output sample rate in Hz

Number of audio output channels

Audio output bitrate in bits per second

Enable audio input capabilities

When enabled, incoming audio frames are pushed downstream

Audio input sample rate in Hz

Number of audio input channels

Audio filter for input processing. Supported filters are: KrispFilter() and NoisereduceFilter(). See the KrispFilter() reference docs and NoisereduceFilter() reference docs` for more information.

Enable video output capabilities

Enable live video streaming mode

Video output width in pixels

Video output height in pixels

Video output bitrate in bits per second

Video output frame rate

Video color format (RGB, BGR, etc.)

Voice Activity Detection analyzer. You can set this to either SileroVADAnalyzer() or WebRTCVADAnalyzer(). SileroVADAnalyzer is the recommended option. Learn more about the SileroVADAnalyzer.

Configuration for dial-in functionality

Enable real-time transcription

Configuration for transcription features

class DailyTranscriptionSettings(BaseModel):
  language: str = "en"                  # Default language
  model: str = "nova-2-general"         # Transcription model
  profanity_filter: bool = True         # Filter profanity
  redact: bool = False                  # Redact sensitive information
  endpointing: bool = True              # Enable speech endpointing
  punctuate: bool = True                # Add punctuation
  includeRawResponse: bool = True       # Include raw API response
  extra: Mapping[str, Any] = {
      "interim_results": True           # Provide any Deepgram-specific settings
  }

Called when the bot successfully joins the room.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing room join information

@transport.event_handler("on_joined")
async def on_joined(transport, data: Dict[str, Any]):
    logger.info(f"Joined room with data: {data}")

Called when the bot leaves the room.

Parameters:

• transport: The DailyTransport instance

@transport.event_handler("on_left")
async def on_left(transport):
    logger.info("Left room")

Called when the first participant joins the room. Useful for initializing conversations.

Parameters:

• transport: The DailyTransport instance
• participant: Dictionary containing participant information

@transport.event_handler("on_first_participant_joined")
async def on_first_participant_joined(transport, participant: Dict[str, Any]):
    await transport.capture_participant_transcription(participant["id"])
    await task.queue_frames([LLMMessagesFrame(initial_messages)])

Called when any participant joins the room.

Parameters:

• transport: The DailyTransport instance
• participant: Dictionary containing participant information

@transport.event_handler("on_participant_joined")
async def on_participant_joined(transport, participant: Dict[str, Any]):
    logger.info(f"Participant joined: {participant['id']}")

Called when a participant leaves the room.

Parameters:

• transport: The DailyTransport instance
• participant: Dictionary containing participant information
• reason: String describing why the participant left, “leftCall” | “hidden”

@transport.event_handler("on_participant_left")
async def on_participant_left(transport, participant: Dict[str, Any], reason: str):
    logger.info(f"Participant {participant['id']} left: {reason}")
    # Cancel the pipeline task to stop processing and remove the bot from the Daily room
    await task.cancel()

Event emitted when a participant is updated. This can mean either the participant’s metadata was updated, or the tracks belonging to the participant changed.

Parameters:

• transport: The DailyTransport instance
• participant: Dictionary containing updated participant information

@transport.event_handler("on_participant_updated")
async def on_participant_updated(transport, participant: Dict[str, Any]):
    logger.info(f"Participant updated: {participant}")

Event emitted when a custom app message is received from another participant or via the REST API.

Parameters:

• transport: The DailyTransport instance
• message: The message content (any type)
• sender: String identifier of the message sender

@transport.event_handler("on_app_message")
async def on_app_message(transport, message: Any, sender: str):
    logger.info(f"Message from {sender}: {message}")

Event emitted when the call state changes, normally as a consequence of joining or leaving the call.

Parameters:

• transport: The DailyTransport instance
• state: String representing the new call state. Learn more about call states.

@transport.event_handler("on_call_state_updated")
async def on_call_state_updated(transport, state: str):
    logger.info(f"Call state updated: {state}")

Event emitted when dial-in is ready. This happens after the room has connected to the SIP endpoint and the system is ready to receive dial-in calls.

Parameters:

• transport: The DailyTransport instance
• sip_endpoint: String containing the SIP endpoint information

@transport.event_handler("on_dialin_ready")
async def on_dialin_ready(transport, sip_endpoint: str):
    logger.info(f"Dial-in ready at: {sip_endpoint}")

Event emitted when the session with the dial-in remote end is established (i.e. SIP endpoint or PSTN are connectd to the Daily room).

Note: connected does not mean media (audio or video) has started flowing between the room and PSTN, it means the room received the connection request and both endpoints are negotiating the media flow.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing connection information. See DialinConnectedEvent.

@transport.event_handler("on_dialin_connected")
async def on_dialin_connected(transport, data: Any):
    logger.info(f"Dial-in connected: {data}")

Event emitted when the dial-in remote end disconnects the call.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing connection information. See DialinStoppedEvent.

@transport.event_handler("on_dialin_stopped")
async def on_dialin_stopped(transport, data: Any):
    logger.info(f"Dial-in stopped: {data}")

Event emitted in the case of dial-in errors which are fatal and the service cannot proceed. For example, an error in SDP negotiation is fatal to the media/SIP pipeline and will result in dialin-error being triggered.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing error information. See DialinEvent.

@transport.event_handler("on_dialin_error")
async def on_dialin_error(transport, data: Any):
    logger.error(f"Dial-in error: {data}")

Event emitted there is a dial-in non-fatal error, such as the selected codec not being used and a fallback codec being utilized.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing warning information. See DialinEvent.

@transport.event_handler("on_dialin_warning")
async def on_dialin_warning(transport, data: Any):
    logger.warning(f"Dial-in warning: {data}")

Event emitted when the session with the dial-out remote end is answered.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing call information. Learn more.

@transport.event_handler("on_dialout_answered")
async def on_dialout_answered(transport, data: Any):
    logger.info(f"Dial-out answered: {data}")

Event emitted when the session with the dial-out remote end is established.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing connection information. Learn more.

@transport.event_handler("on_dialout_connected")
async def on_dialout_connected(transport, data: Any):
    logger.info(f"Dial-out connected: {data}")

Event emitted when the dial-out session is stopped.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing connection information. Learn more.

@transport.event_handler("on_dialout_stopped")
async def on_dialout_stopped(transport, data: Any):
    logger.info(f"Dial-out stopped: {data}")

Event emitted in the case of dial-out errors which are fatal and the service cannot proceed. For example, an error in SDP negotiation is fatal to the media/SIP pipeline and will result in dialout-error being triggered.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing error information.Learn more.

@transport.event_handler("on_dialout_error")
async def on_dialout_error(transport, data: Any):
    logger.error(f"Dial-out error: {data}")

Event emitted there is a dial-out non-fatal error, such as the selected codec not being used and a fallback codec being utilized.

Parameters:

• transport: The DailyTransport instance
• data: Dictionary containing warning information. Learn more.

@transport.event_handler("on_dialout_warning")
async def on_dialout_warning(transport, data: Any):
    logger.warning(f"Dial-out warning: {data}")

Called when a transcription message is received. This includes both interim and final transcriptions.

Parameters:

• transport: The DailyTransport instance
• message: Dictionary containing transcription data including. Learn more.

@transport.event_handler("on_transcription_message")
async def on_transcription_message(transport, message: Dict[str, Any]):
    participant_id = message.get("participantId")
    text = message.get("text")
    is_final = message["rawResponse"]["is_final"]
    logger.info(f"Transcription from {participant_id}: {text} (final: {is_final})")

Called when a room recording starts successfully.

Parameters:

• transport: The DailyTransport instance
• status: Dictionary containing recording status information. Learn more.

@transport.event_handler("on_recording_started")
async def on_recording_started(transport, status: Dict[str, Any]):
    logger.info(f"Recording started with status: {status}")

Called when a room recording stops.

Parameters:

• transport: The DailyTransport instance
• stream_id: String identifier of the stopped recording stream

@transport.event_handler("on_recording_stopped")
async def on_recording_stopped(transport, stream_id: str):
    logger.info(f"Recording stopped for stream: {stream_id}")

Called when an error occurs during recording.

Parameters:

• transport: The DailyTransport instance
• stream_id: String identifier of the recording stream
• message: Error message describing what went wrong

@transport.event_handler("on_recording_error")
async def on_recording_error(transport, stream_id: str, message: str):
    logger.error(f"Recording error for stream {stream_id}: {message}")

Called when a transport error occurs.

Parameters:

• transport: The DailyTransport instance
• error: String containing error details

@transport.event_handler("on_error")
async def on_error(transport, error: str):
    logger.error(f"Transport error: {error}")

Raw audio data from participants

Video frames from participants

Audio data to be sent

Video frames to be sent

Returns a dictionary of all participants currently in the room.

def participants() -> Dict[str, Any]

See participants for more details.

Returns participant count statistics for the room.

def participant_counts() -> Dict[str, int]

See participant_counts for more details.

Sends a message to participants in the Daily room. Messages can be directed to all participants or targeted to a specific participant.

async def send_message(frame: TransportMessageFrame | TransportMessageUrgentFrame)

Parameters:

• frame: A transport message frame containing the message to send. Can be either:
  • TransportMessageFrame: Standard message
  • TransportMessageUrgentFrame: High-priority message

Message Structure:

Messages should conform to the expected format for the receiving system. For RTVI messages, use:

{
    "label": "rtvi-ai",        # Required for RTVI protocol
    "type": "message-type",    # Defines how the client will process it
    "id": "unique-id",         # Unique identifier for the message
    "data": {                  # Custom payload
        # Your custom data fields
    }
}

Example - Standard Message:

import uuid

# Send a standard message to all participants
message_data = {
    "label": "rtvi-ai",
    "type": "custom-message",
    "id": str(uuid.uuid4()),
    "data": {
        "message": "Hello everyone!",
        "timestamp": datetime.datetime.now().isoformat()
    }
}
await transport.send_message(TransportMessageFrame(message=message_data))

Example - Urgent Message to Specific Participant:

# Send urgent message to specific participant
urgent_data = {
    "label": "rtvi-ai",
    "type": "server-message",
    "id": str(uuid.uuid4()),
    "data": {
        "message": "Private message",
        "importance": "high"
    }
}
await transport.send_message(
    DailyTransportMessageUrgentFrame(
        message=urgent_data,
        participant_id="participant-123"
    )
)

The message will be delivered to:

• All participants if no specific participant_id is set
• Only the specified participant if participant_id is set
• Through the Daily app messaging system
• Can be received by registering an on_app_message handler

Sends an image frame to the room.

async def send_image(frame: OutputImageRawFrame | SpriteFrame) -> None

Parameters:

• frame: Image frame to send, either raw image data or sprite animation

Sends an audio frame to the room.

async def send_audio(frame: OutputAudioRawFrame) -> None

Parameters:

• frame: Audio frame to send

Starts capturing video from a specific participant.

async def capture_participant_video( participant_id: str, framerate: int = 30, video_source: str = "camera", color_format: str = "RGB" ) -> None

Parameters:

• participant_id: ID of the participant to capture
• framerate: Target frame rate (default: 30)
• video_source: Video source type (default: “camera”)
• color_format: Color format of the video (default: “RGB”)

Starts capturing and transcribing audio from a specific participant.

async def capture_participant_transcription(participant_id: str) -> None

Parameters:

• participant_id: ID of the participant to transcribe

Updates the transcription configuration for specific participants or instances.

async def update_transcription(
   participants: List[str] | None = None,
   instance_id: str | None = None
) -> None

Parameters:

• participants: Optional list of participant IDs to transcribe. If None, transcribes all participants.
• instance_id: Optional specific transcription instance ID to update

Example:

# Update transcription for specific participants
await transport.update_transcription(participants=["participant-123", "participant-456"])
# Update specific transcription instance
await transport.update_transcription(instance_id="transcription-789")

Starts recording the room session.

async def start_recording( streaming_settings: Dict = None, stream_id: str = None, force_new: bool = None ) -> None

Parameters:

• streaming_settings: Recording configuration settings
• stream_id: Optional stream identifier
• force_new: Force start a new recording

See start_recording for more details.

Stops an active recording.

async def stop_recording(stream_id: str = None) -> None

Parameters:

• stream_id: Optional stream identifier to stop specific recording

See stop_recording for more details.

Initiates a dial-out call.

async def start_dialout(settings: Dict = None) -> None

Parameters:

• settings: Dial-out configuration settings

See start_dialout for more details.

Stops an active dial-out call.

async def stop_dialout(participant_id: str) -> None

Parameters:

• participant_id: ID of the participant to disconnect

See stop_dialout for more details.

Sends DTMF tones in an existing dial-out session.

async def send_dtmf(settings: Dict = None) -> None

Parameters:

• settings: DTMF settings

See send_dtmf for more details.

Updates subscriptions and subscription profiles. This function allows you to update subscription profiles and at the same time assign specific subscription profiles to a participant and even change specific settings for some participants.

async def update_subscriptions( participant_settings: Dict = None, profile_settings: Dict = None ) -> None

Parameters:

• participant_settings: Per-participant subscription settings
• profile_settings: Global subscription profile settings

See update_subscriptions for more details.

Updates permissions and settings for specific participants in the room.

async def update_remote_participants(remote_participants: Mapping[str, Any] = None) -> None

Parameters:

• remote_participants: Dictionary mapping participant IDs to their updated settings

This method allows fine-grained control over participant capabilities and permissions in the Daily room.

Examples:

# Mute a participant's microphone
await transport.update_remote_participants({
    "participant-123": {
        "inputsEnabled": {
            "microphone": False
        }
    }
})

# Revoke send permissions (mutes the participant and prevents them from unmuting)
await transport.update_remote_participants({
    "participant-123": {
        "permissions": {
            "canSend": []  # Empty list revokes all send permissions
        }
    }
})

# Configure selective audio routing
await transport.update_remote_participants({
    "participant-123": { # the customer
        "permissions": {
            "canReceive": {
                "base": False,  # Don't receive from anyone by default
                "byUserId": {
                    "hold-music": True # Only receive from hold music player
                }
            }
        }
    }
})

# Set up user-to-user permissions mapping (e.g., when transferring calls)
# Assumes customer was previously unable to hear anyone (they were on hold) and agent was speaking to bot
await transport.update_remote_participants({
    "participant-123": { # the customer
        "permissions": {
            "base": False,
            "canReceive": {"byUserId": {"agent": True}}
        }
    },
    "participant-456": { # the agent
        "permissions": {
            "base": False,
            "canReceive": {"byUserId": {"customer": True}}
        }
    }
})

# Promote a participant to be a participant admin
await transport.update_remote_participants({
    "participant-123": {
        "permissions": {
            "canAdmin": ["participants"]
        }
    }
})

Permissions Settings:

For comprehensive details on permissions settings, see the Daily API documentation:

• daily-python’s update_remote_participants() documentation
• daily-js’s updateParticipant()->updatePermission and participants().permissions

When testing with Daily Prebuilt, you can send messages to the Prebuilt chat using this method.

Parameters:

• message (str): The chat message to send
• user_name (str): The name of the user sending the message

See send_prebuilt_chat_message for more details.

Returns the transport’s participant ID in the room.

Returns the transport’s room URL for the room currently in use.