Calculate Talk Time Analytics

Analyzing the talk time of participants in a classroom, meeting, or phone call can help you improve participant engagement, sales presentations and support response. Using Deepgram’s speech-to-text API with diarization, you can gather the data you need to make informed decisions about your organization’s interactions.

Before You Begin

The example provided is written in Node.js, and you can find the code on GitHub.

Before you run the code, you’ll need to do a few things:

Create a Deepgram API Key

To access Deepgram’s API, you’ll need to create a Deepgram API Key. Make note of your API Key; you will need it later.

Getting Started

You can run this application by running it on your local computer.

Configure the Settings

Your application will need to know more about you before it can run successfully. Edit the environment variables (.env) to reflect the settings you want to use:

• PORT: The port on which you want to run the application. We generally set this to port 3000.
• DG_KEY: The API Key you created earlier in this tutorial.

Once these variables are set, the application should run automatically.

Run on localhost

To run this project on your local computer you will need to clone the repository, configure the settings, install the dependencies, and start the server.

Clone the Repository

Either clone or download theGitHub repository to your local machine in a new directory:

$
# Clone this repo
>
git clone https://github.com/deepgram-devs/talk-time-analytics.git
>
>
# Move to the created directory
>
cd talk-time-analytics

Configure the Settings

Your application will need to know more about you before it can run. Copy the .env-example file into a new file named .env, and edit the new file to reflect the settings you want to use:

• PORT: The port on which you want to run the application. You can leave this as port 3000.
• DG_KEY: The API Key you created earlier in this tutorial.

Install the Dependencies

In the directory where you downloaded the code, run the following command to bring in the dependencies needed for this project:

$
npm install

Start the Server

Now that you have configured your application and put the dependencies in place, your application is ready to go! Run it with:

$
npm start

By default, the application runs on port 3000, which means you can access it at <http://localhost:3000>.

Code Walk-through

The application is an Express app that uses Chart.js to create a pie chart that displays calculated talk time. The key logic that calculates talk time lives in the server.js file.

Sending Data to the Deepgram API

When a user uploads a file, we call the requestDeepgramAPI function. This function calls the Deepgram API via an https request. The key parameter on this request is diarize=true. This parameter tells the Deepgram API to recognize speaker changes. When activated, the Deepgram API will assign a zero-based speaker index to each word in the transcript.

1
function requestDeepgramAPI({ res, filename, fileUrl, contentType, payload }) {
2
  try {
3
    const deepgram = new Deepgram(DG_KEY)
4
    let audioObj
5
6
    if (typeof payload === 'string') {
7
      audioObj = { url: fileUrl }
8
    } else {
9
      audioObj = { buffer: payload, mimetype: contentType }
10
    }
11
12
    const transcription = await deepgram.transcription.preRecorded(audioObj, {
13
      punctuate: true,
14
      diarize: true,
15
    })
16
17
    const speakers = computeSpeakingTime(transcription)
18
    res.render('analytics.ejs', {
19
      speakers,
20
      filename,
21
      fileUrl,
22
    })
23
  } catch (err) {
24
    error(res, err)
25
  }
26
}

Calculating Talk Time

Once the response is returned from the Deepgram API, we pass the transcript data to the computeSpeakingTime function. In that function, we create a new Map<number, number> named timePerSpeaker.

The Deepgram API specifies the start, end, and duration of each word identifies. That information, paired with the indexed speaker returned by the diarization feature of the API, allows us to iterate through each word calculating the full length of time that speaker spoke.

1
function computeSpeakingTime(transcript) {
2
	const words = transcript.results.channels[0].alternatives[0].words;
3
4
	if (words.length === 0) {
5
		return [];
6
	}
7
8
	// `timePerSpeaker` tracks speaker time. Keys
9
	// are speaker ID; values are speaking time.
10
	const timePerSpeaker = new Map();
11
	let wordAtLastSpeakerChange = words.shift();
12
	for (const word of words) {
13
		// If the speaker changes at this word
14
		if (wordAtLastSpeakerChange.speaker !== word.speaker) {
15
			addSpeakingTime(wordAtLastSpeakerChange.speaker, word.end - wordAtLastSpeakerChange.start, timePerSpeaker);
16
			wordAtLastSpeakerChange = word;
17
		}
18
	}
19
20
	const lastWord = words[words.length - 1];
21
	addSpeakingTime(wordAtLastSpeakerChange.speaker, lastWord.end - wordAtLastSpeakerChange.start, timePerSpeaker);
22
23
	return (
24
		// Convert the Map into an array
25
		[...timePerSpeaker.entries()]
26
			// Sort by speaker ID (keys of the Map)
27
			.sort((entryA, entryB) => entryA[0] - entryB[0])
28
			// Only keep the speaking times (the values of the Map)
29
			.map((entry) => entry[1])
30
	);
31
}
32
33
function addSpeakingTime(speaker, duration, timePerSpeaker) {
34
	const currentSpeakerDuration = timePerSpeaker.get(speaker) || 0;
35
	timePerSpeaker.set(speaker, currentSpeakerDuration + duration);
36
}