> ## Documentation Index
> Fetch the complete documentation index at: https://plivo.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Conference

> Connect multiple callers in a shared conference room with moderation and recording

The `<Conference>` element connects a caller to a conference room. Multiple callers joining the same conference name are connected together. Maximum participants per conference: 20.

<Info>
  For role-based multi-party calls with coaching, individual hold/mute, and AI agent support, see [Multi-party Call](/voice/xml/multiparty-call/).
</Info>

### Basic Usage

```xml theme={null}
<Response>
    <Conference>my-conference-room</Conference>
</Response>
```

<CodeGroup>
  ```python Python theme={null}
  from plivo import plivoxml

  response = plivoxml.ResponseElement()
  response.add(plivoxml.ConferenceElement('my-conference-room'))
  print(response.to_string())
  ```

  ```javascript Node.js theme={null}
  const plivo = require('plivo');

  const response = plivo.Response();
  response.addConference('my-conference-room');
  console.log(response.toXML());
  ```

  ```ruby Ruby theme={null}
  require 'plivo'

  include Plivo::XML

  response = Response.new
  response.addConference('my-conference-room')
  puts PlivoXML.new(response).to_xml
  ```

  ```php PHP theme={null}
  <?php
  require 'vendor/autoload.php';
  use Plivo\XML\Response;

  $response = new Response();
  $response->addConference('my-conference-room');
  echo $response->toXML();
  ```

  ```java Java theme={null}
  import com.plivo.api.xml.*;

  Response response = new Response()
      .children(new Conference("my-conference-room"));
  System.out.println(response.toXmlString());
  ```

  ```csharp .NET theme={null}
  using Plivo.XML;

  var response = new Response();
  response.AddConference("my-conference-room");
  Console.WriteLine(response.ToString());
  ```

  ```go Go theme={null}
  package main

  import "github.com/plivo/plivo-go/v7/xml"

  func main() {
      response := xml.ResponseElement{
          Contents: []interface{}{
              new(xml.ConferenceElement).SetContents("my-conference-room"),
          },
      }
      print(response.String())
  }
  ```
</CodeGroup>

***

## Conference Attributes

### Basic Settings

| Attribute      | Type    | Default | Description                                |
| -------------- | ------- | ------- | ------------------------------------------ |
| `muted`        | boolean | `false` | Join muted (can still hear others)         |
| `enterSound`   | string  | `""`    | Sound on entry: `beep:1`, `beep:2`, or URL |
| `exitSound`    | string  | `""`    | Sound on exit: `beep:1`, `beep:2`, or URL  |
| `maxMembers`   | integer | `20`    | Maximum participants (1-20)                |
| `timeLimit`    | integer | `86400` | Max conference duration in seconds         |
| `hangupOnStar` | boolean | `false` | Let member exit by pressing \*             |
| `stayAlone`    | boolean | `true`  | End conference if only one member          |

### Moderation

| Attribute                | Type    | Default | Description                                         |
| ------------------------ | ------- | ------- | --------------------------------------------------- |
| `startConferenceOnEnter` | boolean | `true`  | Start conference when this member joins             |
| `endConferenceOnExit`    | boolean | `false` | End conference when this member leaves              |
| `waitSound`              | URL     | -       | Audio to play while waiting for conference to start |

### Recording

| Attribute             | Type    | Default | Description                                                                                |
| --------------------- | ------- | ------- | ------------------------------------------------------------------------------------------ |
| `record`              | boolean | `false` | Record the conference                                                                      |
| `recordFileFormat`    | string  | `mp3`   | Recording format (`mp3`, `wav`)                                                            |
| `transcriptionType`   | string  | -       | Transcription type. Values: `auto`, `hybrid`, `manual`                                     |
| `transcriptionUrl`    | URL     | -       | URL to receive transcription                                                               |
| `transcriptionMethod` | string  | `POST`  | HTTP method for sending transcription results to `transcriptionUrl`. Values: `GET`, `POST` |

### Callbacks

| Attribute        | Type    | Default | Description                   |
| ---------------- | ------- | ------- | ----------------------------- |
| `action`         | URL     | -       | URL called when member leaves |
| `method`         | string  | `POST`  | HTTP method for action        |
| `callbackUrl`    | URL     | -       | URL for conference events     |
| `callbackMethod` | string  | `POST`  | HTTP method for callback      |
| `redirect`       | boolean | `true`  | Redirect to action URL        |

### DTMF

| Attribute     | Type    | Default | Description                             |
| ------------- | ------- | ------- | --------------------------------------- |
| `digitsMatch` | string  | -       | DTMF patterns to report                 |
| `floorEvent`  | boolean | `false` | Notify when member becomes floor-holder |
| `relayDTMF`   | boolean | `true`  | Transmit DTMF to all members            |

***

## Examples

### Join Muted

Add participants who can listen but not speak:

```xml theme={null}
<Response>
    <Conference muted="true">my-conference-room</Conference>
</Response>
```

### Entry/Exit Sounds

Play beeps when participants join or leave:

```xml theme={null}
<Response>
    <Conference enterSound="beep:1" exitSound="beep:2">
        my-conference-room
    </Conference>
</Response>
```

Use a URL to play custom audio:

```xml theme={null}
<Response>
    <Conference enterSound="https://example.com/join-sound.xml">
        my-conference-room
    </Conference>
</Response>
```

The URL must return XML with `Play`, `Speak`, or `Wait` elements.

### Moderated Conference

Create a "waiting room" where participants wait for the moderator:

**Participant XML:**

```xml theme={null}
<Response>
    <Conference startConferenceOnEnter="false" waitSound="https://example.com/hold-music.xml">
        moderated-meeting
    </Conference>
</Response>
```

**Moderator XML:**

```xml theme={null}
<Response>
    <Conference startConferenceOnEnter="true" endConferenceOnExit="true">
        moderated-meeting
    </Conference>
</Response>
```

When the moderator joins, the conference starts. When they leave, everyone is disconnected.

### Record Conference

```xml theme={null}
<Response>
    <Conference record="true" recordFileFormat="mp3"
                callbackUrl="https://example.com/recording-ready/">
        recorded-meeting
    </Conference>
</Response>
```

<CodeGroup>
  ```python Python theme={null}
  from plivo import plivoxml

  response = plivoxml.ResponseElement()
  response.add(plivoxml.ConferenceElement(
      'recorded-meeting',
      record=True,
      record_file_format='mp3',
      callback_url='https://example.com/recording-ready/'
  ))
  print(response.to_string())
  ```

  ```javascript Node.js theme={null}
  const plivo = require('plivo');

  const response = plivo.Response();
  response.addConference('recorded-meeting', {
      record: true,
      recordFileFormat: 'mp3',
      callbackUrl: 'https://example.com/recording-ready/'
  });
  console.log(response.toXML());
  ```

  ```ruby Ruby theme={null}
  require 'plivo'

  response = Plivo::XML::Response.new
  response.addConference('recorded-meeting',
      record: true,
      recordFileFormat: 'mp3',
      callbackUrl: 'https://example.com/recording-ready/'
  )
  puts Plivo::XML::PlivoXML.new(response).to_xml
  ```

  ```php PHP theme={null}
  <?php
  require 'vendor/autoload.php';
  use Plivo\XML\Response;

  $response = new Response();
  $response->addConference('recorded-meeting', [
      'record' => true,
      'recordFileFormat' => 'mp3',
      'callbackUrl' => 'https://example.com/recording-ready/'
  ]);
  echo $response->toXML();
  ```
</CodeGroup>

### With Transcription

```xml theme={null}
<Response>
    <Conference record="true"
                transcriptionType="auto"
                transcriptionUrl="https://example.com/transcription/">
        transcribed-meeting
    </Conference>
</Response>
```

### Exit with Action URL

```xml theme={null}
<Response>
    <Conference action="https://example.com/conference-ended/"
                hangupOnStar="true">
        my-conference
    </Conference>
</Response>
```

### Bridge Two Callers

Use conferences to connect two incoming callers:

**First Caller:**

```xml theme={null}
<Response>
    <Conference waitSound="https://example.com/hold.xml">
        private-bridge-123
    </Conference>
</Response>
```

**Second Caller:**

```xml theme={null}
<Response>
    <Conference>private-bridge-123</Conference>
</Response>
```

***

## Callback Parameters

### Conference Action URL Parameters

Sent when a member leaves the conference:

| Parameter            | Description                   |
| -------------------- | ----------------------------- |
| `ConferenceName`     | Name of the conference        |
| `ConferenceUUID`     | Unique conference identifier  |
| `ConferenceMemberID` | Member's ID in the conference |
| `RecordUrl`          | Recording URL (if recorded)   |
| `RecordingID`        | Recording identifier          |

### Conference Callback URL Parameters

Sent for conference events:

| Parameter               | Description                                     |
| ----------------------- | ----------------------------------------------- |
| `ConferenceAction`      | `enter`, `exit`, `digits`, `floor`, `record`    |
| `ConferenceName`        | Conference name                                 |
| `ConferenceUUID`        | Conference identifier                           |
| `ConferenceMemberID`    | Member ID                                       |
| `CallUUID`              | Call identifier                                 |
| `ConferenceDigitsMatch` | Matched digits (when `ConferenceAction=digits`) |
| `RecordUrl`             | Recording URL (when `ConferenceAction=record`)  |
| `RecordingID`           | Recording ID                                    |
| `RecordingDuration`     | Duration in seconds                             |
| `RecordingDurationMs`   | Duration in milliseconds                        |
| `RecordingStartMs`      | Start time (epoch ms)                           |
| `RecordingEndMs`        | End time (epoch ms)                             |

### Transcription URL Parameters

| Parameter              | Description            |
| ---------------------- | ---------------------- |
| `transcription`        | Transcribed text       |
| `transcription_charge` | Cost of transcription  |
| `transcription_rate`   | Rate per minute        |
| `duration`             | Recording duration     |
| `call_uuid`            | Call identifier        |
| `recording_id`         | Recording identifier   |
| `error`                | Error message (if any) |

***

## Related

* [Multi-party Call](/voice/xml/multiparty-call/) — Role-based calls with coaching, AI agents, and advanced controls
* [Recording](/voice/xml/record/) — Record calls
* [Call Routing](/voice/xml/routing/) — Dial, Redirect, Hangup