# Google Meet Transcript Bot (`lexis-solutions/google-meet-transcription-bot`) Actor

Google Meet Bot API for meeting transcription & intelligence. Join calls programmatically, capture speaker-diarized transcripts from live captions, and export JSON/Markdown via REST API, webhooks, n8n & Zapier. Build AI notetakers and automate meeting notes.

- **URL**: https://apify.com/lexis-solutions/google-meet-transcription-bot.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Automation, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $99.00 / 1,000 minutes

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Meet Bot API — Audio Recording & Meeting Intelligence

**Programmatic Google Meet bots that join calls, capture meeting audio, and deliver recordings via REST API** — built as an [Apify Actor](https://apify.com/actors) for developers who want meeting capture without building browser automation from scratch.

> Send a bot to any Google Meet. Get a WebM audio recording and meeting metadata — all through Apify's production-grade API, webhooks, and integrations.

***

### Why this over Recall.ai, Vexa, or rolling your own?

|                             | **Lexis Meet Agent**                                                                                 | Typical meeting-bot APIs          |
| --------------------------- | ---------------------------------------------------------------------------------------------------- | --------------------------------- |
| **API platform**            | Full [Apify REST API](https://docs.apify.com/api/v2) — runs, KV store, webhooks, schedules           | Custom REST + WebSocket           |
| **Audio recording**         | WebM audio written to KV store at meeting end (chunked during call)                                    | MP4, separate audio streams       |
| **Transcription**           | Not included — pipe `recording.webm` to your own STT (Whisper, Deepgram, etc.)                       | Built-in STT / diarization        |
| **Source code**             | Open Actor — fork, self-host, audit                                                                  | Closed / partial open source      |
| **Scaling**                 | Apify cloud — concurrent runs, retries, monitoring                                                   | Managed infra                     |
| **Integrations**            | n8n, Zapier, Make, webhooks, any HTTP client                                                         | Platform-specific                 |
| **Join model**              | Guest bot (host admits) or authenticated Google session                                              | Often no host permission required |

**Best fit:** engineering teams building meeting capture pipelines, AI notetakers, sales call logging, compliance archives, or agentic apps — who want **API-first control** and **Apify's developer ecosystem** instead of a closed meeting-BaaS.

Compare: [Recall.ai Google Meet Bot API](https://www.recall.ai/product/meeting-bot-api/google-meet) · [Vexa Meeting Transcription API](https://vexa.ai/)

***

### What you get

#### Google Meet Bot API primitives

- **Automatic join & leave** — bot joins via meeting URL, stays for the call, exits on alone-timeout, max duration, or removal
- **Custom bot identity** — set display name per meeting (`botName`)
- **Audio recording** — captures incoming WebRTC audio via in-browser `MediaRecorder`; uploads 10-second chunks during the call
- **Meeting metadata** — run status, chunk counts, byte totals, end reason in `status.json` and `recording.json`
- **Post-meeting output** — combined `recording.webm` plus per-chunk `audio/chunk-*.webm` files in the KV store
- **Agent-ready data** — feed recordings into your STT, LLMs, CRMs, or compliance archives

#### Built for AI agents & automation

- **REST API** for every operation — start bots, fetch recordings and artifacts
- **Webhooks** on run finish — trigger n8n, Zapier, or your backend when a meeting ends
- **Schedules** — calendar-driven bot deployment via [Apify Schedules](https://docs.apify.com/platform/schedules)
- **Concurrent bots** — run unlimited parallel meetings (Apify platform limits apply)
- **Observable runs** — live logs and run history in Apify Console

***

### Two API calls to meeting audio

#### 1. Start a Google Meet bot

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~google-meet-transcription-bot/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "meetingUrl": "https://meet.google.com/abc-defg-hij",
    "botName": "Acme Recorder",
    "aloneTimeoutSecs": 120
  }'
```

#### 2. Get the recording (after the meeting ends)

**Audio artifacts** (available once the run completes):

```bash
## Combined WebM recording
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/recording.webm?token=YOUR_APIFY_TOKEN" \
  --output meeting.webm

## Recording metadata (chunk keys, mime type, byte counts)
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/recording.json?token=YOUR_APIFY_TOKEN"

## Run status (joining → recording_active → ended)
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/status.json?token=YOUR_APIFY_TOKEN"
```

Individual chunks are also available at `audio/chunk-00001.webm`, `audio/chunk-00002.webm`, etc.

#### TypeScript / JavaScript

```typescript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

// Join the meeting
const run = await client.actor('YOUR_USERNAME/google-meet-transcription-bot').call({
    meetingUrl: 'https://meet.google.com/abc-defg-hij',
    botName: 'Meeting Recorder',
});

// Combined audio recording
const store = client.keyValueStore(run.defaultKeyValueStoreId);
const recording = await store.getRecord('recording.webm');
const metadata = await store.getRecord('recording.json');
console.log(metadata.value); // { chunkCount, totalBytes, mimeType, ... }
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("YOUR_USERNAME/google-meet-transcription-bot").call(run_input={
    "meetingUrl": "https://meet.google.com/abc-defg-hij",
    "botName": "Meeting Bot",
})

store = client.key_value_store(run["defaultKeyValueStoreId"])
metadata = store.get_record("recording.json")
audio = store.get_record("recording.webm")
```

#### Webhook on meeting end

```typescript
const run = await client.actor('YOUR_USERNAME/google-meet-transcription-bot').call(
    { meetingUrl: 'https://meet.google.com/abc-defg-hij' },
    {
        webhooks: [
            {
                eventTypes: ['ACTOR.RUN.SUCCEEDED', 'ACTOR.RUN.FAILED'],
                requestUrl: 'https://your-app.com/webhooks/meeting-ended',
            },
        ],
    },
);
```

Or configure a permanent webhook on the Actor in [Apify Console](https://console.apify.com/) → your Actor → Integrations → Webhooks.

Your webhook receives the run payload with links to the key-value store — fetch the recording and push to your STT pipeline, S3, or compliance archive.

***

### How it works

```
Meeting URL  →  Apify API  →  Bot joins Meet  →  Audio capture ON  →  Bot leaves  →  recording.webm
```

1. **Launch** — Camoufox (anti-fingerprint Firefox) via Playwright on Apify infrastructure
2. **Join** — guest join with your `botName`, mic/camera off, keyboard-driven lobby navigation
3. **Admit** — waits for host admission (configurable timeout)
4. **Record** — hooks `RTCPeerConnection` to mix incoming remote audio tracks; `MediaRecorder` writes WebM chunks every 10 seconds
5. **Upload** — each chunk is saved to the KV store during the call; chunks are concatenated into `recording.webm` at the end
6. **End** — leaves on alone-timeout, max duration, or removal
7. **Deliver** — writes `recording.webm`, `recording.json`, and `status.json` to the KV store

No built-in speech-to-text. Transcription quality depends on **your STT provider** applied to the recording.

***

### Input

| Field                  | Required | Default     | Description                                                    |
| ---------------------- | -------- | ----------- | -------------------------------------------------------------- |
| `meetingUrl`           | **Yes**  | —           | Google Meet link (`https://meet.google.com/...`)               |
| `botName`              | No       | `Notetaker` | Bot display name shown to participants                         |
| `maxDurationSecs`      | No       | `7200`      | Max time in meeting (`0` = unlimited)                          |
| `aloneTimeoutSecs`     | No       | `5`         | Leave when bot is alone this long                              |
| `admissionTimeoutSecs` | No       | `600`       | Wait for host to admit the bot                                 |

***

### Output

#### Key-Value Store — meeting artifacts

| Key                    | Description                                                        |
| ---------------------- | ------------------------------------------------------------------ |
| `recording.webm`       | Combined WebM audio of the meeting (all chunks concatenated)       |
| `recording.json`       | Metadata: mime type, chunk keys, byte counts, duration, end reason |
| `audio/chunk-*.webm`   | Individual 10-second recording chunks uploaded during the call     |
| `status.json`          | Live run status (`joining` → `recording_active` → `ended`)         |

#### Status lifecycle

`starting` → `joining` → `admitted` → `recording_active` → `ended`

Terminal states: `blocked_guest`, `admission_timeout`, `error`

`status.json` during recording includes `chunkCount`, `totalBytes`, and `trackCount`.

***

### Use cases

- **Sales & revenue** — archive discovery calls and demos; transcribe with your own STT
- **Engineering** — record standups / retros for async review or AI summarization
- **HR & recruiting** — interview audio archives for compliance and review
- **Compliance** — meeting audio recordkeeping with consent
- **AI notetakers** — capture audio on Apify, transcribe and summarize in your pipeline
- **Workflow automation** — n8n/Zapier triggers on `ACTOR.RUN.SUCCEEDED`

***

### Requirements & limitations

**Works with**

- Google Meet on all common Workspace tiers (guest join where org policy allows)
- Free Google accounts when guest access is permitted

**Limitations**

- **Host must admit** the guest bot
- Some organizations **block guest joins** — run exits with `blocked_guest`
- **Audio only** — no video recording, screenshare capture, or chat messages
- **Incoming audio only** — bot joins with mic muted; captures remote participant WebRTC audio tracks
- Recording requires Meet to deliver audio over WebRTC to the browser — if no remote tracks connect, `chunkCount` will be `0`
- **No built-in transcription or speaker diarization** — add your own STT step
- **Google Meet only** — Microsoft Teams and Zoom not supported in this Actor
- Real-time delivery is via **KV store chunk uploads** during the call (not a dedicated WebSocket)

**Consent**

This Actor captures meeting audio, which may constitute recording in some jurisdictions. You are responsible for obtaining consent from meeting participants before use.

***

### Architecture

| Layer      | Technology                                               |
| ---------- | -------------------------------------------------------- |
| Platform   | [Apify Actors](https://apify.com/actors)                 |
| Browser    | [Camoufox](https://camoufox.com/) + Playwright (Firefox) |
| Interaction| Ghost cursor, semantic locators, keyboard shortcuts      |
| Recording  | WebRTC track hook + `MediaRecorder` (WebM/Opus)          |

***

### FAQ

**Does this work as a Google Meet recording API?**
Yes. Start a run with a Meet URL; retrieve `recording.webm` and `recording.json` from the KV store once the run completes.

**Do I need the host's permission?**
For guest join, the host (or someone with admit rights) must let the bot into the meeting.

**Can I get real-time audio during the call?**
Chunks are uploaded to the KV store every ~10 seconds as `audio/chunk-*.webm`. Poll those keys during the run, or wait for the combined `recording.webm` at the end.

**How does this compare to Recall.ai?**
Recall.ai offers built-in transcription, video capture, wider platform support, and often no-admit joins. This Actor is **audio-only**, **open source**, and runs on **Apify's API** — you bring your own STT.

**How does this compare to Vexa?**
Vexa is open-source meeting-bot infrastructure with WebSockets and self-hosting. This Actor gives you a **deploy-ready Google Meet bot** on Apify with a "send URL → get recording" developer experience.

**Can I run multiple bots at once?**
Yes. Each meeting is a separate Apify Actor run. Scale concurrent bots via Apify platform limits and billing.

**Can I schedule bots for calendar meetings?**
Use [Apify Schedules](https://docs.apify.com/platform/schedules) or trigger runs from your calendar integration (Google Calendar → webhook → Apify API).

**Is there speaker diarization?**
Not built in. Run your preferred STT service on `recording.webm` for transcription and diarization.

***

<p align="center">
  <strong>Google Meet Bot API</strong> · Meeting Audio Recording · WebRTC Capture · Meeting Intelligence · Apify Actor
</p>

***

👀 p.s.

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find). We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or [LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work 💝

If you're happy with our work and scrapers, you're welcome to leave us a company review [here](https://apify.com/partners/find/lexis-solutions/review) and leave a review for the scrapers you're subscribed to. It will take you less than a minute but it will mean a lot to us!

# Actor input Schema

## `meetingUrl` (type: `string`):

The Google Meet link to join (e.g. https://meet.google.com/abc-defg-hij).

## `botName` (type: `string`):

Name shown to other participants when the bot joins.

## `maxDurationSecs` (type: `integer`):

Maximum time to stay in the meeting. Set 0 for no limit.

## `aloneTimeoutSecs` (type: `integer`):

Leave the meeting when the bot is the only participant for this many seconds.

## `admissionTimeoutSecs` (type: `integer`):

How long to wait for the host to admit the bot before giving up.

## Actor input object example

```json
{
  "meetingUrl": "https://meet.google.com/",
  "botName": "Notetaker",
  "maxDurationSecs": 7200,
  "aloneTimeoutSecs": 5,
  "admissionTimeoutSecs": 600
}
```

# Actor output Schema

## `recording` (type: `string`):

No description

## `recordingJson` (type: `string`):

No description

## `status` (type: `string`):

No description

## `audioChunks` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "meetingUrl": "https://meet.google.com/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/google-meet-transcription-bot").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "meetingUrl": "https://meet.google.com/" }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/google-meet-transcription-bot").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "meetingUrl": "https://meet.google.com/"
}' |
apify call lexis-solutions/google-meet-transcription-bot --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lexis-solutions/google-meet-transcription-bot",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/980f5X3aR9FKreq9j/builds/DjixXT923bWedxCZi/openapi.json