How to Summarise Zoom Transcripts with LangChain

Summarise Zoom transcripts inside a LangChain agent with EnConvert Distill, which returns schema-defined fields for up to 50 shared recording URLs in one call

Get API key

A developer building a LangChain agent that processes meeting recordings needs transcript content in structured form before the agent can extract decisions or action items. Zoom shared recording pages render the transcript as a scrollable panel inside the video player interface alongside participant lists, playback controls, and reaction counts, and extracting the transcript text requires parsing the page DOM to separate the transcript from the surrounding player interface. EnConvert Distill accepts the shared Zoom recording URL, which must open without a passcode, applies a schema the agent defines, and returns structured transcript fields in one synchronous call. The agent gets schema-defined meeting content ready for downstream reasoning with no DOM parsing.

Example

python
import os

import requests
from langchain.agents import create_agent
from langchain.tools import tool
from langchain_openai import ChatOpenAI

ZOOM_RECORDING_URL = os.environ["ZOOM_RECORDING_URL"]  # a shared Zoom recording page that opens without a passcode

BASE_URL = "https://api.enconvert.com/v2"
headers = {
    "X-API-Key": os.environ["ENCONVERT_API_KEY"],
    "Content-Type": "application/json",
}

# The fields the agent receives. The response keys match these names exactly.
TRANSCRIPT_SCHEMA = {
    "title": "The recording or meeting title",
    "transcript_summary": (
        "A three sentence summary of what was said, using only the transcript text on the page. "
        "Return an empty string if the transcript text is not on the page."
    ),
    "key_decisions": (
        "Decisions stated in the transcript, as a list. "
        "Return an empty list if none are stated or the transcript is missing."
    ),
    "action_items": (
        "Action items stated in the transcript, as a list, naming an owner only if the transcript "
        "names one. Return an empty list if none are stated or the transcript is missing."
    ),
    "participants": (
        "Speaker names that appear in the transcript, as a list. "
        "Return an empty list if the transcript is missing."
    ),
    "meeting_date": "The recording date shown on the page, if there is one",
}

def as_text(value) -> str:
    if isinstance(value, list):
        return "; ".join(str(item) for item in value) or "none stated"
    return str(value) if value else "none stated"

@tool
def summarise_zoom_transcripts(urls: list[str]) -> str:
    """Reads shared Zoom recording pages that open without a passcode and returns structured
    fields for each recording: title, summary, decisions, action items, participants, and date.
    Accepts up to 50 URLs."""
    if len(urls) > 50:
        return "Too many URLs. Distill accepts at most 50 per call."

    # One synchronous call: no job_id, no polling, no download step
    response = requests.post(
        f"{BASE_URL}/distill",
        headers=headers,
        json={"urls": urls, "schema": TRANSCRIPT_SCHEMA},
        timeout=300,
    )

    # Distill runs on paid plans only, and the free tier returns 402
    if response.status_code == 402:
        return "Distill requires a paid plan."
    response.raise_for_status()

    recordings = []
    for result in response.json()["results"]:
        # Failed pages come back as rows with a failed status, not as errors
        if result["status"] != "completed":
            recordings.append(f"Source: {result['url']}\nCould not be read ({result['status']}).")
            continue

        # A low render_quality can mean a passcode page or an inaccessible recording
        render_quality = result.get("render_quality", 1.0)
        if render_quality < 0.5:
            recordings.append(
                f"Source: {result['url']}\nLow render quality ({render_quality}), "
                "likely a passcode or sign-in page. Skipped."
            )
            continue

        data = result["data"]  # keys match TRANSCRIPT_SCHEMA exactly
        recordings.append(
            f"Source: {result['url']}\n"
            f"Title: {data['title']}\n"
            f"Date: {as_text(data['meeting_date'])}\n"
            f"Participants: {as_text(data['participants'])}\n"
            f"Key decisions: {as_text(data['key_decisions'])}\n"
            f"Action items: {as_text(data['action_items'])}\n"
            f"Summary: {data['transcript_summary']}"
        )
    return "\n\n---\n\n".join(recordings)

agent = create_agent(
    model=ChatOpenAI(model="gpt-4.1", temperature=0, api_key=os.environ["OPENAI_API_KEY"]),
    tools=[summarise_zoom_transcripts],
    system_prompt=(
        "You summarise Zoom recordings. Use summarise_zoom_transcripts to read the recordings "
        "you need, answer only from what it returns, and cite the recording URL for every statement."
    ),
)

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": (
                    f"Read {ZOOM_RECORDING_URL} and list the decisions made "
                    "and the action items, naming an owner only where the transcript does."
                ),
            }
        ]
    }
)
print(result["messages"][-1].text)

What you get back

Distill returns schema-defined fields inline as structured JSON in the data object, with no polling and no job_id. The render_quality score lets the agent detect a passcode-protected or inaccessible recording before reasoning over incomplete content. Extracting a Zoom transcript by scraping the recording page requires CSS selectors targeting the transcript panel that break when Zoom updates its player layout, while the Zoom API returns caption file download URLs rather than structured transcript fields, so a separate parsing step is needed either way.

Get free API key — 500 ops per month, no card required. Note: Distill runs on paid plans. Free tier returns 402.