Note Events

​

Overview

​

Event Details

​

note.created

• When starting a live-voice note recording
• When creating a note from a recording file

​

note.deleted

• When a user permanently deletes a note

​

note.recording.completed (Recording paused)

• Fires after a live recording is paused and Tiro finishes processing the audio, transcript, and paragraphs captured so far
• Can fire multiple times for the same note because a recording can be paused more than once during a meeting
• The event name keeps completed for compatibility, but it does not mean the note has ended. Use note.ended for the final state

​

note.user_content.updated

• When a user manually edits the note content

​

note.ended

• Triggered when a note is completely finished (after all processing is complete)
• Fires only once per note lifecycle, unlike note.recording.completed, which can fire multiple times
• This is the definitive event for note completion
• Use this event when you need to know that a note has reached its final state

​

note.participants.updated

• Triggered when meeting participants are added or removed from a note
• Does not fire when an existing participant’s name or email is updated
• The resource field contains the full Note object with the updated participants array

​

Example Payload

​

Resource Data

​

Guide

​

Distinguish a paused recording from an ended note

• note.recording.completed means the recording was paused. Fetch fresh note data whenever you receive it
• note.ended fires once after the note is fully ended
• Subscribe to both events to handle interim results at each pause and the final result separately

1. Meeting starts → recording begins
2. Recording pauses → transcript and summary processing → note.recording.completed fires
3. Recording resumes → processing continues
4. Recording pauses → note.recording.completed fires again
5. Recording resumes and ends → note.ended fires

async function handleRecordingPaused(event) {
  const noteId = event.data.resourceId;
  const note = event.data.resource;
  const paragraphs = await fetchNoteParagraphs(noteId);

  processPausedNote(note, paragraphs);
}

async def handle_recording_paused(event):
    note_id = event['data']['resourceId']
    note = event['data']['resource']
    paragraphs = await fetch_note_paragraphs(note_id)

    process_paused_note(note, paragraphs)

func handleRecordingPaused(event WebhookEvent) error {
    noteID := event.Data.ResourceID
    note := event.Data.Resource

    paragraphs, err := fetchNoteParagraphs(noteID)
    if err != nil {
        return err
    }

    return processPausedNote(note, paragraphs)
}

suspend fun handleRecordingPaused(event: WebhookEvent) {
    val noteId = event.data.resourceId
    val note = event.data.resource
    val paragraphs = fetchNoteParagraphs(noteId)

    processPausedNote(note, paragraphs)
}