Skip to main content
Twilio models a conference as a Conference resource (CF… SID) with a nested Participant collection keyed by each leg’s CallSid. Vobiz models the same thing as a named room: every call that runs <Conference>RoomName</Conference> joins the room RoomName, and you control the room and its members by that name — so there is no separate SID to track. This page maps every Twilio conference call onto its Vobiz equivalent, in Python and Node.
Set your credentials once: AUTH_ID is your Vobiz Auth ID (MA_…), AUTH_TOKEN is your Auth Token. In the Vobiz SDK, api_key is the Auth ID, and every account-scoped method takes that auth_id explicitly. Members are addressed by conference_name + member_id.

​
Twilio → Vobiz mapping

Twilio (twilio-python / TwiML)VobizNotes
client.conferences.list(status='in-progress')client.conferences.list_conferences(auth_id)Lists active rooms on the account.
client.conferences(sid).fetch()client.conferences.get_conference(auth_id, conference_name)Vobiz returns room details and its member list in one call.
client.conferences(sid).update(status='completed')client.conferences.delete_conference(auth_id, conference_name)Ends the room and disconnects everyone.
(loop each CF… → update(status='completed'))client.conferences.delete_all_conferences(auth_id)One call ends every active room.
conferences(sid).participants.list()client.conferences.get_conference(auth_id, conference_name) → membersMembers come back with the room in get_conference.
conferences(sid).participants(call_sid).fetch()client.conferences.get_conference(...) → pick member_idFind the member in the returned member list.
participants(call_sid).update(muted=True)client.conference_members.mute_member(auth_id, conference_name, member_id)Mute a single member.
participants(call_sid).update(muted=False)client.conference_members.unmute_member(auth_id, conference_name, member_id)Unmute a single member.
participants(call_sid).update(hold=True, hold_url=…)client.conference.play_audio_member(auth_id, conference_name, member_id, url=…)Play hold audio to one member; stop_audio_member resumes.
participants(call_sid).update(announce_url=…)client.conference.play_audio_member(auth_id, conference_name, member_id, url=…)Play a one-off announcement to a member.
(one-way listen / coach)client.conference.deaf_member / undeaf_member(auth_id, conference_name, member_id)Stop/restore a member hearing the room; pair with mute for whisper/coach flows.
participants(call_sid).delete()client.conference.kick_member(auth_id, conference_name, member_id)Remove a member from the room.
(hang up the participant’s leg)client.conference.hangup_member(auth_id, conference_name, member_id)Disconnect that member’s call entirely.
participants.create(from_, to, …)client.calls.make_call(auth_id, from_, to, answer_url, answer_method) → answer URL returns <Conference>Originate a leg, then join it to the room from its answer XML.
record='record-from-start' / recordingStatusCallbackclient.conference_recording.start_conference_recording(auth_id, conference_name, file_format, callback_url) · stop_conference_recording(...) — or record="true" on <Conference>Start/stop room recording on demand, or record from the first join.
<Dial><Conference>Room</Conference></Dial> (TwiML)<Conference>Room</Conference> (VobizXML)Room name is the element text; Vobiz creates the room on first join.
startConferenceOnEnter / endConferenceOnExitstartConferenceOnEnter / endConferenceOnExitSame names, same moderator semantics.
muted, beep, maxParticipantsmuted, beep, maxParticipantsSame attributes; see Conference attributes.
waitUrl / waitMethodwaitSound / waitMethodHold-music URL played until the room starts.
statusCallback + statusCallbackEventcallbackUrl + callbackMethodVobiz posts enter / exit / start / end events. See Conference callbacks.

​
Join a call to a conference

In Twilio you either dial into a room with <Dial><Conference> from an inbound call, or you push a new leg in with participants.create. In Vobiz the room name is the join key: return <Conference>RoomName</Conference> from an inbound call’s answer URL, and originate outbound legs with make_call pointing at an answer URL that returns the same room. 
from twilio.rest import Client
client = Client(ACCOUNT_SID, AUTH_TOKEN)

# Push an outbound leg into the conference
client.conferences("CFxxxxxxxx").participants.create(
    from_="+14155551234",
    to="+14165553434",
    start_conference_on_enter=True,
    end_conference_on_exit=False,
    beep="onEnter",
)
The answer URL returns the room in XML. TwiML nests <Conference> inside <Dial>; VobizXML uses <Conference> directly, with the room name as the element text. 
from twilio.twiml.voice_response import VoiceResponse, Dial

resp = VoiceResponse()
dial = Dial()
dial.conference(
    "SalesRoom",
    start_conference_on_enter=True,
    end_conference_on_exit=False,
    beep="onEnter",
    wait_url="https://example.com/hold-music",
    status_callback="https://example.com/conf-events",
    status_callback_event="start end join leave",
)
resp.append(dial)
print(str(resp))

​
Control members: mute, hold, kick

Twilio addresses a participant by its leg CallSid and mutates it with participants(sid).update(...). Vobiz gives each control its own verb, addressed by conference_name + member_id — you get the member IDs from get_conference. 
conf = client.conferences("CFxxxxxxxx")

# Who is in the room?
for p in conf.participants.list():
    print(p.call_sid, "muted:", p.muted, "hold:", p.hold)

# Mute one participant
conf.participants("CAaaaa").update(muted=True)
# Put one participant on hold with hold music
conf.participants("CAaaaa").update(hold=True, hold_url="https://example.com/hold-music")
# Remove one participant
conf.participants("CAaaaa").delete()
For a whisper/coach flow, pair deaf_member/undeaf_member (control who a member hears) with mute_member/unmute_member (control who hears them) — the same effect Twilio’s coaching + muted combination produces, expressed as two explicit, composable verbs.

​
List, inspect, and end rooms

# List active conferences
for c in client.conferences.list(status="in-progress"):
    print(c.sid, c.friendly_name, c.status)

# Fetch one
conf = client.conferences("CFxxxxxxxx").fetch()

# End a conference (no delete — you update status)
client.conferences("CFxxxxxxxx").update(status="completed")

​
Record a conference

Twilio records via the record attribute (record-from-start) plus recordingStatusCallback. Vobiz records the whole room either declaratively (record="true" on <Conference>) or imperatively, starting and stopping on demand by room name. 
# Recording is set when the conference is created via TwiML:
#   <Conference record="record-from-start"
#               recordingStatusCallback="https://example.com/rec">Room</Conference>
The recording URL is delivered to your callbackUrl on the conference end event (and to callback_url on the recording API) — see Conference callbacks.

​
Key differences

  • Room name, not SID. Twilio tracks a Conference by its CF… SID and each participant by leg CallSid. Vobiz uses the human-readable room name plus a member_id for every operation, so you never fetch a SID before acting — the name you put in <Conference> is the same name you pass to every control method.
  • One call returns the whole room. get_conference returns the room’s details and its member list together, where Twilio’s fetch() and participants.list() are separate requests.
  • Ending rooms is explicit. Vobiz gives you delete_conference for one room and delete_all_conferences for every active room, versus Twilio’s update(status='completed') per SID.
  • One verb per control. Mute, hold, deaf, announce, kick, and hangup are each their own method (mute_member, play_audio_member, deaf_member, kick_member, hangup_member), so intent is explicit and composable rather than a bundle of flags on one participant.update().
  • Hold is “play to one member.” play_audio_member streams hold music to a single participant and stop_audio_member returns them to the room — the same outcome as Twilio’s hold/hold_url, expressed as an audio action you fully control.
  • On-demand recording. start_conference_recording/stop_conference_recording let you record any portion of an active room by name, in addition to the declarative record="true" attribute.
  • Same TwiML-shaped XML. VobizXML keeps startConferenceOnEnter, endConferenceOnExit, muted, beep, and maxParticipants under the same names — most <Conference> blocks port with only a waitUrl→waitSound and statusCallback→callbackUrl rename.

​
See also