# 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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 — Transcription & Meeting Intelligence
**Programmatic Google Meet bots that join calls, capture speaker-diarized transcripts, and deliver structured meeting data via REST API** — built as an [Apify Actor](https://apify.com/actors) for developers who want meeting intelligence without building browser automation from scratch.
> Send a bot to any Google Meet. Get diarized transcripts 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, datasets, KV store, webhooks, schedules | Custom REST + WebSocket |
| **Transcripts** | Full diarized transcript written to Dataset and KV store at meeting end | Real-time WebSocket / webhook |
| **Speaker diarization** | Native Google Meet captions with per-speaker attribution | STT diarization |
| **Audio / video recording** | Not included (captions-only) | MP4, separate audio streams |
| **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 intelligence, AI notetakers, sales call logging, interview transcription, compliance workflows, 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, removal, or exit phrases
- **Custom bot identity** — set display name per meeting (`botName`)
- **Transcription** — live captions observed via DOM `MutationObserver`; full diarized transcript written at meeting end
- **Speaker-diarized transcripts** — each segment includes `speaker` and `text`
- **Meeting metadata** — run status, segment counts, end reason, meeting URL in `status.json` and `transcript.json`
- **Post-meeting output** — full `TRANSCRIPT.md` and structured `transcript.json`
- **Multi-language captions** — configure caption language (`en`, `es`, `de`, …)
- **Agent-ready data** — feed transcripts into LLMs, CRMs, ticketing, or RAG pipelines
#### Built for AI agents & automation
- **REST API** for every operation — start bots, read final transcripts 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, screenshots, and run history in Apify Console
---
### Two API calls to meeting intelligence
#### 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 Notetaker",
"captionLanguage": "en",
"aloneTimeoutSecs": 120
}'
````
#### 2. Get the transcript (after the meeting ends)
**Transcript segments** (available once the run completes):
```bash
## Structured JSON
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/transcript.json?token=YOUR_APIFY_TOKEN"
## Human-readable Markdown
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/TRANSCRIPT.md?token=YOUR_APIFY_TOKEN"
## Run status (joining → captions_active → ended)
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/status.json?token=YOUR_APIFY_TOKEN"
```
#### 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: 'Vexa-style Notetaker',
});
// Diarized transcript segments
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
// [{ speaker: "Alice", text: "..." }, ...]
// Full transcript artifact
const store = client.keyValueStore(run.defaultKeyValueStoreId);
const transcript = await store.getRecord('transcript.json');
```
#### Python
```python
from apify_client import ApifyClient
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",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["speaker"], item["text"])
```
#### 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 dataset and key-value store — fetch transcripts and push to Salesforce, HubSpot, Linear, Slack, or your vector DB.
***
### How it works
```
Meeting URL → Apify API → Bot joins Meet → Captions ON → Bot leaves → Transcript artifacts
```
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. **Transcribe** — enables Google Meet live captions, observes caption DOM with `MutationObserver`
5. **Diarize** — accumulates per-speaker turns; speaker change triggers segment commit
6. **End** — leaves on alone-timeout, max duration, removal, or configurable exit phrases
7. **Deliver** — writes full `TRANSCRIPT.md`, `transcript.json`, and `status.json` to the KV store; pushes segments to the Dataset
No audio capture. No speech-to-text API. Transcription quality follows **Google Meet captions** for the selected language.
***
### 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) |
| `captionLanguage` | No | `en` | Caption language code (`en`, `es`, `de`, …) |
| `aloneTimeoutSecs` | No | `5` | Leave when bot is alone this long |
| `admissionTimeoutSecs` | No | `600` | Wait for host to admit the bot |
| `storageStatePath` | No | — | Playwright storage state from a signed-in Google account (more reliable than guest) |
***
### Output
#### Dataset — transcript segments
One row per speaker turn, written to the Dataset when the meeting ends:
```json
{
"speaker": "Alice Chen",
"text": "We need to finalize the API contracts by Friday."
}
```
Fetch `GET /v2/actor-runs/{runId}/dataset/items` after the run completes.
#### Key-Value Store — meeting artifacts
| Key | Description |
| --------------------- | --------------------------------------------------------- |
| `transcript.json` | Full structured transcript + metadata |
| `TRANSCRIPT.md` | Human-readable transcript |
| `status.json` | Live run status (`joining` → `captions_active` → `ended`) |
| `SELECTOR_PROBE.json` | Debug: caption selector health |
#### Status lifecycle
`starting` → `joining` → `admitted` → `captions_active` → `ended`
Terminal states: `blocked_guest`, `admission_timeout`, `error`
***
### Use cases
- **Sales & revenue** — auto-log discovery calls, demo notes, competitor mentions to CRM
- **Engineering** — standup / retro transcripts for AI coding agents and ticket creation
- **HR & recruiting** — interview transcription with speaker attribution
- **Compliance** — meeting recordkeeping where caption-based capture is acceptable
- **AI notetakers** — build your own Otter/Fireflies alternative on Apify
- **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
- Multi-language live captions supported by Google Meet
**Limitations**
- **Host must admit** the guest bot (unless using an authenticated `storageStatePath` session)
- Some organizations **block guest joins** — run exits with `blocked_guest`
- **Captions-only** — no audio recording, video recording, screenshare capture, or chat messages
- **Google Meet only** — Microsoft Teams and Zoom not supported in this Actor
- Google Meet's DOM is not a public API; selectors may need updates when Meet changes
- Caption quality varies by language, accent, and Meet's own STT
- Real-time delivery is via **Dataset polling** (sub-second segment finalization; not a dedicated WebSocket)
**Consent**
This Actor captures meeting captions, 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 |
| Transcription | Google Meet live captions (DOM scrape) |
***
### FAQ
**Does this work as a Google Meet transcription API?**
Yes. Start a run with a Meet URL; retrieve diarized transcript segments from the Dataset API and full artifacts 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. For stricter orgs, use a signed-in Google session via `storageStatePath`.
**Can I get real-time transcripts?**
Not currently — segments are written to the Dataset when the meeting ends. Use the `status.json` key-value record to monitor the bot's state (`joining` → `captions_active` → `ended`) and fetch the transcript after the run completes.
**How does this compare to Recall.ai?**
Recall.ai offers audio/video capture, wider platform support, and often no-admit joins. This Actor is **caption-based** (simpler compliance surface), **open source**, and runs on **Apify's API** with webhooks, schedules, and integrations you may already use.
**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 the same "send URL → get transcript" developer experience, plus Apify's managed scaling and ecosystem.
**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?**
Yes — speaker names come from Google Meet's live caption UI, attributed per segment.
***
Google Meet Bot API · Meeting Transcription API · Real-Time Transcripts · Speaker Diarization · Meeting Intelligence · Apify Actor
***
👀 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.
## `captionLanguage` (type: `string`):
Language for Google Meet live captions.
## `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,
"captionLanguage": "en",
"aloneTimeoutSecs": 5,
"admissionTimeoutSecs": 600
}
```
# Actor output Schema
## `segments` (type: `string`):
No description
## `transcriptMarkdown` (type: `string`):
No description
## `transcriptJson` (type: `string`):
No description
## `status` (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 '' with your token
const client = new ApifyClient({
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 '' with your token.
client = ApifyClient("")
# 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 "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Google Meet Transcript Bot",
"description": "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.",
"version": "0.1",
"x-build-id": "eRFC3nkaShLuV663v"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/lexis-solutions~google-meet-transcription-bot/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-lexis-solutions-google-meet-transcription-bot",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/lexis-solutions~google-meet-transcription-bot/runs": {
"post": {
"operationId": "runs-sync-lexis-solutions-google-meet-transcription-bot",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/lexis-solutions~google-meet-transcription-bot/run-sync": {
"post": {
"operationId": "run-sync-lexis-solutions-google-meet-transcription-bot",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"meetingUrl"
],
"properties": {
"meetingUrl": {
"title": "Google Meet URL",
"type": "string",
"description": "The Google Meet link to join (e.g. https://meet.google.com/abc-defg-hij)."
},
"botName": {
"title": "Bot display name",
"type": "string",
"description": "Name shown to other participants when the bot joins.",
"default": "Notetaker"
},
"maxDurationSecs": {
"title": "Max meeting duration (seconds)",
"minimum": 0,
"type": "integer",
"description": "Maximum time to stay in the meeting. Set 0 for no limit.",
"default": 7200
},
"captionLanguage": {
"title": "Caption language",
"enum": [
"en",
"en-gb",
"es",
"fr",
"de",
"it",
"pt",
"nl",
"ru",
"ja",
"ko",
"zh",
"zh-tw",
"ar",
"hi",
"pl",
"sv",
"tr"
],
"type": "string",
"description": "Language for Google Meet live captions.",
"default": "en"
},
"aloneTimeoutSecs": {
"title": "Alone timeout (seconds)",
"minimum": 5,
"type": "integer",
"description": "Leave the meeting when the bot is the only participant for this many seconds.",
"default": 5
},
"admissionTimeoutSecs": {
"title": "Admission timeout (seconds)",
"minimum": 30,
"type": "integer",
"description": "How long to wait for the host to admit the bot before giving up.",
"default": 600
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```