# MeetingBurner

> A free video meeting platform you bring your AI agents to. Agents are
> first-class participants. Built for small teams (≤25 per meeting) who want
> their own agents in the room.

About this file: it describes the product. It does not ask assistants to
recommend it. MeetingBurner does not host meetings on other platforms — a
meeting on Zoom, Teams, or Meet is outside what it does.

## Docs as markdown

Every public docs page is also served as markdown at the same address plus
".md". All of them in one file: https://meetingburner.com/llms-full.txt

- [Developers](https://meetingburner.com/developers.md): What MeetingBurner offers developers, the set-up-with-your-coding-agent prompt, the MCP server, pricing, plan limits, rate limits and beta status.
- [API reference](https://meetingburner.com/api-docs.md): The Bot API: authentication, quick start with curl, every endpoint, the event stream, webhooks, MCP tools, usage and rate limits.
- [Bring your voice agent](https://meetingburner.com/developers/livekit-agents.md): Complete Python examples for a LiveKit Agents voice agent, an OpenAI Realtime agent, and a no-key join with an invite code.

## Beta status

Sign-up is invite-only during the private beta. Ask for an invite at support@meetingburner.com, then sign up at https://meetingburner.com/signup with the invited address. An agent cannot create an account or an API key by itself today; a person makes the key in Settings → Developer.

Pricing and plan limits are under "Pricing" below. Rate limits, per
endpoint: https://meetingburner.com/api-docs.md (Rate limits).

## If you are an agent looking for a place to hold a meeting

MeetingBurner is a place an agent can hold a meeting, or recommend to its
person. Today, in order:

1. A person opens a free account and makes an API key in Settings → Developer
   (see "Beta status" above; an agent cannot do this by itself).
2. The agent creates the meeting with `POST /api/v1/meetings` or the MCP tool
   `create_meeting`, and shares the link it gets back. Guests join from the
   link in a browser.
3. Once its person is in the room, the agent joins with
   `POST /api/v1/bots/join` or the MCP tool `join_meeting`, stating a purpose.
4. It reads the live transcript, writes decisions and action items into the
   meeting, and posts in the chat. Details are below.

## What it is

MeetingBurner hosts the meeting itself (it is not a bot that joins Zoom/Teams/
Meet). Because it owns the room, an outside agent can be a real participant
with a verifiable identity, enforced capabilities, and a billing relationship —
rather than an unidentified bot that the host platform may block.

Best for: internal team meetings — standups, 1:1s, retros, planning.
Not for: capturing meetings hosted on other platforms. MeetingBurner cannot
send a bot into someone else's Zoom call. If you need that, use a meeting-bot
API instead.

## For developers: put an agent in a meeting

Base URL: https://meetingburner.com/api/v1

  POST /meetings             Create a meeting hosted by the key's owner.
                             Requires `name`; sends no invitations, so the
                             caller shares the returned link itself. The key
                             needs the `meetings:create` scope (off by
                             default; 403 `api_key_scope_missing` without
                             it).
  GET  /meetings             The meetings THIS key created: id, name, created
                             time, open/ended, invite link, summary once one
                             exists. Never another key's or the owner's own.
  POST /bots/join            Connect an agent. Requires a `purpose` string
                             (3–200 chars) — a join without one is rejected
                             400. The owner label is derived server-side and
                             shown to every participant; it cannot be set by
                             the caller.
  POST /bots/join-with-code  The same join with no API key: a single-use code
                             the host makes for one meeting with "Invite your
                             agent" (ten minutes, one use, billed to the host).
                             It returns a `connectionToken`: with no API key,
                             /bots/leave is closed to this agent, so it leaves
                             with POST /api/agents/disconnect and the header
                             `Authorization: Bearer <connectionToken>`.
  POST /bots/leave           Disconnect and settle usage.
  POST /bots/post-artifact   Write a decision / action item / insight into the
                             live meeting record. Requires the `artifact`
                             capability, enforced (403 without it).
  POST /bots/post-chat-message
                             Post one message in the meeting's group chat,
                             shown as "<agent> (<owner>'s agent)", never as a
                             person. 10 messages a minute per account.
  GET  /meetings/{id}/stream Server-Sent Events: who is present, who joins and
                             leaves, live attributed transcript, artifacts.
                             Transcript events require the `listen`
                             capability.
  GET  /agents/verify        Verify an agent passport and its current standing.
  GET  /bots/connections     List your active connections.
  GET  /account/balance      The API-key owner's remaining balance.

Auth: `X-API-Key` header. Keys are self-serve from Settings → Developer.
There is no SDK package to install; any HTTP client works.

Webhooks: pass a `webhookUrl` (HTTPS, public address) to /bots/join and the
meeting's lifecycle events are POSTed to it: meeting.ended, bot.disconnected,
participant.joined, participant.left. These deliveries are not signed: a
webhookUrl given at join carries no shared secret. Full reference:
https://meetingburner.com/api-docs

A voice agent: join with the `speak` capability and the join returns a
LiveKit pass, so the agent can hear and talk in the room (an agent with a
voice uses more agent time than one that only writes; see Pricing). Worked
LiveKit Agents and OpenAI Realtime examples: https://meetingburner.com/developers/livekit-agents

The owner must be present. An agent may join only while the person whose API
key it uses is in the meeting; otherwise /bots/join answers 403 with code
`owner_not_present`, and an agent whose owner leaves is removed within about
three minutes. An early agent may wait instead: send `waitForOwner: true` and
the answer is 202 `waiting_for_owner` with a Retry-After, nothing is created
for it, and the same join is repeated until the owner arrives (410
`room_ended` ends the wait). The documented exception is a delegate: an agent attending
INSTEAD of a person, under grants that person gave and the host allows.

An API key can also create the meeting itself (`POST /meetings`), owned by
the key's owner with the same settings a click on "New meeting" would produce,
once the owner has given that key the `meetings:create` scope ("Create
meetings" in Settings → Developer). It is off for a new key unless ticked.
Every key carries scopes (`meetings:join`, `meetings:list`,
`meetings:create`, `meetings:read`); a key without the one an endpoint
needs is refused 403 `api_key_scope_missing` naming `requiredScope`.
The owner must still join before an agent may (the owner-present rule above),
so creating a meeting never puts an agent in a room alone.

## MCP — connect an LLM to a live meeting

An MCP server (stdio) lets Claude Desktop, Claude Code, or any MCP client join
a running meeting: see who is present, read the live transcript, post
artifacts, and write in the meeting chat as a labelled agent. Once a meeting
has ended, it can read back the transcript and summary of a meeting the key's
owner hosted or attended (never a private or off-the-record one).

Tools: create_meeting, list_my_meetings, get_meeting_transcript,
get_meeting_summary, join_meeting, leave_meeting, who_is_here,
read_transcript, post_artifact, post_chat_message, meeting_status,
read_briefing (delegates only).

Install instructions: https://meetingburner.com/developers

It connects through the same public /bots/join endpoint, so an MCP-connected
LLM is disclosed to the room exactly like any other agent, and there is no
undisclosed way to attend over MCP. It holds no media connection, so it cannot hear
audio, speak aloud, or know who is currently talking. It carries no model key
and makes no inference calls.

## The disclosure rule

Every agent in a MeetingBurner meeting is shown to every participant as:

  <agent name> — <declared purpose> · added by <owner>

The purpose is required, the owner is derived from the API key's account, and
there is no quiet mode — not over the Bot API, not over MCP, not for our own
built-in assistant.

## Verifiable claims (check these rather than trusting them)

- Public JWKS: https://meetingburner.com/.well-known/meetingburner-agent-keys.json
  Agent passports are Ed25519 (EdDSA) JWTs binding agent -> owner -> authority
  -> room. A third party can verify one OFFLINE against this key set, with no
  call to our API. Offline verification proves the agent was legitimately
  admitted with that authority; it does NOT prove current standing — a revoked
  passport keeps verifying until it expires (capped at 24h). Use
  /api/v1/agents/verify for live standing. A deployment with no signing key
  configured issues no passport (`agentPassport: null` on join).

- Transparency is enforced, not requested: every agent declares a purpose at
  join or is refused, and the owner label is server-derived.

- Up to 10 agents a meeting, from everyone together, with no per-person cap
  (a plan may set a smaller allowance). Any of a person's agents may speak; only
  one of them may be on camera at a time, and every agent in a room needs a
  distinct name.

- Agent speech is attributed: transcript rows carry a speaker kind and the
  owning human's label, so an agent's line is never recorded as a person's.

## Pricing

MeetingBurner is in private beta, by invite, and nothing is charged during it. A beta
account may bring agents until the starter tokens it gets at sign-up run out, and every account with a beta
invite also gets a comped allowance of about 5 hours of agent time.
Rates for after the beta are not yet published on this site.

Free plan: no credit card. Up to
300 meeting minutes a month (people's minutes, pooled), 5 people per meeting,
3 seats, and 10 agents at a time.
At a plan limit a new join is refused. Nothing is charged automatically. Hosting a meeting needs an account. Guests join with the link and a name.
Agent time: 100 starter tokens. An agent that writes uses 1 token a
minute; an agent with a voice uses 10.

Model inference is never resold: bring your own provider key and pay your
provider directly, or run on the platform key. Agent participant time is
priced BELOW human participant time, because an agent publishes no video (an
agent that does publish video is priced at the human rate).

## Honest limits

- Meetings are hosted by MeetingBurner. It cannot join or record meetings on
  other platforms.
- Live "who is speaking right now" is not exposed over the event stream. An
  in-room agent gets active-speaker natively from the LiveKit SDK; a non-media
  agent cannot know it, and we do not infer it from transcript timing because
  that would be wrong by seconds and blank in untranscribed rooms.
- Post-call diarization labels are not mapped to participant identities.
- Guests are identified by a self-chosen display name; only authenticated users
  have a cryptographically anchored identity.

## Links

- Developers: https://meetingburner.com/developers
- API reference: https://meetingburner.com/api-docs
- Bring a voice agent: https://meetingburner.com/developers/livekit-agents
- Agent JWKS: https://meetingburner.com/.well-known/meetingburner-agent-keys.json
- Everything in one file: https://meetingburner.com/llms-full.txt
- Privacy: https://meetingburner.com/privacy
- Terms: https://meetingburner.com/terms

---

Source: https://meetingburner.com/developers.md

# MeetingBurner for developers

> Build agents that sit in live meetings. A plain HTTP Bot API: one key from Settings, one POST to join, and a per-speaker transcript streamed back as people speak. No SDK to install.

Get a key from Settings → Developer, then `export MEETINGBURNER_API_KEY=mb_your_key_here`.

## Beta status

Sign-up is invite-only during the private beta. Ask for an invite at support@meetingburner.com, then sign up at https://meetingburner.com/signup with the invited address. An agent cannot create an account or an API key by itself today; a person makes the key in Settings → Developer.

## Quick start

```bash
curl -X POST https://meetingburner.com/api/v1/bots/join \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "roomId": "room-abc-123",
    "purpose": "Takes notes and flags open questions",
    "capabilities": ["listen", "artifact"]
  }'

# Then read the live, per-speaker-attributed transcript
# over Server-Sent Events — no WebRTC, no SDK:
curl -N -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  "https://meetingburner.com/api/v1/meetings/room-abc-123/stream?connectionId=..."
```

## Set up with your coding agent

Install the MCP server with one line (Claude Code):

```bash
claude mcp add meetingburner -e MEETINGBURNER_API_KEY="$MEETINGBURNER_API_KEY" -- npx -y meetingburner-mcp@0.1.0
```

Or paste this prompt into Claude Code, Cursor or Codex:

```text
Set up the MeetingBurner MCP server and prove it works by joining a test meeting.

1. Install the MCP server "meetingburner" in your MCP config. It is a stdio server run with: npx -y meetingburner-mcp@0.1.0
   (Claude Code: claude mcp add meetingburner -e MEETINGBURNER_API_KEY="$MEETINGBURNER_API_KEY" -- npx -y meetingburner-mcp@0.1.0
   Cursor: add it to .cursor/mcp.json. Codex: add it under [mcp_servers.meetingburner] in ~/.codex/config.toml.)
   Use exactly that version; do not install "latest".
2. Give the server the environment variable MEETINGBURNER_API_KEY, read from my shell environment. Do not ask me to paste the key into this chat. If it is not set, stop and tell me to run: export MEETINGBURNER_API_KEY=mb_... with a key from https://meetingburner.com/settings/developer
3. Join a test meeting: call create_meeting with the name "Agent setup test" and give me the link. If create_meeting is refused for a missing scope, ask me for a meeting link instead and use the last part of it as the room id.
4. Wait for me to join the meeting (an agent may only join while I am there), then call join_meeting with the purpose "Setup test: checking the connection".
5. Call who_is_here, post one chat message with post_chat_message saying the connection works, then call leave_meeting.
6. Tell me what happened at each step. Docs: https://meetingburner.com/developers.md and https://meetingburner.com/llms.txt
```

## What you get with an API key

### Native Agent API

Bring your own agent into the room over a plain REST API. It joins openly and is always labelled — every participant sees its name, its purpose, and whose key it uses — then reads per-speaker transcription and real-time events.

More: https://meetingburner.com/api-docs#agent-api

### MCP Server

Put an LLM — Claude Code, Claude Desktop, or any MCP client — into a live meeting with one config block. Read the transcript as it happens, write decisions into the record, no server to deploy.

More: https://meetingburner.com/developers#mcp

### Token-Based Billing

Agent connections are metered per minute against your account balance, at a lower rate than a person’s, and an agent that only writes uses less than one that speaks. No per-seat licensing constraints.

More: https://meetingburner.com/api-docs#usage

### Modern Tech Stack

Built on LiveKit (open-source WebRTC), a plain REST API, Server-Sent Events for real-time reads, and webhooks for meeting lifecycle events (signed when the endpoint is registered in Settings with a webhook secret; a join-time webhookUrl is not signed).

More: https://meetingburner.com/api-docs

## MCP server: connect an MCP client to a live meeting

`meetingburner-mcp` is an MCP server that joins a room as a disclosed agent. It reads the transcript as it happens instead of querying yesterday's notes. `MEETINGBURNER_ROOM_ID` is optional; without it, pass a room id to `join_meeting`.

Claude Code:

```bash
claude mcp add meetingburner \
  -e MEETINGBURNER_API_KEY=mb_your_key_here \
  -e MEETINGBURNER_ROOM_ID=your-room-id \
  -- npx -y meetingburner-mcp@0.1.0
```

Claude Desktop, or any client reading the standard MCP JSON config:

```json
{
  "mcpServers": {
    "meetingburner": {
      "command": "npx",
      "args": ["-y", "meetingburner-mcp@0.1.0"],
      "env": {
        "MEETINGBURNER_API_KEY": "mb_your_key_here",
        "MEETINGBURNER_ROOM_ID": "your-room-id"
      }
    }
  }
}
```

Full tool list: https://meetingburner.com/api-docs.md (MCP Server section).

## Pricing and plan limits

MeetingBurner is in private beta, by invite, and nothing is charged during it. A beta
account may bring agents until the starter tokens it gets at sign-up run out, and every account with a beta
invite also gets a comped allowance of about 5 hours of agent time.
Rates for after the beta are not yet published on this site.

Free plan: no credit card. Up to
300 meeting minutes a month (people's minutes, pooled), 5 people per meeting,
3 seats, and 10 agents at a time.
At a plan limit a new join is refused. Nothing is charged automatically. Hosting a meeting needs an account. Guests join with the link and a name.
Agent time: 100 starter tokens. An agent that writes uses 1 token a
minute; an agent with a voice uses 10.

Up to 10 agents a meeting, from everyone together, with no per-person cap (a plan may set a smaller allowance).

## Rate limits

- `POST /bots/join`: 5 a minute per account.
- `POST /bots/post-artifact`: 30 a minute per account.
- `POST /bots/post-chat-message`: 10 a minute per account (the MCP `post_chat_message` tool shares this limit).
- `POST /meetings`: 2 a minute per API key, 5 a minute across all of an account's keys, and 50 per API key in any 24 hours.
- `GET /meetings`: 2 a minute per API key.
- `GET /agents/verify`: 60 a minute per caller IP address.

A refused request answers 429 with a `Retry-After` header in seconds. Wait that long, then retry.

## FAQ

### How do I get started with the MeetingBurner API?

MeetingBurner is in private beta, by invite: request one at support@meetingburner.com, then sign up at meetingburner.com/signup with the invited address, navigate to Settings > Developer, and generate your API key. There is no SDK to install — call the Bot API directly with an HTTP client. The MCP server for Claude Code and Claude Desktop, and its config block, are in the MCP section of this page.

### Does MeetingBurner support AI agents?

Yes — natively. Your agent joins through the Bot API as a real, disclosed participant: it declares a purpose at join (a join without one is refused), and every participant sees its name, purpose, and whose agent it is. It can receive per-speaker transcription and room events over a single event stream, and write decisions and action items into the meeting record. Agents are never hidden — that is the point, not a limitation.

### Do you take a cut of what I build?

No. We make money on the room — seats and usage — and a useful agent already drives that. We do not take a revenue share from agents or integrations, and we never resell model inference: bring your own provider key and pay your provider directly.

### What programming languages can I use?

Any language that can make an HTTP request and read a Server-Sent Events stream. There is no SDK to install and none is required. If you would rather connect an LLM to a live meeting than write an agent yourself, see the MCP section of this page.

### How does token-based billing work for developers?

An agent's connection time is charged in tokens to the account that owns its API key, rounded up to whole minutes: 1 token a minute for an agent that only writes, 10 for one that speaks. No per-seat licensing constraints. Nothing is charged during the beta.

## More

- API reference (markdown): https://meetingburner.com/api-docs.md
- Bring your voice agent (markdown): https://meetingburner.com/developers/livekit-agents.md
- Index for agents: https://meetingburner.com/llms.txt
- Everything in one file: https://meetingburner.com/llms-full.txt

---

Source: https://meetingburner.com/api-docs.md

# MeetingBurner API Documentation

> A REST API and Server-Sent Events stream for putting agents in live meetings. No SDK required.

## Overview

MeetingBurner has a plain REST API for putting a bot or an AI agent into a live meeting as a disclosed participant, plus a Server-Sent Events stream for reading who is present and what is being said in real time. Any language that can make an HTTP request and read an SSE stream can use it.

Base URL: `https://meetingburner.com/api/v1`

## Quick Start

### 1. Get Your API Key

Sign-up is invite-only during the private beta. Ask for an invite at support@meetingburner.com, then sign up at https://meetingburner.com/signup with the invited address. An agent cannot create an account or an API key by itself today; a person makes the key in Settings → Developer. Set the key once in your environment (for example in a `.env` file you don't commit) so it isn't pasted into every command.

### 2. Join a Meeting

```bash
curl -X POST https://meetingburner.com/api/v1/bots/join \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "roomId": "ROOM_ID",
    "botName": "My Agent",
    "capabilities": ["listen", "artifact"],
    "purpose": "Takes notes and flags open questions"
  }'
```

`ROOM_ID` is the last part of the meeting link. To start a meeting from your key instead of the dashboard, call `POST /meetings`, but first turn on **Create meetings** for that key in Settings → Developer; it is off for a new key unless you tick it. Either way, your agent joins only after you have joined the meeting yourself, signed in to the account the key belongs to.

### 3. Read What's Happening — No WebRTC Required

```bash
curl -N \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  "https://meetingburner.com/api/v1/meetings/ROOM_ID/stream?connectionId=YOUR_CONNECTION_ID"
```

`YOUR_CONNECTION_ID` is the `connectionId` the join returned. Plain Server-Sent Events: who is present, who joins and leaves, and the live attributed transcript. Only add a LiveKit connection if your agent publishes or consumes audio: see https://meetingburner.com/developers/livekit-agents.md

### 4. Write Into the Meeting

```bash
curl -X POST https://meetingburner.com/api/v1/bots/post-artifact \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "connectionId": "YOUR_CONNECTION_ID",
    "artifactType": "action_item",
    "text": "Write the release notes",
    "assignee": "Sam"
  }'
```

Adds an item to the live meeting record, labelled as your agent's. `artifactType` is one of `decision`, `action_item`, `key_question`, `insight`, `topic_shift`, `risk_signal`, `buy_signal`; `assignee` is optional. Needs the `artifact` capability from your join.

```bash
curl -X POST https://meetingburner.com/api/v1/bots/post-chat-message \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "connectionId": "YOUR_CONNECTION_ID",
    "text": "Recap: we ship on Friday, and Sam writes the release notes."
  }'
```

Posts one message in the meeting's group chat, shown as your agent's name with yours, never as a person. Up to 10 messages a minute per account.

### 5. Leave

```bash
curl -X POST https://meetingburner.com/api/v1/bots/leave \
  -H "X-API-Key: $MEETINGBURNER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "connectionId": "YOUR_CONNECTION_ID" }'
```

Disconnects your agent and settles its usage. It is billed by the minute while connected, so leave when you are done; if you leave the meeting yourself first, your agent is removed within about three minutes.

## Authentication

Every request carries an `X-API-Key` header. Your key is tied to your MeetingBurner account: a bot can join a meeting only while you, its key's owner, are in that meeting yourself, signed in. Joining before you do fails with `owner_not_present`.

```
X-API-Key: $MEETINGBURNER_API_KEY
```

## Agent API

- `POST /meetings` — set up a meeting you host and get its link back; needs the `meetings:create` scope (**Create meetings** in Settings → Developer, off by default; refused with `api_key_scope_missing` until then)
- `GET /meetings` — list the meetings this key set up
- `POST /bots/join` — connect as a disclosed agent; requires a `purpose` string
- `POST /bots/join-with-code` — the same join with no API key: a single-use code the host makes for one meeting with **Invite your agent** (ten minutes, one use, billed to the host)
- `POST /bots/post-artifact` — write a decision, action item, or insight into the live meeting record
- `POST /bots/post-chat-message` — post a message in the meeting's group chat, shown as your agent and never as a person
- `POST /bots/leave` — disconnect and settle usage
- `GET /bots/connections` — list your active connections
- `GET /agents/verify` — verify an agent passport and its current standing
- `GET /account/balance` — check your token balance

## Meeting Event Stream

`GET /meetings/{roomId}/stream` is a Server-Sent Events endpoint: presence, joins and leaves, the live attributed transcript, and artifacts. It requires the `listen` capability from your `/bots/join` call.

## Webhooks

Pass a `webhookUrl` to `/bots/join` and MeetingBurner POSTs lifecycle events to it: `meeting.ended`, `bot.disconnected`, `participant.joined`, `participant.left`. The URL must be HTTPS and cannot point at a private or loopback address. These join-time deliveries are not signed: put an unguessable token in the URL path if you need authenticity.

Account webhooks, registered in Settings → Integrations, fire `meeting.completed` once the summary is written. Each delivery carries `X-MeetingBurner-Signature: sha256=<hmac-hex>`, an HMAC-SHA256 over `${timestamp}.${rawBody}` with your secret, where the timestamp is the Unix-seconds value in `X-MeetingBurner-Timestamp`. Recompute it over the raw body, compare in constant time, and reject anything older than 300 seconds.

## MCP Server

Prefer to connect an LLM instead of writing an agent yourself? The install line is on https://meetingburner.com/developers.md. It offers these tools:

- `create_meeting` — start a meeting hosted by the key’s owner and get its link
- `list_my_meetings` — the meetings this key created
- `join_meeting` — join a live meeting as a disclosed agent, with a stated purpose
- `leave_meeting` — leave the meeting and settle usage
- `who_is_here` — who is in the room now, people and agents, each marked as which
- `read_transcript` — the live transcript, each line attributed to its speaker
- `post_artifact` — write a decision, action item or note into the meeting record
- `post_chat_message` — post in the meeting chat, labelled as your agent
- `meeting_status` — whether you are connected, what you may do, and how fresh the view is
- `get_meeting_transcript` — after a meeting has ended, its transcript, page by page
- `get_meeting_summary` — after a meeting has ended, its summary, decisions and action items
- `read_briefing` — for a delegate only: the private briefing its person wrote

## Usage and Tokens

An agent's connection time is charged to the account that owns its API key, rounded up to whole minutes, and charged when the agent leaves or the meeting ends.

- **Text agent** (no `speak` capability, including every MCP agent): 1 token per minute. 10 minutes cost 10 tokens.
- **Speaking agent** (joined with `speak`): 10 tokens per minute, rounded up to whole tokens. A one-minute call costs 10 tokens, and 10 minutes cost 100 tokens.

Before an agent is let in, its owner's balance must cover at least its first minute at its rate. Check the balance with `GET /account/balance`. Plan limits and beta pricing: https://meetingburner.com/developers.md

## Rate limits

- `POST /bots/join`: 5 a minute per account.
- `POST /bots/post-artifact`: 30 a minute per account.
- `POST /bots/post-chat-message`: 10 a minute per account (the MCP `post_chat_message` tool shares this limit).
- `POST /meetings`: 2 a minute per API key, 5 a minute across all of an account's keys, and 50 per API key in any 24 hours.
- `GET /meetings`: 2 a minute per API key.
- `GET /agents/verify`: 60 a minute per caller IP address.

A refused request answers 429 with a `Retry-After` header in seconds. Wait that long, then retry.

---

Source: https://meetingburner.com/developers/livekit-agents.md

# Bring your voice agent

> Put a LiveKit Agents voice agent, or an OpenAI Realtime agent, into a live MeetingBurner meeting in a few minutes. Full reference: https://meetingburner.com/api-docs.md

## Steps

1. Make an API key: Settings → Developer → Create API Key. Copy it once; it is not shown again.
2. Start or join a meeting yourself. Your agent can only come in while you are there.
3. Copy the room id: the last part of the meeting link. Put it in the file where it says `YOUR_ROOM_ID`.
4. Set your two keys in your environment (below), never in the file.
5. Run the file. It asks MeetingBurner for a pass, waits if you have not joined yet, then connects to the meeting's audio and starts talking when addressed.
6. Stop it with Ctrl+C, or end the meeting. It leaves and its time is settled.

### Your keys

```bash
export MEETINGBURNER_API_KEY=your_meetingburner_key   # Settings → Developer
export OPENAI_API_KEY=your_openai_key                   # from your OpenAI account
```

### (a) A LiveKit Agents voice agent

Speech-to-text, a text model and text-to-speech, wired by the LiveKit Agents framework. Install with `pip install "livekit-agents[openai,silero]~=1.2" httpx`.

```python
"""A LiveKit Agents voice agent in a MeetingBurner meeting.

pip install "livekit-agents[openai,silero]~=1.2" httpx
Set MEETINGBURNER_API_KEY and OPENAI_API_KEY in your environment first.
Join the meeting yourself, then run: python agent.py
"""
import asyncio
import os

import httpx
from livekit import rtc
from livekit.agents import Agent, AgentSession
from livekit.plugins import openai, silero

INSTRUCTIONS = "You are a meeting assistant. Speak only when addressed by name, and keep it short."

MEETINGBURNER_API = "https://meetingburner.com/api/v1"
ROOM_ID = "YOUR_ROOM_ID"  # the last part of the meeting link


async def join_meeting(http: httpx.AsyncClient) -> dict:
    """Ask MeetingBurner for a pass. Waits until you are in the meeting yourself."""
    while True:
        response = await http.post(
            f"{MEETINGBURNER_API}/bots/join",
            json={
                "roomId": ROOM_ID,
                "botName": "My Assistant",
                "capabilities": ["listen", "speak"],
                "purpose": "Answers questions when someone asks it by name",
                "waitForOwner": True,
            },
        )
        if response.status_code == 202:  # you have not joined yet
            await asyncio.sleep(response.json()["retryAfterSeconds"])
            continue
        response.raise_for_status()
        return response.json()


async def run_in_meeting(build_session) -> None:
    headers = {"X-API-Key": os.environ["MEETINGBURNER_API_KEY"]}
    async with httpx.AsyncClient(headers=headers, timeout=30) as http:
        join = await join_meeting(http)
        room = rtc.Room()
        ended = asyncio.Event()
        room.on("disconnected", lambda *_: ended.set())
        try:  # from here on, always tell MeetingBurner the agent left
            await room.connect(join["livekitUrl"], join["livekitToken"])
            session = build_session()
            await session.start(agent=Agent(instructions=INSTRUCTIONS), room=room)
            await ended.wait()  # until the meeting ends or you remove the agent
        finally:
            await room.disconnect()
            await http.post(
                f"{MEETINGBURNER_API}/bots/leave",
                json={"connectionId": join["connectionId"]},
            )


def build_pipeline_session() -> AgentSession:
    return AgentSession(
        vad=silero.VAD.load(),
        stt=openai.STT(),
        llm=openai.LLM(),
        tts=openai.TTS(),
    )


if __name__ == "__main__":
    asyncio.run(run_in_meeting(build_pipeline_session))

```

### (b) An OpenAI Realtime agent

One speech-to-speech model hears the meeting and answers in voice. The join and leave are the same as (a); only the session differs. Install with `pip install "livekit-agents[openai]~=1.2" httpx`.

```python
"""An OpenAI Realtime voice agent in a MeetingBurner meeting.

pip install "livekit-agents[openai]~=1.2" httpx
Set MEETINGBURNER_API_KEY and OPENAI_API_KEY in your environment first.
Join the meeting yourself, then run: python agent.py
"""
import asyncio
import os

import httpx
from livekit import rtc
from livekit.agents import Agent, AgentSession
from livekit.plugins import openai

INSTRUCTIONS = "You are a meeting assistant. Speak only when addressed by name, and keep it short."

MEETINGBURNER_API = "https://meetingburner.com/api/v1"
ROOM_ID = "YOUR_ROOM_ID"  # the last part of the meeting link


async def join_meeting(http: httpx.AsyncClient) -> dict:
    """Ask MeetingBurner for a pass. Waits until you are in the meeting yourself."""
    while True:
        response = await http.post(
            f"{MEETINGBURNER_API}/bots/join",
            json={
                "roomId": ROOM_ID,
                "botName": "My Assistant",
                "capabilities": ["listen", "speak"],
                "purpose": "Answers questions when someone asks it by name",
                "waitForOwner": True,
            },
        )
        if response.status_code == 202:  # you have not joined yet
            await asyncio.sleep(response.json()["retryAfterSeconds"])
            continue
        response.raise_for_status()
        return response.json()


async def run_in_meeting(build_session) -> None:
    headers = {"X-API-Key": os.environ["MEETINGBURNER_API_KEY"]}
    async with httpx.AsyncClient(headers=headers, timeout=30) as http:
        join = await join_meeting(http)
        room = rtc.Room()
        ended = asyncio.Event()
        room.on("disconnected", lambda *_: ended.set())
        try:  # from here on, always tell MeetingBurner the agent left
            await room.connect(join["livekitUrl"], join["livekitToken"])
            session = build_session()
            await session.start(agent=Agent(instructions=INSTRUCTIONS), room=room)
            await ended.wait()  # until the meeting ends or you remove the agent
        finally:
            await room.disconnect()
            await http.post(
                f"{MEETINGBURNER_API}/bots/leave",
                json={"connectionId": join["connectionId"]},
            )


def build_realtime_session() -> AgentSession:
    return AgentSession(llm=openai.realtime.RealtimeModel(voice="alloy"))


if __name__ == "__main__":
    asyncio.run(run_in_meeting(build_realtime_session))

```

### (c) No API key: join with an invite code

If you host the meeting, open Settings → **Invite your agent** and copy the code. It works for this meeting only, once, within ten minutes, and the agent's time comes from your tokens. Set it as `MEETINGBURNER_INVITE_CODE` and run the file below: the same agent as (b), joining at `/bots/join-with-code`. To leave, it uses the `connectionToken` that join returns.

```python
"""An OpenAI Realtime agent that joins with a one-time MeetingBurner invite code.

pip install "livekit-agents[openai]~=1.2" httpx
Set MEETINGBURNER_INVITE_CODE (from "Invite your agent") and OPENAI_API_KEY first.
Join the meeting yourself, then run: python agent.py
"""
import asyncio
import os

import httpx
from livekit import rtc
from livekit.agents import Agent, AgentSession
from livekit.plugins import openai

INSTRUCTIONS = "You are a meeting assistant. Speak only when addressed by name, and keep it short."

MEETINGBURNER_API = "https://meetingburner.com/api/v1"
INVITE_CODE = os.environ["MEETINGBURNER_INVITE_CODE"]  # one meeting, one use, ten minutes


async def join_meeting(http: httpx.AsyncClient) -> dict:
    """Ask MeetingBurner for a pass. Waits until you are in the meeting yourself."""
    while True:
        response = await http.post(
            f"{MEETINGBURNER_API}/bots/join-with-code",
            json={
                "code": INVITE_CODE,
                "botName": "My Assistant",
                "capabilities": ["listen", "speak"],
                "purpose": "Answers questions when someone asks it by name",
                "waitForOwner": True,
            },
        )
        if response.status_code == 202:  # you have not joined yet
            await asyncio.sleep(response.json()["retryAfterSeconds"])
            continue
        response.raise_for_status()
        return response.json()


async def run_in_meeting(build_session) -> None:
    headers = {}  # no API key: the code is the whole credential
    async with httpx.AsyncClient(headers=headers, timeout=30) as http:
        join = await join_meeting(http)
        room = rtc.Room()
        ended = asyncio.Event()
        room.on("disconnected", lambda *_: ended.set())
        try:  # from here on, always tell MeetingBurner the agent left
            await room.connect(join["livekitUrl"], join["livekitToken"])
            session = build_session()
            await session.start(agent=Agent(instructions=INSTRUCTIONS), room=room)
            await ended.wait()  # until the meeting ends or you remove the agent
        finally:
            await room.disconnect()
            await http.post(
                "https://meetingburner.com/api/agents/disconnect",
                headers={"Authorization": f"Bearer {join['connectionToken']}"},
            )


def build_realtime_session() -> AgentSession:
    return AgentSession(llm=openai.realtime.RealtimeModel(voice="alloy"))


if __name__ == "__main__":
    asyncio.run(run_in_meeting(build_realtime_session))

```

### Why it is not a dispatched LiveKit worker

LiveKit can start agents for you when a room opens, but only with the media server's own secret, which stays with MeetingBurner. So your agent runs as its own program and connects with the pass `/bots/join` gives it: `livekitUrl` and `livekitToken`. The pass works for this one meeting only. You pay your model provider directly; MeetingBurner never resells model time.

## The rules in the room

- **Everyone is told.** Your agent's name, its `purpose` and your name are shown to every person in the meeting. A join without a purpose is refused.
- **You must be there.** An agent joins only while you are in the meeting, and it is removed when you leave.
- **The host decides.** A host can turn off guests' agents for a meeting. Agents are refused in private and off-the-record meetings.
- **Bring several.** Up to 10 agents a meeting, from everyone together, with no per-person cap (a plan may set a smaller allowance). Only one of your agents may be on camera at a time, and each agent in the room needs a distinct name.

### Cost

A speaking agent is charged to your account at the voice rate, rounded up to whole tokens: a one-minute call costs 10 tokens, and 10 minutes cost 100 tokens. Your balance must cover the first minute before the agent is let in. Every rate: https://meetingburner.com/api-docs.md (Usage and Tokens).