Easily Extract Insights From Meeting Audio With Recall.ai’s Rev Integration

Rev’s thrilled to announce our new partnership with Recall.ai, a unified API to send meeting bots to video conferencing platforms like Zoom, Google Meet, Microsoft Teams, and more. By providing one simple API that integrates with multiple meeting platforms, developers save months of engineering work as there is no need to build out each individual integration. 

Rev AI lets you add transcript functionality to your app in moments vs. months by generating highly-accurate ASR transcripts from uploaded audio or video files. You can also add real-time transcription as audio or video is live-streamed.

Through the Rev AI integration, you’ll get industry-leading speech-to-text on the audio data that Recall.ai extracts from meetings — without needing to write any extra code. 

Learn how to seamlessly set up the integration by following the steps below. 

Creating a Sample Note Taking app with Recall.ai

Let’s build a sample application with the Recall.ai and Rev AI integration to demonstrate how the integration works. We’ll be building a simple app that receives the real-time audio from a Zoom call, and produces real-time transcription from Rev AI.

Getting Set Up

To get started, we need a Rev AI account and Recall.ai account. If you don’t have a Rev AI account, you can sign up for free here. If you don’t have a Recall.ai account, you can get started here. After you’ve created your accounts, generate a Rev AI API key and paste it into the Recall.ai dashboard. Recall.ai will call Rev AI on your behalf by using this key.

Setting up Ngrok

We’ll be receiving the Rev AI transcription in real-time over webhook, so let’s use Ngrok to provide a public URL we can send webhooks to. Ngrok will forward the webhooks to your local server. If you don’t have an Ngrok account, you can sign up for one here. Once you have Ngrok installed, run the following command:

ngrok http 5000

Take note of the “Forwarding” URL (in the example code below referred to as SERVER_URL) that appears in your terminal. All requests to that URL will be forwarded to localhost:5000.

Setting Up a Web Server

We’ll set up a simple web server using Flask:

Paste the following code into a file called app.py.

import os

from urllib.parse import urljoin

import requests

from flask import Flask, render_template, request, url_for, redirect

RECALLAI_API_KEY = os.environ[‘RECALLAI_API_KEY’]

SERVER_URL = os.environ[‘SERVER_URL’]

transcript_parts = []

app = Flask(__name__)

@app.route(“/send_bot_to_call”)

def send_bot_to_call():

    global bot_id

    zoom_url = request.args.get(“zoom_url”)

    if not zoom_url:

        return “zoom_url parameter is required”, 400

    resp = requests.post(

        “https://api.recall.ai/api/v1/bot/”,

        json={

            “meeting_url”: zoom_url,

            “real_time_transcription”: {

                “destination_url”: urljoin(SERVER_URL, url_for(“transcript_webhook”))

            },

            “transcription_options”: {

                “provider”: “rev”

            },

        },

        headers={ 

            “Content-Type”: “application/json”,

            “Authorization”: f”Token {RECALLAI_API_KEY}” 

        }

    )

    if not resp.ok:

        return f”Error from Recall: {str(resp.json())}”, 400

    return redirect(url_for(“transcript”))

@app.route(“/transcript”)

def transcript():

    global transcript_parts

    formatted_transcript = []

    for p in transcript_parts:

        formatted_transcript.append({

            “speaker”: p[‘speaker’],

            “text”: ‘ ‘.join(w[‘text’] for w in p[‘words’])

        })

    return render_template(

        ‘transcript_view.html’,

        formatted_transcript=formatted_transcript

    )

@app.route(“/transcript_webhook”, methods=[‘POST’])

def transcript_webhook():

    global transcript_parts 

    transcript = request.json[‘data’][‘transcript’]

    if transcript[‘is_final’]:

        transcript_parts.append(transcript)

    return “OK”

 

Next, create a folder called templates and paste the following code into a file at templates/transcript_view.html

<!DOCTYPE html>

<html>

    <head>

        <meta http-equiv=”refresh” content=”1″>

    </head>

    <body>

        <h1>Transcript View</h1>

        <table>

            {% for p in formatted_transcript %}

            <tr>

                <th>{{ p[‘speaker’] }}</th>

                <td>{{ p[‘text’] }}</td>

            </tr>

            {% endfor %}

        </table>

    </body>

</html>

After that, you need to install the dependencies for the server. 

pip install Flask

pip install requests

Finally, to run the server, type the following into your terminal:

flask run

View the Real-Time Rev AI Transcription

Start a Zoom call, then visit localhost:5000/send_bot_to_call?zoom_url=YOUR-ZOOM-URL, substituting “YOUR-ZOOM-URL” with your full Zoom url (which should look like this: https://us02web.zoom.us/j/1234567890

If you are in the Zoom call and speaking, you should be able to see the real-time transcription with speaker labels show up on the page you get redirected to. 

And just like that, we’ve created a basic note taking application that transcribes a Zoom meeting in real-time.

On top of that, Recall.ai supports other video conferencing platforms like Google Meet, Microsoft Teams, Webex, and more – which means this application already integrates with these other platforms without any code change required. Simply replace the meeting URL with the meeting URL of a different platform, and everything works the same!

How to Get Started

Pulling audio from meeting platforms can be tricky, so we’re thrilled that this Recall.ai partnership provides developers with a frictionless way to get Rev AI’s highly-accurate transcription to deliver more powerful meeting insights for a variety of use cases.

To get started with Rev AI, sign up here.
To get started with Recall.ai, book a call here.