Conference

Create and manage multi-party conference calls with support for recording, muting, and participant control. Conferences allow multiple call legs to be bridged into a single shared audio session.

API Reference: Conference endpoints

Overview

Note

AI Context

Complexity: Medium-High
Cost: Chargeable (credit deduction per conference minute per participant)
Async: Yes. POST /conferences returns immediately with status starting. Poll GET /conferences/{id} or subscribe via WebSocket to track conference status changes.

The Conference API is a powerful low-level API that empowers developers to create conference rooms capable of accommodating various forms of communication, including voice, video, and chat. At its core, the API revolves around the concept of conferences, which act as containers for communications exchanged between two or more users. These communications may represent single interactions or a complete history of all interactions between the participants.

Additionally, the Conference API allows developers to establish voice, video, and WebRTC (Web Real-Time Communication) calls, enabling seamless voice and video communication between two users. These calls can be stored within the conferences, ensuring that all relevant communications are organized and easily accessible.

By leveraging the Conference API, developers can build robust communication applications with the capability to host multi-user conferences and support various communication modes. The API’s flexibility and functionality provide a foundation for creating feature-rich and scalable communication solutions to meet diverse user needs. Whether for collaboration, remote meetings, customer support, or any other scenario requiring real-time communication, the Conference API offers a reliable and efficient means to establish and manage communication sessions between multiple users.

How Conferences Work

A conference is a virtual room where multiple participants can communicate. Understanding the architecture helps you build reliable applications.

Conference Architecture

+-------------------------------------------------------------------------+
|                      Conference Architecture                            |
+-------------------------------------------------------------------------+

Application Layer                         Infrastructure Layer
+-------------------------+              +-------------------------+
|      Conference         |              |       Confbridge        |
|   (conference-manager)  |              |    (call-manager)       |
|                         |              |                         |
|  • Participant list     |--------------|  • Audio mixing         |
|  • Recording control    |   manages    |  • Voice bridge         |
|  • Transcription        |              |  • Join/leave events    |
|  • Metadata & state     |              |  • Media streams        |
+-------------------------+              +-------------------------+
          |                                        |
          |                                        |
          v                                        v
+-------------------------------------------------------------------------+
|                         Participants (Calls)                            |
|                                                                         |
|  +----------+    +----------+    +----------+    +----------+           |
|  | Call A   |    | Call B   |    | Call C   |    | Call D   |           |
|  | (phone)  |    | (WebRTC) |    | (SIP)    |    | (phone)  |           |
|  +----------+    +----------+    +----------+    +----------+           |
|                                                                         |
|                     All audio mixed together                            |
+-------------------------------------------------------------------------+

Key Concepts

Conference: High-level container that manages participants, recording, and transcription
Confbridge: Low-level audio bridge that actually mixes the audio
Conferencecall: A participant in the conference (links a call to a conference)

Conference Lifecycle

Every conference moves through a predictable set of states.

State Diagram

+-------------------------------------------------------------------------+
|                     Conference State Machine                            |
+-------------------------------------------------------------------------+

                POST /v1/conferences
                       |
                       v
                +------------+
                |  starting  | (brief initialization)
                +-----+------+
                      |
                      v
                +------------+
                |progressing |<--------------------------------+
                |  (active)  |                                 |
                +-----+------+                                 |
                      |                                        |
                      | DELETE or timeout                      |
                      v                                        |
                +------------+      still has                  |
                |terminating |------participants --------------+
                | (closing)  |
                +-----+------+
                      |
                      | all participants left
                      v
                +------------+
                | terminated |
                |  (closed)  |
                +------------+

State Descriptions

Status	What’s happening
starting	Conference is being initialized. Brief transitional state.
progressing	Conference is active. Participants can join, recording can start.
terminating	Conference is closing. No new participants. Waiting for everyone to leave.
terminated	Conference is completely closed. No further operations possible.

Participant Lifecycle

Each participant (conferencecall) has their own lifecycle independent of the conference.

Participant States

+-------------------------------------------------------------------------+
|                   Participant (Conferencecall) States                   |
+-------------------------------------------------------------------------+

     Flow triggers join
            |
            v
     +------------+
     |  joining   |  (pre-flow executing, connecting to bridge)
     +-----+------+
           |
           | audio connected
           v
     +------------+
     |   joined   |  (actively in conference, can hear/speak)
     +-----+------+
           |
           | hangup or kicked
           v
     +------------+
     |  leaving   |  (being removed from bridge)
     +-----+------+
           |
           | fully disconnected
           v
     +------------+
     |   leaved   |  (no longer in conference)
     +------------+

Status	What’s happening
joining	Participant is connecting. Pre-conference flow may be executing.
joined	Participant is active. Audio is flowing. Can hear and speak.
leaving	Participant is being disconnected from the conference.
leaved	Participant has fully left. No longer part of the conference.

Joining a Conference

When a participant joins a conference, a coordinated sequence occurs.

Join Sequence

+-------------------------------------------------------------------------+
|                      Participant Join Sequence                          |
+-------------------------------------------------------------------------+

Flow                    Conference-Manager              Call-Manager
  |                            |                             |
  | conference_join action     |                             |
  |--------------------------->|                             |
  |                            |                             |
  |                            | Create conferencecall       |
  |                            | status: joining             |
  |                            |                             |
  |                            | Pre-flow? Execute it        |
  |                            |                             |
  |                            | Push confbridge_join        |
  |                            |---------------------------->|
  |                            |                             |
  |                            |                             | Connect call
  |                            |                             | to audio bridge
  |                            |                             |
  |                            |   confbridge_joined event   |
  |                            |<----------------------------|
  |                            |                             |
  |                            | Update conferencecall       |
  |                            | status: joined              |
  |                            |                             |
  |                            | Add to participant list     |
  |                            |                             |
  |<---------------------------|                             |
  |    Continue flow           |                             |

What Happens at Each Step

Flow Action: Your flow executes a conference_join action
Conferencecall Created: A participant record is created with status “joining”
Pre-Flow (Optional): If configured, a welcome flow plays (greeting, instructions)
Audio Connected: The call’s audio is routed to the conference bridge
Joined: Participant can now hear and be heard by others in the conference

Leaving a Conference

Participants can leave naturally (hangup) or be removed via API.

Natural Leave (Call Ends)

+-------------------------------------------------------------------------+
|                    Natural Leave (Participant Hangup)                   |
+-------------------------------------------------------------------------+

Participant              Call-Manager              Conference-Manager
    |                         |                            |
    | Hangs up phone          |                            |
    |------------------------>|                            |
    |                         |                            |
    |                         | Detects leave from bridge  |
    |                         |                            |
    |                         |  confbridge_leaved event   |
    |                         |--------------------------->|
    |                         |                            |
    |                         |                            | Update status
    |                         |                            | to "leaved"
    |                         |                            |
    |                         |                            | Remove from
    |                         |                            | participant list
    |                         |                            |

Forced Removal (API)

DELETE /v1/conferencecalls/{participant-id}
                 |
                 v
+----------------------------------------+
| 1. Validate participant is in          |
|    "joining" or "joined" status        |
|                                        |
| 2. Update status to "leaving"          |
|                                        |
| 3. Send kick request to confbridge     |
|                                        |
| 4. Confbridge removes participant      |
|                                        |
| 5. confbridge_leaved event fires       |
|                                        |
| 6. Update status to "leaved"           |
+----------------------------------------+

Conference Types

VoIPBIN supports different conference types for different use cases.

Type: Conference (Standard)

+-------------------------------------------------------------------------+
|                    Type: Conference (Multi-Party)                       |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+
|                        Conference Room                                  |
|                                                                         |
|   +------+    +------+    +------+    +------+    +------+              |
|   |User A|    |User B|    |User C|    |User D|    |User E|              |
|   +------+    +------+    +------+    +------+    +------+              |
|                                                                         |
|   • Supports 2+ participants                                            |
|   • Remains active even with 0 or 1 participant                         |
|   • Only terminates when explicitly deleted                             |
|   • Recording captures all participants                                 |
|                                                                         |
+-------------------------------------------------------------------------+

Note

AI Implementation Hint

The type field is immutable after creation. Choose conference for multi-party rooms (2+ participants, stays active until explicitly deleted) or connect for 1:1 bridges (auto-terminates when either party leaves). If unsure, default to conference since it handles both single and multi-party scenarios.

Type: Connect (1:1 Bridge)

+-------------------------------------------------------------------------+
|                      Type: Connect (Two-Party)                          |
+-------------------------------------------------------------------------+

+-------------------------------------------------------------------------+
|                        Connect Bridge                                   |
|                                                                         |
|         +------------+              +------------+                      |
|         |  Caller    |<------------>|   Agent    |                      |
|         +------------+              +------------+                      |
|                                                                         |
|   • Designed for exactly 2 participants                                 |
|   • Auto-ejects remaining participant when one leaves                   |
|   • Useful for customer-agent calls                                     |
|   • Conference terminates when empty                                    |
|                                                                         |
+-------------------------------------------------------------------------+

When one participant leaves:
+----------+           +----------+
|  Caller  |           |  Agent   |
|  leaves  |---------->| AUTO-KICK|
+----------+           +----------+
                             |
                             v
                   Conference terminates

Recording

Conferences support recording all participant audio into a single file.

Starting a Recording

POST /v1/conferences/{id}/recording_start

+-------------------------------------------------------------------------+
|                     Recording Active                                    |
+-------------------------------------------------------------------------+

Conference
+-------------------------------------------------------------------------+
|                                                                         |
|   +------+    +------+    +------+                                      |
|   |User A|    |User B|    |User C|                                      |
|   +--+---+    +--+---+    +--+---+                                      |
|      |           |           |                                          |
|      +-----------+-----------+                                          |
|                  |                                                      |
|                  v                                                      |
|          +-------------+                                                |
|          |  Recording  |                                                |
|          |    File     |                                                |
|          +-------------+                                                |
|                                                                         |
|   recording_id: "abc-123"  (current active recording)                   |
|   recording_ids: ["abc-123", ...]  (all recordings history)             |
|                                                                         |
+-------------------------------------------------------------------------+

Note

AI Implementation Hint

Recording and transcription can only start when the conference status is progressing. If you attempt POST /conferences/{id}/recording_start on a conference in starting or terminating status, the request will fail. Always poll GET /conferences/{id} and verify status is progressing before starting recording or transcription.

Recording Rules

Only one active recording per conference at a time
Recording can only start when conference is in “progressing” status
All participant audio is mixed into a single recording
Maximum duration: 24 hours
Recording history is preserved in recording_ids array

Stopping a Recording

POST /v1/conferences/{id}/recording_stop

• Stops active recording
• Clears recording_id field
• Recording file becomes available for download

Transcription

Real-time transcription converts conference audio to text.

Starting Transcription

POST /v1/conferences/{id}/transcribe_start

+-------------------------------------------------------------------------+
|                    Transcription Active                                 |
+-------------------------------------------------------------------------+

Conference Audio                              Transcription Service
+---------------------+                      +---------------------+
| User A: "Hello"     |                      |                     |
| User B: "Hi there"  |--------------------->|  Speech-to-Text     |
| User C: "Welcome"   |      audio stream    |                     |
+---------------------+                      +----------+----------+
                                                        |
                                                        v
                                             +---------------------+
                                             | Transcript Output   |
                                             | "Hello. Hi there.   |
                                             |  Welcome."          |
                                             +---------------------+

Transcription Rules

Only one active transcription per conference at a time
Can only start when conference is in “progressing” status
Language must be specified for accurate transcription
History preserved in transcribe_ids array

Recording and Transcription Together

For complete conference documentation, you can run recording and transcription simultaneously.

Combined Setup

+---------------------------------------------------------------+
|                    Conference                                 |
|  +------+    +------+    +------+                             |
|  |User A|    |User B|    |User C|                             |
|  +--+---+    +--+---+    +--+---+                             |
|     |           |           |                                 |
|     +-----+-----+-----+-----+                                 |
|           |           |                                       |
|           v           v                                       |
|     +----------+  +-------------+                             |
|     |Recording |  |Transcription|                             |
|     |  File    |  |   Stream    |                             |
|     +----------+  +------+------+                             |
+---------------------------------------------------------------+
                           |
                           v
                    +-----------+
                    | Your App  |
                    | (webhook) |
                    +-----------+

Sequence

1. Create conference
   POST /v1.0/conferences

2. Start recording
   POST /v1.0/conferences/{id}/recording_start

3. Start transcription
   POST /v1.0/conferences/{id}/transcribe_start
   { "language": "en-US" }

4. Participants join and talk
   → Recording captures all audio
   → Transcripts stream to webhook

5. Stop transcription
   POST /v1.0/conferences/{id}/transcribe_stop

6. Stop recording
   POST /v1.0/conferences/{id}/recording_stop

7. Result: Audio file + searchable text transcripts

Use Cases for Combined Recording + Transcription

Use Case	Benefit
Compliance	Full audio archive + searchable text records
Meeting minutes	Auto-generated text from recording
Quality assurance	Review both audio and transcript
Legal documentation	Verifiable audio + readable transcript

Timeout and Auto-Cleanup

Conferences can be configured to automatically terminate after a period.

Timeout Behavior

+-------------------------------------------------------------------------+
|                     Conference Timeout                                  |
+-------------------------------------------------------------------------+

Conference created                                      Timeout expires
with timeout: 3600 (1 hour)                             |
     |                                                  |
     v                                                  v
-----o--------------------------------------------------o------------->
     |<------------- 3600 seconds --------------------->|    Time
     |                                                  |
     | Conference is progressing                        | Auto-terminate
     | Participants can join/leave                      | All participants
     |                                                  | kicked

Set timeout when creating the conference (in seconds)
When timeout expires, conference moves to “terminating”
All remaining participants are kicked
Conference transitions to “terminated”

Auto-Cleanup When Empty

Conference in "terminating" status
            |
            v
+------------------------+
| Any participants left? |
+-----------+------------+
            |
   +--------+--------+
   |                 |
  Yes               No
   |                 |
   v                 v
Wait for them    Conference destroyed
to leave         Status: terminated

Health Checks

The system continuously monitors participant health.

Health Check Process

+-------------------------------------------------------------------------+
|                    Participant Health Checks                            |
+-------------------------------------------------------------------------+

Every 5 seconds, for each participant:

+----------------------------------------+
| 1. Is the participant's call still     |
|    in "progressing" status?            |
|                                        |
| 2. Is the conference still in          |
|    "progressing" status?               |
|                                        |
| 3. Was the participant created less    |
|    than 24 hours ago?                  |
+----------------------------------------+
                 |
        +--------+--------+
        |                 |
     All Yes          Any No
        |                 |
        v                 v
   Continue         Remove participant
   monitoring       (after 2 retries)

Common Scenarios

Scenario 1: Simple Conference Call

1. Create conference
   POST /v1/conferences
   → Conference in "progressing" status

2. Participants join through flow
   +----------+  +----------+  +----------+
   | User A   |  | User B   |  | User C   |
   |  joins   |  |  joins   |  |  joins   |
   +----------+  +----------+  +----------+

3. All can hear each other

4. Users hang up one by one

5. Delete conference when done
   DELETE /v1/conferences/{id}

Scenario 2: Recorded Meeting

Create conference
Start recording
   POST /v1/conferences/{id}/recording_start
Participants join and talk
Stop recording
   POST /v1/conferences/{id}/recording_stop
Recording file available for download

Scenario 3: Customer-Agent Connect

1. Create connect-type conference
   POST /v1/conferences
   { "type": "connect" }

2. Customer call joins
3. Agent call joins
4. Customer and agent talk

5. When either hangs up:
   → Other is auto-ejected
   → Conference terminates

Events and Webhooks

Conference changes trigger events you can subscribe to.

Event Types

+-------------------------------------------------------------------------+
|                     Conference Events                                   |
+-------------------------------------------------------------------------+

Event                    When it fires
-------------------------------------------------------------------------
conference_created       Conference is created
conference_updated       Participant joins/leaves, recording starts/stops
conference_deleted       Conference is terminated

Best Practices

1. Choose the Right Conference Type

Use Case                          Type
----------------------------------------------------
Team meeting (3+ people)          conference
Customer support call             connect
Webinar/broadcast                 conference

2. Set Appropriate Timeouts

• Short meetings: timeout: 3600 (1 hour)
• Long workshops: timeout: 14400 (4 hours)
• Persistent rooms: timeout: 0 (no timeout)

3. Handle Participant Lifecycle

Subscribe to conference_updated events to track joins/leaves
Implement cleanup logic when all participants leave
Consider pre-flows for instructions or greetings

4. Recording Best Practices

Notify participants that recording is active (legal requirement)
Set reasonable duration limits
Download and store recordings promptly

Conference

{
    "id": "<string>",
    "customer_id": "<string>",
    "type": "<string>",
    "status": "<string>",
    "name": "<string>",
    "detail": "<string>",
    "data": {},
    "timeout": <integer>,
    "pre_actions": [
        {
            ...
        }
    ],
    "post_actions": [
        {
            ...
        }
    ],
    "conferencecall_ids": [
        ...
    ],
    "recording_id": "<string>",
    "recording_ids": [
        ...
    ],
    "tm_create": "<string>",
    "tm_update": "<string>",
    "tm_delete": "<string>"
}

id (UUID): The conference’s unique identifier. Returned when creating via POST /conferences or listing via GET /conferences.
customer_id (UUID): The customer who owns this conference. Obtained from GET /customers.
type (enum string): The conference’s type. Immutable after creation. See Type.
status (enum string): The conference’s current status. See Status.
name (String): Human-readable name for the conference.
detail (String): Detailed description of the conference.
data (Object): Reserved for future use.
timeout (Integer): Conference auto-termination timeout in seconds. Set to 0 for no timeout.
pre_actions (Array of Object): Flow actions executed when a participant joins (e.g., greeting message). Each element follows the Action structure.
post_actions (Array of Object): Flow actions executed when a participant leaves. Each element follows the Action structure.
conferencecall_ids (Array of UUID): List of participant IDs currently in the conference. Each ID can be used with GET /conferencecalls/{id} to retrieve participant details.
recording_id (UUID): The currently active recording’s ID. Obtained from GET /recordings. Set to 00000000-0000-0000-0000-000000000000 if no recording is active.
recording_ids (Array of UUID): List of all recording IDs created during this conference’s lifetime. Each ID can be used with GET /recordings/{id} to retrieve the recording.
tm_create (String, ISO 8601): Timestamp when the conference was created.
tm_update (String, ISO 8601): Timestamp of the last update to any conference property.
tm_delete (String, ISO 8601): Timestamp when the conference was deleted.

Note

AI Implementation Hint

Timestamps set to 9999-01-01 00:00:00.000000 indicate the event has not yet occurred. For example, tm_delete with this value means the conference is still active.

Example

{
    "id": "99accfb7-c0dd-4a54-997d-dd18af7bc280",
    "customer_id": "5e4a0680-804e-11ec-8477-2fea5968d85b",
    "type": "conference",
    "status": "progressing",
    "name": "test conference",
    "detail": "test conference for example.",
    "data": {},
    "timeout": 0,
    "pre_actions": [
        {
            "id": "00000000-0000-0000-0000-000000000000",
            "next_id": "00000000-0000-0000-0000-000000000000",
            "type": "talk",
            "option": {
                "text": "Hello. Welcome to the test conference.",
                "language": "en-US"
            }
        }
    ],
    "post_actions": [
        {
            "id": "00000000-0000-0000-0000-000000000000",
            "next_id": "00000000-0000-0000-0000-000000000000",
            "type": "talk",
            "option": {
                "text": "The conference has closed. Thank you. Good bye.",
                "language": "en-US"
            }
        }
    ],
    "conferencecall_ids": [],
    "recording_id": "00000000-0000-0000-0000-000000000000",
    "recording_ids": [],
    "tm_create": "2022-02-03 06:08:56.672025",
    "tm_update": "2022-08-06 19:11:13.040418",
    "tm_delete": "9999-01-01 00:00:00.000000"
}

Type

Conference’s type (enum string). Immutable after creation.

Type	Description
conference	Multi-party conference room. Supports 2+ participants. Remains active even with 0 or 1 participant. Only terminates when explicitly deleted or timeout expires.
connect	Two-party bridge. Designed for exactly 2 participants (e.g., customer-agent). Auto-ejects the remaining participant when one leaves, then terminates.

Status

Conference’s current status (enum string). States only move forward, never backward.

Status	Description
starting	Conference is being initialized. Brief transitional state. No operations (recording, transcription) are possible yet.
progressing	Conference is active. Participants can join, recording and transcription can start. This is the main operational state.
terminating	Conference is closing. No new participants can join. Waiting for existing participants to leave.
terminated	Conference is completely closed. No further operations are possible. This is the final state.

conferencecall

Conferencecall

{
    "id": "<string>",
    "customer_id": "<string>",
    "conference_id": "<string>",
    "reference_type": "<string>",
    "reference_id": "<string>",
    "status": "<string>",
    "tm_create": "<string>",
    "tm_update": "<string>",
    "tm_delete": "<string>"
}

id (UUID): The conferencecall’s unique identifier. Returned when a participant joins a conference or when listing via GET /conferencecalls.
customer_id (UUID): The customer who owns this conferencecall. Obtained from GET /customers.
conference_id (UUID): The conference this participant belongs to. Obtained from GET /conferences.
reference_type (enum string): The type of the referenced resource. See Reference type.
reference_id (UUID): The ID of the referenced resource (e.g., a call ID). Obtained from GET /calls/{id} when reference_type is call.
status (enum string): The conferencecall’s current status. See Status.
tm_create (String, ISO 8601): Timestamp when the conferencecall was created.
tm_update (String, ISO 8601): Timestamp of the last update to any conferencecall property.
tm_delete (String, ISO 8601): Timestamp when the conferencecall was deleted.

Note

AI Implementation Hint

Timestamps set to 9999-01-01 00:00:00.000000 indicate the event has not yet occurred. For example, tm_delete with this value means the participant record still exists. To remove a participant from a conference, use DELETE /conferencecalls/{id}.

Example

{
    "id": "b8aa51f6-5cc1-40ba-9737-45ca24dab153",
    "customer_id": "5e4a0680-804e-11ec-8477-2fea5968d85b",
    "conference_id": "99accfb7-c0dd-4a54-997d-dd18af7bc280",
    "reference_type": "call",
    "reference_id": "7cb70145-a20a-4070-8b23-9131410d301d",
    "status": "leaved",
    "tm_create": "2022-08-06 16:57:12.247946",
    "tm_update": "2022-08-06 19:09:47.349667",
    "tm_delete": "9999-01-01 00:00:00.000000"
}

Reference type

The type of resource participating in the conference (enum string).

Type	Description
call	The participant is a call. The `reference_id` is a call ID obtainable from `GET /calls`.

Status

The conferencecall’s current status (enum string). States only move forward, never backward.

Status	Description
joining	The call is connecting to the conference. Pre-conference flow actions may be executing (e.g., greeting message).
joined	The call is active in the conference. Audio is flowing. The participant can hear and speak with others.
leaving	The call is being disconnected from the conference. Triggered by hangup or `DELETE /conferencecalls/{id}`.
leaved	The call has fully left the conference. This is the final state. No further changes are possible.

Tutorial

Before working with conferences, you need:

An authentication token. Obtain one via POST /auth/login or use an access key from GET /accesskeys.
(Optional) A flow ID (UUID) for pre_actions or post_actions. Create one via POST /flows or obtain from GET /flows.
(Optional) To add participants, you need an active call. Create one via POST /calls or obtain from GET /calls.

Note

AI Implementation Hint

Conferences are created with POST /conferences and begin in starting status, quickly transitioning to progressing. Participants do not join via the conference API directly – they join through flow actions (conference_join). To remove a participant, use DELETE /conferencecalls/{conferencecall_id}. To terminate the entire conference, use DELETE /conferences/{conference_id}.

Install channel: line

Example

$ curl --location --request POST 'https://api.voipbin.net/v1.0/conversations/setup?token=<YOUR_AUTH_TOKEN>' \
    --header 'Content-Type: application/json' \
    --data-raw '{
        "reference_type": "line"
    }'

Get list of conferences

Example

$ curl -k --location --request GET 'https://api.voipbin.net/v1.0/conferences?token=<YOUR_AUTH_TOKEN>'

{
    "result": [
        {
            "id": "17039950-eab0-421d-a5f5-05acd1ac6801",
            "user_id": 1,
            "type": "conference",
            "status": "",
            "name": "",
            "detail": "",
            "conferencecall_ids": [],
            "recording_id": "00000000-0000-0000-0000-000000000000",
            "recording_ids": null,
            "tm_create": "2021-02-04 02:55:39.659316",
            "tm_update": "2021-02-04 02:56:07.525985",
            "tm_delete": ""
        },
        ...
    ],
    "next_page_token": "2021-02-03 09:33:58.077756"
}

Get detail of conference

Example

$ curl -k --location --request GET 'https://api.voipbin.net/v1.0/conferences/0e7112d7-6ddc-47ea-bba5-223a3a55ff79?token=<YOUR_AUTH_TOKEN>'

{
    "id": "0e7112d7-6ddc-47ea-bba5-223a3a55ff79",
    "user_id": 1,
    "type": "conference",
    "status": "",
    "name": "",
    "detail": "",
    "conferencecall_ids": [],
    "recording_id": "00000000-0000-0000-0000-000000000000",
    "recording_ids": [],
    "tm_create": "2021-02-03 10:44:42.163464",
    "tm_update": "2021-02-03 10:52:08.488301",
    "tm_delete": ""
}

Create a new conference

Example

$ curl -k --location --request POST 'https://api.voipbin.net/v1.0/conferences?token=<YOUR_AUTH_TOKEN>' \
    --data-raw '{
        "type": "conference",
        "name": "test conference",
        "detail": "test conference for example"
    }'

{
    "id": "85252d7b-777b-4580-9420-4df8c6adfc30",
    "user_id": 1,
    "type": "conference",
    "status": "",
    "name": "test conference",
    "detail": "test conference for example",
    "conferencecall_ids": [],
    "recording_id": "00000000-0000-0000-0000-000000000000",
    "recording_ids": null,
    "tm_create": "2021-02-04 03:05:57.710583",
    "tm_update": "",
    "tm_delete": ""
}

Kick the conferencecall from the conference

Note

AI Implementation Hint

You can only kick participants whose status is joining or joined. Attempting to delete a conferencecall in leaving or leaved status will fail. Obtain the conferencecall ID from the conference’s conferencecall_ids array (via GET /conferences/{id}) or from GET /conferencecalls.

Example

$ curl --location --request DELETE 'https://api.voipbin.net/v1.0/conferencecalls/4833755c-f5d0-4bf2-a101-7d3a7e5e586f?token=<YOUR_AUTH_TOKEN>'

{
    "id": "4833755c-f5d0-4bf2-a101-7d3a7e5e586f",   // Conferencecall ID (UUID)
    "customer_id": "5e4a0680-804e-11ec-8477-2fea5968d85b",   // Customer UUID
    "conference_id": "99accfb7-c0dd-4a54-997d-dd18af7bc280",   // Parent conference UUID
    "reference_type": "call",   // enum: call, line
    "reference_id": "153c2866-ade0-4a55-a5a7-027e463d9207",   // The call's UUID
    "status": "leaving",   // enum: joining, joined, leaving, leaved
    "tm_create": "2022-08-09 03:53:49.142446",   // ISO 8601 timestamp
    "tm_update": "2022-08-09 03:54:10.035297",
    "tm_delete": "9999-01-01 00:00:00.000000"   // 9999-01-01 means not deleted
}

Troubleshooting

400 Bad Request:
- Cause: Invalid conference creation parameters (e.g., missing type field).
- Fix: Ensure the request body includes "type": "conference" and a name string.
404 Not Found:
- Cause: The conference UUID or conferencecall UUID does not exist or belongs to a different customer.
- Fix: Verify the UUID was obtained from GET /conferences or GET /conferencecalls.
409 Conflict (kick participant):
- Cause: Attempted to kick a participant whose status is leaving or leaved.
- Fix: Check participant status via GET /conferencecalls/{id} before attempting deletion. Only joining or joined participants can be kicked.
Conference has no participants:
- Cause: Participants join through flow actions (conference_join), not through the conference API.
- Fix: Create a call with a flow containing a conference_join action that references the conference ID.

Conference

Overview

How Conferences Work

Conference Lifecycle

Participant Lifecycle

Joining a Conference

Leaving a Conference

Conference Types

Recording

Transcription

Recording and Transcription Together

Timeout and Auto-Cleanup

Health Checks

Common Scenarios

Events and Webhooks

Best Practices

Related Documentation

Conference

Conference

Example

Type

Status

conferencecall

Conferencecall

Example

Reference type

Status

Tutorial

Install channel: line

Example

Get list of conferences

Example

Get detail of conference

Example

Create a new conference

Example

Kick the conferencecall from the conference

Example

Troubleshooting