Start a new multiparty call

    You can trigger this request to initiate an MPC with at least one participant.

    API Endpoint

    POST https://api.plivo.com/v1/Account/{auth_id}/MultiPartyCall/name_{mpc_name}/

    Arguments

    statusCurrent status of the MPC. Set to Active when call starts.

    Returns

    Returns 404 Not Found if the MPC is not found for the given name or UUID in the initiated state. Else, returns 204 without content.

    Response

    HTTP Status Code: 204

    Example Request

    1
    2
    3
    4
    5
    6
    
    import plivo
    
    client = plivo.RestClient(auth_id="your_auth_id", auth_token="your_auth_token")
    
    response = client.multi_party_calls.start(friendly_name='mpc_name')
    print(response)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    
    require "rubygems"
    require "/root/plivo-ruby/lib/plivo.rb"
    include Plivo
    include Plivo::Exceptions
    
    api = RestClient.new("<auth_id>","<auth_token>")
    begin
      response = api.multipartycalls.start("friendly_name":"mpc_name")
      puts response
    rescue PlivoRESTError => e
      puts 'Exception: ' + e.message
    end
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    var plivo = require('plivo');
    (function main() {
        'use strict';
        var client = new plivo.Client("<auth_id>", "<auth_token>");
        client.multiPartyCalls.start({
            friendlyName: '<mpc_name>', // uuid: '<mpc_uuid>', mpc_uuid can also be used instead of mpc_name.
            status: 'active'
        }).then(function(response) {
            console.log(response);
        }, function(err) {
            console.error(err);
        });
    })();
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    
    <?php
    require 'vendor/autoload.php';
    
    use Plivo\RestClient;
    use Plivo\Exceptions\PlivoRestException;
    
    $client = new RestClient("<auth_id>", "<auth_token>");
    try
    {
        $response = $client
            ->multiPartyCalls
            ->start(["friendly_name" => "mpc_name", ]);
        print_r($response);
    }
    catch(PlivoRestException $ex)
    {
        print_r($ex);
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    package com.plivo.examples.multipartycall;
    
    import com.plivo.api.Plivo;
    import com.plivo.api.exceptions.PlivoRestException;
    import com.plivo.api.exceptions.PlivoValidationException;
    import com.plivo.api.models.multipartycall.MultiPartyCall;
    import com.plivo.api.models.multipartycall.MultiPartyCallUtils;
    
    import java.io.IOException;
    
    public class Start {
    
      public static void main(String[] args) throws IOException, PlivoRestException, PlivoValidationException {
        Plivo.init("<YOUR-AUTH-ID>", "<YOUR-AUTH-TOKEN>");
        try
        {
          MultiPartyCall.starter(MultiPartyCallUtils.friendlyName("myInitializedMPC1")).update();
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
      }
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    
    using System;
    using Plivo;
    using Plivo.Exception;
    
    namespace PlivoExamples
    {
        class Program
        {
            static void Main(string[] args)
            {
                var api = new PlivoApi("<auth_id>", "<auth_token>");
    
                try
                {
                    var response = api.MultiPartyCall.Start(friendlyName: "mpc_name")
                    Console.WriteLine(response);
                }
                catch (PlivoRestException e)
                {
                    Console.WriteLine("Exception: " + e.Message);
                }
    
            }
        }
    }
    
    1
    2
    
    curl -i --user AUTH_ID:AUTH_TOKEN -X POST \
        https://api.plivo.com/v1/Account/{auth_id}/MultiPartyCall/name_{mpc_name}/
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    
    package main
    
    import (
    	"github.com/plivo/plivo-go"
    )
    
    func main() {
    	client, err := plivo.NewClient("<auth_id>", "<auth_token>", &plivo.ClientOptions{})
    	if err != nil {
    		panic(err)
    	}
    	err = client.MultiPartyCall.Start(plivo.MultiPartyCallBasicParams{FriendlyName: "MPC_Name"})
    	if err != nil {
    		panic(err)
    	}
    	fmt.Printf("MPC start Success")
    }