Voice Broadcast

Contents

Campaign Service

Description

Campaign Service help you to create and manage your campaigns.

WSDL

https://www.callfire.com/service/CampaignService?wsdl

The WSDL is called CampaignService. It encompasses not only the voice broadcast functionality, but also the methods needed to create and modify other types of campaigns.

Methods

Operation Type Description
Add Operations Quick link to all add operations.
Create Operations Quick link to all create operations.
Send Operations Quick link to send operations
Modify Operations Quick link to modify operations


ADD

addAutoDNCToCampaign

Use this function to add a number to the Do Not Call list.

Parameters

  • api_key - This is the key that you were provided when you registered with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings".
  • campaign_id - This is the CampaignID to start
  • To Test The Function:
    • Create a new campaign
    • Call the addAutoDNCTo_Campaign function
    • Run the campaign, when you receive the call, press the DNC digit.
  • Response
    • The number would be added to the do not call list.
    • Logon to callfire.com as an Admin, click on "Toolbox -> Phonebooks and DNC" to view the number

Input: addAutoDNCToCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignid 1 1 xsd:long the campaign id to start

Output: addAutoDNCToCampaignResponse

Name maxOccurs minOccurs nillable type description
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:addAutoDNCToCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>-5814</tnsa:campaignId>
    </tnsa:addAutoDNCToCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:addAutoDNCToCampaignResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com"></ns1:addAutoDNCToCampaignResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
	public function addAutoDNCToCampaign($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$addAutoDNCarray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);
		try
		{
			$addAutoDNCToCampaignResponse = $campaignOutboundClient->addAutoDNCToCampaign($addAutoDNCarray);
			$addAutoDNC = $addAutoDNCToCampaignResponse->out;
			if($debug)
			{
				echo "Numbers will be added to DoNotCallList";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public void addAutoDNCToCampaign(string key, long campaignId)
        {
            LOG.Info("Entered addAutoDNCToCampaign(string key, long campaignId)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCampaignId(campaignId);

            try
            {
                /*
                 * add auto DNC to campaign
                 */
                this.campaignService.addAutoDNCToCampaign(key, campaignId);
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to addAutoDNCToCampaign";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited addAutoDNCToCampaign(string key, long campaignId)");
            }
        }

addNumbersToCampaign

If you need to add more numbers to an existing campaign, use this to upload additional phone numbers.

Parameters

  • api_key - This is the key that you were provided when you registerd with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • campaign_id - This is the CampaignID to start
  • csvdata - This is the csv file containing the additional numbers. each number is followed by a comma and some extra data, the next phone number is on a separate line (think '\n')
CSVData File Format
The CSV Data (String) should look like this for a campaign with just phone numbers ( New Line Seperated )
1231231234
1231231235
1231231236
...
1231231237

For Call Center Connect Campaigns or with Extra Data per number, it should be as follows =
1231231234,FirstName1,LastName1,ExtraInfo,Address
1231231235,FirstName2,LastName2,ExtraInfo,Address
...
1231231236,FirstNameN,LastNameN,ExtraInfo,Address 

Input: addNumbersToCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
id 1 1 xsd:long the campaign id to start
csvData 1 1 TRUE xsd:string a csv containing all the phone number data

Output: addNumbersToCampaignResponse

Name maxOccurs minOccurs nillable type description
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:addNumbersToCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:id>-3198</tnsa:id>
      <tnsa:csvData>string</tnsa:csvData>
    </tnsa:addNumbersToCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:addNumbersToCampaignResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com"></ns1:addNumbersToCampaignResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
	public function addNumbersToCampaign($api_key,$campaign_id,$csvdata,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$csv = file_get_contents($csvdata);
		$addNumbersArray = array (
		'key' => $api_key,
		'id' => $campaign_id,
		'csvData' => $csv
		);
		try
		{
			$addNumbersResponse = $campaignOutboundClient->addNumbersToCampaign($addNumbersArray);
			$addNumbers = $addNumbersResponse->out;
			if($debug)
			{
				echo "Successfully added numbers to existing campaign..";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public void addNumbersToCampaign(string key, long campaignId, string numbersInCSV)
        {
            LOG.Info("Entered addNumbersToCampaign(string key, long campaignId, string numbersInCSV)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCampaignId(campaignId);

            try
            {
                /*
                 * add numbers to campaign
                 */
                this.campaignService.addNumbersToCampaign(key, campaignId, numbersInCSV);
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to addNumbersToCampaign";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited addNumbersToCampaign(string key, long campaignId, string numbersInCSV)");
            }
        }

CREATE

createBroadcastNoAMD

This function is to create a broadcast campaign without answering machine detection

Parameters

  • api_key - This is the key that you were provided when you registered with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. Upload your phone numbers
  • dncDigit - DTMF digit that will mark the call Do Not Call
  • live_file - Sound file to be played when the user picks up the phone. (File format :: binary sound file. Wav file 16 Bit 8kHz mono.)
  • dnc_file - Sound file to play when user presses Do Not Call digit. (File format :: binary sound file. Wav file 16 Bit 8kHz mono.)

Input: createBroadcastNoAMD

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call
dncDigit 1 1 TRUE xsd:string which DTMF digit will mark the call Do Not Call
liveFile 1 1 TRUE xsd:base64Binary
dncFile 1 1 TRUE xsd:base64Binary Sound file to play when user presses Do Not Call digit

Output: createBroadcastNoAMD

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:longcampaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastNoAMD xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:liveFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:liveFile>
      <tnsa:dncFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:dncFile>
    </tnsa:createBroadcastNoAMD>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastNoAMD($api_key,$caller_id,$phoneNumbers,$dncDigit,$live_file,$dnc_file,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		//Converting the input file to ArrayOfString
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound files to byte format
		$handle = fopen($live_file,'r');
		$contents = fread($handle,filesize($live_file));
		$liveFile = $contents;
		$handle1 = fopen($dnc_file,'r');
		$contents1 = fread($handle1,filesize($dnc_file));
		$dncFile = $contents1;

		$createcampaign = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
    	'dncDigit' => $dncDigit,
   		'liveFile' => $liveFile,
   		'dncFile' => $dncFile
		);
		try
		{
			$createBroadcastNoAMDResponse = $campaignOutboundClient->createBroadcastNoAMD($createcampaign);
			$campaignId = $createBroadcastNoAMDResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long createBroadcastNoAMD(string key, string callerId, List<string> numbers,
            string dncDigit, byte[] liveFile, byte[] dncFile)
        {
            LOG.Info("Entered createBroadcastNoAMD(string key, string callerId, List<string> numbers, "
                + "string dncDigit, byte[] liveFile, byte[] dncFile)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateDNCDigit(dncDigit);
            this.validateLiveFile(liveFile);
            this.validateDNCFile(dncFile);

            try
            {
                /*
                 * Create broadcast with no Anwering Machine Detection (AMD)
                 */
                long campaignId = this.campaignService.createBroadcastNoAMD(key, callerId,
                    numbers.ToArray(), dncDigit, liveFile, dncFile);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastNoAMD";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastNoAMD(string key, string callerId, List<string> numbers, "
                    + "string dncDigit, byte[] liveFile, byte[] dncFile)");
            }
        }

createBroadcastToList

This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines.

Parameters

  • api_key - This is the key that you were provided when you registerd with callfire.com, You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • list_id - This is the Id of your phonebook. You can get this id by logging onto callfire.com & then goto "Toolbox -> Phonebooks & DNC "
  • soundfile - Sound file to be played. (File format :: binary sound file. Wav file 16 Bit 8kHz mono.)
Warning: This function will automatically start the campaign! Only call this if you are ready to broadcast right away.
  • Live Answer and Answering Machine Detection
  • Playback sound to Live Pickup and leave a message to Answering Machines
  • Use your own Callerid
  • Campaign STARTS automatically

Input: createBroadcastToList

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
listid 1 1 xsd:long
soundFile 1 1 TRUE xsd:base64Binary

Output: createBroadcastToList

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastToList xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:listid>3240</tnsa:listid>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
    </tnsa:createBroadcastToList>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastToList($api_key,$caller_id,$list_id,$soundfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		//Converting the sound files to byte format
		$handle = fopen($soundfile,'r');
		$contents = fread($handle,filesize($soundfile));
		$soundFile = $contents;
		$createBroadcasttoList = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'listid' => $list_id,
   		'soundFile' => $soundFile
		);
		try
		{
			$createBroadCastToListResponse = $campaignOutboundClient->createBroadcastToList($createBroadcasttoList);
			$campaignId = $createBroadCastToListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long createBroadcastToList(string key, string callerId, long listId, byte[] soundFile)
        {
            LOG.Info("Entered createBroadcastToList(string key, string callerId, long listId, byte[] soundFile)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateListId(listId);
            this.validateSoundFile(soundFile);

            try
            {
                /*
                 * Create broadcast using an existing list
                 */
                long campaignId = this.campaignService.createBroadcastToList(key, callerId, listId,
                    soundFile);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastToList";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastToList(string key, string callerId, long listId, byte[] soundFile)");
            }
        }

createBroadcastToList1

This function creates a Broad cast campaign. Use this function if you already have your sound files uploaded on callfire.com

Parameters

  • api_key - This is the key that you were provided when you registerd with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (!0 digits)
  • list_id - This is the Id of your phonebook. You can get this id by logging onto callfire.com & then goto "Toolbox -> Phonebooks & DNC "
  • soundfileid - This is the sound file id. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastToList1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls (10 digits)
listid 1 1 xsd:long
soundFileId 1 1 xsd:long

Output: createBroadcastToList1

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastToList1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:listid>-7816</tnsa:listid>
      <tnsa:soundFileId>-9170</tnsa:soundFileId>
    </tnsa:createBroadcastToList1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:createBroadcastToList1Response xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>1129222</ns1:out>
</ns1:createBroadcastToList1Response>
</soap:Body>
</soap:Envelope>
Sample PHP Code
	public function createBroadcastToList1($api_key,$caller_id,$list_id,$soundfileid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$createBroadcasttoList = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'listid' => $list_id,
   		'soundFileId' => $soundfileid
		);
		try
		{
			$createBroadCastToListResponse = $campaignOutboundClient->createBroadcastToList1($createBroadcasttoList);
			$campaignId = $createBroadCastToListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long createBroadcastToListWithExistingSoundFile(string key, string callerId, long listId, long soundFileId)
        {
            LOG.Info("Entered createBroadcastToListWithExistingSoundFile(string key, string callerId, long listId, "
                + "long soundFileId)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateListId(listId);
            this.validateSoundFileId(soundFileId);

            try
            {

                /*
                 * Create broadcast using an existing list and sound file
                 */
                long campaignId = this.campaignService.createBroadcastToList1(key, callerId, listId,
                    soundFileId);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastToListWithExistingSoundFile";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastToListWithExistingSoundFile(string key, string callerId, long listId, "
                    + "long soundFileId)");
            }
        }

createBroadcastToNumbers

Same as sendBroadcastToList, except the campaign is not started immediately. This function will create a broadcast to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines.

  • Live Answer and Answering Machine Detection
  • Playback sound to Live Pickup and leave a message to Answering Machines
  • Use your own Callerid
  • Campaign DOES NOT start automatically
Parameters
  • api_key - This is the key that you were provided when you registerd with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • callerid - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • soundfile - Sound file to be played. File format :: binary sound file. Wav file 16 Bit 8kHz mono.


Input: createBroadcastToNumbers

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
numbers 1 1 TRUE tns:ArrayOfString an Array of Phone numbers (10 digits)
soundFile 1 1 TRUE xsd:base64Binary binary sound file. Wav file 16 Bit 8kHz mono.

Output: createBroadcastToNumbersResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastToNumbers xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
    </tnsa:createBroadcastToNumbers>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastToNumbers($api_key,$caller_id,$phoneNumbers,$soundfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		//Converting the input file to ArrayOfString
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file
		$handle = fopen($soundfile,'r');
		$contents = fread($handle,filesize($soundfile));
		$soundFile = $contents;

		$createBroadcasttonumbersarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'soundFile' => $soundFile
		);
		try
		{
			$createBroadcastToNumbersResponse = $campaignOutboundClient->createBroadcastToNumbers($createBroadcasttonumbersarray);
			$campaignId = $createBroadcastToNumbersResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long createBroadcastToNumbers(string key, string callerId, List<string> numbers, byte[] soundFile)
        {
            LOG.Info("Entered createBroadcastToNumbers(string key, string callerId, List<string> numbers, byte[] soundFile");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateSoundFile(soundFile);

            try
            {
                /*
                 * Create campaign using given numbers
                 */
                long campaignId = this.campaignService.createBroadcastToNumbers(key, callerId, numbers.ToArray(),
                    soundFile);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastToNumbers";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastToNumbers(string key, string callerId, List<string> numbers, byte[] soundFile");
            }
        }

createBroadcastToNumbers1

Same as sendBroadcastToList, except the campaign is not started immediately. This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines.

Parameters
  • api_key - This is the key that you were provided when you registered with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • soundfileid - This is the sound file id. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastToNumbers1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call
soundFileId 1 1 xsd:long

Output: createBroadcastToNumbers1

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastToNumbers1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:soundFileId>-3464</tnsa:soundFileId>
    </tnsa:createBroadcastToNumbers1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastToNumbers1($api_key,$caller_id,$phoneNumbers,$soundfileid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		//Converting the input file to ArrayOfString
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		$createBroadcasttonumbersarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'soundFileId' => $soundfileid
		);
		try
		{
			$createBroadCastToListResponse = $campaignOutboundClient->createBroadcastToNumbers1($createBroadcasttonumbersarray);
			$campaignId = $createBroadCastToListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long createBroadcastToNumbersWithExistingSoundFile(string key, string callerId, List<string> numbers, 
            long soundFileId)
        {
            LOG.Info("Entered createBroadcastToNumbersWithExistingSoundFile(string key, string callerId, List<string> numbers, "
                + "long soundFileId");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateSoundFileId(soundFileId);

            try
            {
                /*
                 * Create campaign using given numbers and an existing sound file
                 */
                long campaignId = this.campaignService.createBroadcastToNumbers1(key, callerId, numbers.ToArray(),
                    soundFileId);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastToNumbersWithExistingSoundFile";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastToNumbersWithExistingSoundFile(string key, string callerId, List<string> numbers, "
                    + "long soundFileId");
            }
        }

createBroadcastWithDNC

This function will create a broadcast list with the DoNotCall Feature. Use this if you want to upload sound files from your system

Parameters

  • api_key - This is the key that you were provided when you registered with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • dncdigit - which DTMF digit will mark the Do Not Call
  • liveanswer - Sound file to be played when the user picks up the phone. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • ansmachine - Sound file to be played when the call goes to voicemail. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • dncfile - Sound file to be played when the user presses the Do Not Call Digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.

Input: createBroadcastWithDNC

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
numbers 1 1 TRUEtns:ArrayOfString10 digit phone numbers to call
dncDigit 1 1 TRUE xsd:string which DTMF digit will mark the Do Not Call
liveAnswer 1 1 TRUE xsd:base64Binary
answeringMachine 1 1 TRUE xsd:base64binary Answering machine sound file
dncFile 1 1 TRUE xsd:base64binary Sound file to play when user presses Do not call digit

Output: createBroadcastWithDNCResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithDNC xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:liveAnswer>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:liveAnswer>
      <tnsa:answeringMachine>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:answeringMachine>
      <tnsa:dncFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:dncFile>
    </tnsa:createBroadcastWithDNC>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastWithDNC($api_key,$caller_id,$phoneNumbers,$dncdigit,$liveanswer,$ansmachine,$dncfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file to byte format
		$handle = fopen($liveanswer,'r');
		$contents = fread($handle,filesize($liveanswer));
		$liveAnswer = $contents;

		$handle1 = fopen($ansmachine,'r');
		$contents1 = fread($handle1,filesize($ansmachine));
		$answeringMachine = $contents1;

		$handle2 = fopen($dncfile,'r');
		$contents2 = fread($handle2,filesize($dncfile));
		$dncFile = $contents2;

		$phoneNumber = '2134000543';
		$createBroadcasttoList = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'dncDigit' => $dncdigit,
   		'liveAnswer' => $liveAnswer,
   		'answeringMachine' => $answeringMachine,
   		'dncFile' => $dncFile
		);
		try
		{
			$createBroadCastToListResponse = $campaignOutboundClient->createBroadcastWithDNC($createBroadcasttoList);
			$campaignId = $createBroadCastToListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createBroadcastWithDNC(string key, string callerId, List<string> numbers, string dncDigit,
            byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile)
        {
            LOG.Info("Entered createBroadcastWithDNC(string key, string callerId, List<string> numbers, string dncDigit,"
                + "byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateDNCDigit(dncDigit);
            this.validateLiveFile(liveAnswer);
            this.validateAnsweringFile(answeringMachine);
            this.validateDNCFile(dncFile);

            try
            {
                /*
                 * Create broadcast using given numbers with a DNC
                 */
                long campaignId = this.campaignService.createBroadcastWithDNC(key, callerId, numbers.ToArray(), dncDigit,
                    liveAnswer, answeringMachine, dncFile);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastWithDNC";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithDNC(string key, string callerId, List<string> numbers, string dncDigit,"
                + "byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile");
            }
        }

createBroadcastWithDNC1

This function will create a broadcast list with the DoNotCall Feature. Use this function, if you have your sound files uploaded on callfire.com

Parameters

  • api_key - This is the key that you were provided when you registered with callfire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • dncdigit - which DTMF digit will mark the Do Not Call
  • liveAnswerid - Sound file to be played when the user picks up the phone. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • answeringMachineid - Sound file to be played when the call goes to voicemail. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
* dncFileid - Sound file to be played when the user presses the Do Not Call Digit. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastWithDNC1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call
dncDigit 1 1 TRUE xsd:string which DTMF digit will mark the call Do Not Call
laSoundFileId 1 1 xsd:long Live Answer sound file
answeringMachine 1 1 xsd:long Answering machine sound file
dncFileId 1 1 xsd:long Sound file to play when user presses Do Not Call

Output: createBroadcastWithDNC1Response

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithDNC1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:laSoundFileId>-7230</tnsa:laSoundFileId>
      <tnsa:answeringMachine>2427</tnsa:answeringMachine>
      <tnsa:dncFileId>9092</tnsa:dncFileId>
    </tnsa:createBroadcastWithDNC1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Sample PHP Code
	public function createBroadcastWith_DNC1($api_key,$caller_id,$phoneNumbers,$dncdigit,$liveAnswerid,$answeringMachineid,$dncFileid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		$createBroadcasttoList = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'dncDigit' => $dncdigit,
   		'laSoundFileId' => $liveAnswerid,
   		'answeringMachine' => $answeringMachineid,
   		'dncFileId' => $dncFileid
		);
		try
		{
			$createBroadCastToListResponse = $campaignOutboundClient->createBroadcastWithDNC1($createBroadcasttoList);
			$campaignId = $createBroadCastToListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createBroadcastWithDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, string dncDigit,
            long liveAnswerId, long answeringMachineId, long dncFileId)
        {
            LOG.Info("Entered createBroadcastWithDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                + "string dncDigit, long liveAnswerId, long answeringMachineId, long dncFileId)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateDNCDigit(dncDigit);
            this.validateLiveId(liveAnswerId);
            this.validateAnsweringId(answeringMachineId);
            this.validateDNCId(dncFileId);

            try
            {
                /*
                 * Create broadcast using given numbers with an existing DNC
                 */
                long campaignId = this.campaignService.createBroadcastWithDNC1(key, callerId, numbers.ToArray(), dncDigit,
                    liveAnswerId, answeringMachineId, dncFileId);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastWithDNCWithExistingSoundFiles";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                    + "string dncDigit, long liveAnswerId, long answeringMachineId, long dncFileId)");
            }
        }

createBroadcastWithTransfer

This will create a voice broadcast campaign with the capability to transfer. Plays back a unique file for Live Answer and Answering Machine.

  • Live Answer and Answering Machine Detection
  • Leave different messages for Live Answer and Answering Machine
  • Detect any digit from the user to transfer to your number
  • Playback a file when user chooses the transfer digit
  • Use your own Callerid
  • Campaign DOES NOT start automatically
Parameters
  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • liveanswer - Sound file to be played when the user picks up the phone. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • ansmachine - Sound file to be played when the call goes to Voice Mail. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • transferfile - Sound file to be played when the user presses the transfer digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.

Input: createBroadcastWithTransfer

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns: ArrayOfString 10 digit phone numbers to call
transferNumber 1 1 TRUE xsd:string 10 digit phone number to transfer to
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
liveAnswer 1 1 TRUE xsd:base64Binary LiveAnswer sound file
answeringMachine 1 1 TRUE xsd:base64Binary Answering machine sound file
transferFile 1 1 TRUE xsd:base64Binary Sound file to play when user presses the transfer digit

Output: createBroadcastWithTransferResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransfer xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:liveAnswer>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:liveAnswer>
      <tnsa:answeringMachine>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:answeringMachine>
      <tnsa:transferFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:transferFile>
    </tnsa:createBroadcastWithTransfer>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastWithTransfer($api_key,$caller_id,$phoneNumbers,$transfer_number,$transfer_digit,$liveanswer,$ansmachine,$transferfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file to byte format
		$handle = fopen($liveanswer,'r');
		$contents = fread($handle,filesize($liveanswer));
		$liveAnswer = $contents;

		$handle1 = fopen($ansmachine,'r');
		$contents1 = fread($handle1,filesize($ansmachine));
		$answeringMachine = $contents1;

		$handle2 = fopen($transferfile,'r');
		$contents2 = fread($handle2,filesize($transferfile));
		$transferFile = $contents2;

		$createBroadcasttoListtransfer = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'liveAnswer' => $liveAnswer,
   		'answeringMachine' => $answeringMachine,
   		'transferFile' => $transferFile
		);
		try
		{
			$createBroadCastToListTransferResponse = $campaignOutboundClient->createBroadcastWithTransfer($createBroadcasttoListtransfer);
			$campaignId = $createBroadCastToListTransferResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}

Sample C# Code
public long createBroadcastWithTransfer(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, byte[] liveAnswer, byte[] answeringMachine, byte[] transferFile)
        {
            LOG.Info("Entered createBroadcastWithTransfer(string key, string callerId, List<string> numbers, string transferNumber, "
                + "string transferDigit, byte[] liveAnswer, byte[] answeringMachine, byte[] transferFile)");

            /*
             * Validation of parameters early helps avoid runtime
             * exceptions such as null pointer exceptions (NPE). Invalid
             * parameters can be rejected immediately before any web
             * service calls are made.
             */
            this.validateAccountKey(key);
            this.validateCallerId(callerId);
            this.validateNumbers(numbers);
            this.validateTransferNumber(transferNumber);
            this.validateTransferDigit(transferDigit);
            this.validateLiveFile(liveAnswer);
            this.validateAnsweringFile(answeringMachine);
            this.validateTransferFile(transferFile);

            try
            {
                /*
                 * Create broadcast with given numbers and transfer file
                 */
                long campaignId = this.campaignService.createBroadcastWithTransfer(key, callerId, numbers.ToArray(), 
                    transferNumber, transferDigit, liveAnswer, answeringMachine, transferFile);

                /*
                 * A quick check is performed to see if debug mode is enabled for logging.
                 * This ensure the string parameter is not evaluated unless it is needed.
                 */
                if (LOG.IsDebugEnabled)
                {
                    LOG.Debug("New campaign created: " + campaignId);
                }

                return campaignId;
            }
            catch (Exception e)
            {
                //write to log and raise exception indicating an error occurred
                string msg = "Unable to createBroadcastWithTransfer";
                LOG.Error(msg);
                throw new CampaignException(msg, e);
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransfer(string key, string callerId, List<string> numbers, " 
                    + "string transferNumber, string transferDigit, byte[] liveAnswer, byte[] answeringMachine, byte[] transferFile)");
            }
        }

createBroadcastWithTransfer1

This function will create a broadcast campaign with the Call Transfer Feature Use this function if you have already uploaded your sound files on callfire

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • liveanswerid - Sound file to be played when the user picks up the phone. You can get this id by logging onto CallFire.com & then goto "Toolbox -> SoundManager"
  • ansmachineid - Sound file to be played when the call goes to Voice Mail. You can get this id by logging onto CallFire.com & then goto "Toolbox -> SoundManager"
  • transferfileid - Sound file to be played when the user presses the transfer digit. You can get this id by logging onto CallFire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastWithTransfer1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should b e presented on each call (10 digits)
numbers 1 1 TRUE tns: ArrayOfString
transferNumber 1 1 TRUE xsd:string
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
laSoundFileId 1 1 xsd:long
answeringMachine 1 1 xsd:long
transferFileId 1 1 xsd:long

Output: createBroadcastWithTransfer1Response

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransfer1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:laSoundFileId>953</tnsa:laSoundFileId>
      <tnsa:answeringMachine>-9785</tnsa:answeringMachine>
      <tnsa:transferFileId>-4219</tnsa:transferFileId>
    </tnsa:createBroadcastWithTransfer1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
public function createBroadcastWithTransfer1($api_key,$caller_id,$phoneNumbers,$transfer_number,$transfer_digit,$liveanswerid,$ansmachineid,$transferfileid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		$createBroadcasttoListtransfer1 = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'laSoundFileId' => $liveanswerid,
   		'answeringMachine' => $ansmachineid,
   		'transferFileId' => $transferfileid
		);
		try
		{
			$createBroadCastToListTransferResponse1 = $campaignOutboundClient->createBroadcastWithTransfer1($createBroadcasttoListtransfer1);
			$campaignId = $createBroadCastToListTransferResponse1->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createBroadcastWithTransferWithExistingSoundFiles(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, long liveAnswerId, long answeringMachineId, long transferFileId)
        {
            LOG.Info("Entered createBroadcastWithTransferWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                + "string transferNumber, string transferDigit, long liveAnswerId, long answeringMachineId, long transferFileId)");

            try
            {
                long campaignId = this.campaignService.createBroadcastWithTransfer1(key, callerId, numbers.ToArray(),
                    transferNumber, transferDigit, liveAnswerId, answeringMachineId, transferFileId);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransferWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                    + "string transferNumber, string transferDigit, long liveAnswerId, long answeringMachineId, long transferFileId)");
            }
        }

createBroadcastWithTransferDNC

This function will create a broadcast to the phone numbers you specify, it allows an option to transfer and add to the DNC List. The sound file provided will be played back to live pickups and be left as a message on answering machines. On live answer, the user can select a digit to transfer to your call center or press another digit to be marked as Do Not Call.

  • Live Answer and Answering Machine Detection
  • Leave different messages for Live Answer and Answering Machine
  • Detect any digit from the user to transfer to your number
  • Detect any digit from the user to mark as Do-Not-Call
  • Playback a file when user chooses the transfer digit
  • Playback a file when user chooses the Do-Not-Call Digit
  • Use your own Callerid
  • Campaign DOES NOT start automatically
Parameters
  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • dnc_digit - This is the DTMF digit that would mark the Do Not Call
  • liveanswer - Sound file to be played when the user picks up the phone. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • ansmachine - Sound file to be played when the call goes to Voice Mail. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • transferfile - Sound file to be played when the user presses the transfer digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • dncfile - Sound file to be played when the user presses the Do Not call digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.

Input: createBroadcastWithTransferDNC

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls (10 digits)
numbers 1 1 TRUE xsd:ArrayOfString 10 digit phone numbers to call
transferNumber 1 1 TRUE xsd:string
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
dncDigit 1 1 TRUE xsd:string which DTMF will mark the call Do Not Call
liveAnswer 1 1 TRUE xsd:base64Binary Live answer sound file
answeringMachine 1 1 TRUE xsd:base64Binary Answering machine sound file
transferFile 1 1 TRUE xsd:base64Binary Sound file to be played when the user presses the transfer digit
dncFile 1 1 TRUE xsd:base64Binary Sound file to play when user presses the do not call digit

Output: createBroadcastWithTransferDNCResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransferDNC xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:liveAnswer>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:liveAnswer>
      <tnsa:answeringMachine>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:answeringMachine>
      <tnsa:transferFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:transferFile>
      <tnsa:dncFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:dncFile>
    </tnsa:createBroadcastWithTransferDNC>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastWithTransferDNC($api_key,$caller_id,$phoneNumbers,$transfer_number,$transfer_digit,$dnc_digit,$liveanswer,$ansmachine,$transferfile,$dncfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file to byte format
		$handle = fopen($liveanswer,'r');
		$contents = fread($handle,filesize($liveanswer));
		$liveAnswer = $contents;

		$handle1 = fopen($ansmachine,'r');
		$contents1 = fread($handle1,filesize($ansmachine));
		$answeringMachine = $contents1;

		$handle2 = fopen($transferfile,'r');
		$contents2 = fread($handle2,filesize($transferfile));
		$transferFile = $contents2;

		$createBroadcastWithTransferDNCarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'dncDigit' => $dnc_digit,
   		'liveAnswer' => $liveAnswer,
   		'answeringMachine' => $answeringMachine,
   		'transferFile' => $transferFile,
   		'dncFile' => $dncfile
		);
		try
		{
			$createBroadcastWithTransferDNCResponse = $campaignOutboundClient->createBroadcastWithTransferDNC($createBroadcastWithTransferDNCarray);
			$campaignId = $createBroadcastWithTransferDNCResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createBroadcastWithTransferDNC(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, byte[] transferFile,
            byte[] dncFile)
        {
            LOG.Info("Entered createBroadcastWithTransferDNC(string key, string callerId, List<string> numbers, "
                + "string transferNumber, string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, "
                + "byte[] transferFile, byte[] dncFile)");

            try
            {
                long campaignId = this.campaignService.createBroadcastWithTransferDNC(key, callerId, numbers.ToArray(),
                    transferNumber, transferDigit, dncDigit, liveAnswer, answeringMachine, transferFile, dncFile);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransferDNC(string key, string callerId, List<string> numbers, "
                    + "string transferNumber, string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, "
                    + "byte[] transferFile, byte[] dncFile)");
            }
        }

createBroadcastWithTransferDNC1

This function will create a broadcast list with the Call Transfer Feature & the add to DoNotCall List feature. Use this function if you have already uploaded your sound files on CallFire.com

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • dnc_digit - This is the DTMF digit that would mark the Do Not Call
  • liveanswerid - Sound file to be played when the user picks up the phone. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • ansmachineid - Sound file to be played when the call goes to Voice Mail. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • transferfileid - Sound file to be played when the user presses the transfer digit. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • dncfileid - Sound file to be played when the user presses the Do Not call digit. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastWithTransferDNC1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls (10 digits)
numbers 1 1 TRUE xsd:ArrayOfString 10 digit phone numbers to call
transferNumber 1 1 TRUE xsd:string
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
dncDigit 1 1 TRUE xsd:string which DTMF will mark the call Do Not Call
laSoundFileId 1 1 xsd:long Sound file to be played when the user picks up the phone
answeringMachineFileId 1 1 xsd:long Answering machine sound file
transferFileId 1 1 xsd:long Sound file to be played when the user presses the Transfer Digit
dncFileId 1 1 xsd:long Sound file to be played when the user presses the DoNotCall Digit

Output: createBroadcastWithTransferDNC1

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransferDNC1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:laSoundFileId>7143</tnsa:laSoundFileId>
      <tnsa:answeringMachineFileId>-7225</tnsa:answeringMachineFileId>
      <tnsa:transferFileId>-979</tnsa:transferFileId>
      <tnsa:dncFileId>-5415</tnsa:dncFileId>
    </tnsa:createBroadcastWithTransferDNC1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastWithTransferDNC1($api_key,$caller_id,$phoneNumbers,$transfer_number,$transfer_digit,$dnc_digit,$liveanswerid,$ansmachineid,$transferfileid,$dncfileid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		$createBroadcastWithTransferDNCarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'dncDigit' => $dnc_digit,
   		'laSoundFileId' => $liveanswerid,
   		'answeringMachineFileId' => $ansmachineid,
   		'transferFileId' => $transferfileid,
   		'dncFileId' => $dncfileid
		);
		try
		{
			$createBroadcastWithTransferDNCResponse1 = $campaignOutboundClient->createBroadcastWithTransferDNC1($createBroadcastWithTransferDNCarray);
			$campaignId = $createBroadcastWithTransferDNCResponse1->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createBroadcastWithTransferDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, long transferFileId,
            long dncFileId)
        {
            LOG.Info("Entered createBroadcastWithTransferDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                + "string transferNumber, string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, "
                + "long transferFileId, long dncFileId)");

            try
            {
                long campaignId = this.campaignService.createBroadcastWithTransferDNC1(key, callerId, numbers.ToArray(),
                    transferNumber, transferDigit, dncDigit, liveAnswerId, answeringMachineId, transferFileId, dncFileId);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransferDNCWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                    + "string transferNumber, string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, "
                    + "long transferFileId, long dncFileId))");
            }
        }

createBroadcastWithTransferDNCNoAMD

Use this function will create a broadcast list with the Call Transfer Feature & the add to DoNotCall List feature. This function does not have the Answering Machine Detection Feature. Use this function, if you want to upload the sound files from your system.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • dnc_digit - This is the DTMF digit that would mark the Do Not Call
  • liveanswer - Sound file to be played when the user picks up the phone. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • transferfile - Sound file to be played when the user presses the transfer digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • dncfile - Sound file to be played when the user presses the Do Not call digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.


Input: createBroadcastWithTransferDNCNoAMD

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns: ArrayOfString 10 digit phone numbers to call
transferNumber 1 1 TRUE xsd:string 10 digit phone number to transfer to
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
dncDigit 1 1 TRUE xsd:string which DTMF will mark the call Do Not Call
liveAnswer 1 1 TRUE xsd:base64Binary Answering machine sound file
answeringMachine 1 1 TRUE xsd:base64Binary Sound file to play when user presses the transfer digit
transferFile 1 1 TRUE xsd:base64Binary Answering machine sound file
dncFile 1 1 TRUE xsd:base64Binary Sound file to play when user presses the transfer digit


Output: createBroadcastWithTransferDNCNoAMDResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransferDNCNoAMD 
xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:liveAnswer>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:liveAnswer>
      <tnsa:answeringMachine>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:answeringMachine>
      <tnsa:transferFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:transferFile>
      <tnsa:dncFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:dncFile>
    </tnsa:createBroadcastWithTransferDNCNoAMD>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createBroadcastWithTransferDNCNoAMD($api_key,$caller_id,$phoneNumbers,$transfer_number,$transfer_digit,$dnc_digit,$liveanswer,$ansmacfile,$transferfile,$dncfile,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file to byte format
		$handle = fopen($liveanswer,'r');
		$contents = fread($handle,filesize($liveanswer));
		$liveAnswer = $contents;

		$handle2 = fopen($transferfile,'r');
		$contents2 = fread($handle2,filesize($transferfile));
		$transferFile = $contents2;

		$handle3 = fopen($ansmacfile,'r');
		$contents3 = fread($handle3,filesize($ansmacfile));
		$ansmac = $contents3;

		$handle4 = fopen($dncfile,'r');
		$contents4 = fread($handle4,filesize($dncfile));
		$dncfile1 = $contents4;


		$createBroadcastWithTransferDNCNoAMDarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'dncDigit' => $dnc_digit,
   		'liveAnswer' => $liveAnswer,
   		'answeringMachine' => $ansmac,
   		'transferFile' => $transferFile,
   		'dncFile' => $dncfile1
		);
		try
		{
			$createBroadcastWithTransferDNCNoAMDResponse = $campaignOutboundClient->createBroadcastWithTransferDNCNoAMD($createBroadcastWithTransferDNCNoAMDarray);
			$campaignId = $createBroadcastWithTransferDNCNoAMDResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
       public long createBroadcastWithTransferDNCAndNoAMD(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, byte[] transferFile,
            byte[] dncFile)
        {
            LOG.Info("Entered createBroadcastWithTransferDNCAndNoAMD(string key, string callerId, List<string> numbers, "
                + "string transferNumber, string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, "
                + "byte[] transferFile, byte[] dncFile)");

            try
            {
                long campaignId = this.campaignService.createBroadcastWithTransferDNCNoAMD(key, callerId, numbers.ToArray(),
                    transferNumber, transferDigit, dncDigit, liveAnswer, answeringMachine, transferFile, dncFile);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransferDNCAndNoAMD(string key, string callerId, List<string> numbers, "
                    + "string transferNumber, string transferDigit, string dncDigit, byte[] liveAnswer, byte[] answeringMachine, "
                    + "byte[] transferFile, byte[] dncFile)");
            }
        }

createBroadcastWithTransferDNCNoAMD1

This function will create a broadcast list with the Call Transfer Feature & the add to DoNotCall List feature. This function does not have the Answering Machine Detection Feature. Use this function, if you have already uploaded files on CallFire.com

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • caller_id - The caller id that should be presented on each call (10 digits)
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • transfer_number - This is the 10 digit number to which you want to transfer the call to
  • transfer_digit - This is the DTMF digit that will initiate the transfer
  • dnc_digit - This is the DTMF digit that would mark the Do Not Call
  • iveanswer - Sound file to be played when the user picks up the phone. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • transferfile - Sound file to be played when the user presses the transfer digit. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"
  • dncfile - Sound file to be played when the user presses the Do Not call digit. You can get this id by logging onto callfire.com & then goto "Toolbox -> SoundManager"

Input: createBroadcastWithTransferDNCNoAMD1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns: ArrayOfString 10 digit phone numbers to call
transferNumber 1 1 TRUE xsd:string 10 digit phone number to transfer to
transferDigit 1 1 TRUE xsd:string which DTMF digit will initiate the transfer
dncDigit 1 1 TRUE xsd:string which DTMF will mark the call Do Not Call
liveAnswer 1 1 xsd:long Answering machine sound file
answeringMachine 1 1 xsd:long Sound file to play when user presses the transfer digit
transferFile 1 1 xsd:long Answering machine sound file
dncFile 1 1 xsd:long Sound file to play when user presses the transfer digit


Output: createBroadcastWithTransferDNCNoAMD1

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createBroadcastWithTransferDNCNoAMD1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:transferNumber>string</tnsa:transferNumber>
      <tnsa:transferDigit>string</tnsa:transferDigit>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:liveAnswer>-3497</tnsa:liveAnswer>
      <tnsa:answeringMachine>-9374</tnsa:answeringMachine>
      <tnsa:transferFile>6206</tnsa:transferFile>
      <tnsa:dncFile>-8036</tnsa:dncFile>
    </tnsa:createBroadcastWithTransferDNCNoAMD1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
Wsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}

		$createBroadcastWithTransferDNCarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'transferNumber' => $transfer_number,
   		'transferDigit' => $transfer_digit,
   		'dncDigit' => $dnc_digit,
   		'liveAnswer' => $liveanswerid,
   		'answeringMachine' => '0',
   		'transferFile' => $transferfileid,
   		'dncFile' => $dncfileid
		);
		try
		{
			$createBroadcastWithTransferDNCResponse1 = $campaignOutboundClient->createBroadcastWithTransferDNCNoAMD1($createBroadcastWithTransferDNCarray);
			$campaignId = $createBroadcastWithTransferDNCResponse1->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
       public long createBroadcastWithTransferDNCAndNoAMDWithExistingSoundFiles(string key, string callerId, List<string> numbers, string transferNumber,
            string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, long transferFileId,
            long dncFileId)
        {
            LOG.Info("Entered createBroadcastWithTransferDNCAndNoAMDWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                + "string transferNumber, string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, "
                + "long transferFileId, long dncFileId)");

            try
            {
                long campaignId = this.campaignService.createBroadcastWithTransferDNCNoAMD1(key, callerId, numbers.ToArray(),
                    transferNumber, transferDigit, dncDigit, liveAnswerId, answeringMachineId, transferFileId, dncFileId);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createBroadcastWithTransferDNCAndNoAMDWithExistingSoundFiles(string key, string callerId, List<string> numbers, "
                    + "string transferNumber, string transferDigit, string dncDigit, long liveAnswerId, long answeringMachineId, "
                    + "long transferFileId, long dncFileId))");
            }
        }

createLiveAnswerNoDetect

Input: createLiveAnswerNoDetect

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID presented on outbound calls (10 digits)
name 1 1 TRUE xsd:string
mainSoundFile 1 1 xsd:long
fileForPress1 1 1 xsd:long
fileForPress2 1 1 xsd:long
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call

Output: createLiveAnswerNoDetectResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:long
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createLiveAnswerNoDetect xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:name>string</tnsa:name>
      <tnsa:mainSoundFile>-3824</tnsa:mainSoundFile>
      <tnsa:fileForPress1>-9141</tnsa:fileForPress1>
      <tnsa:fileForPress2>6017</tnsa:fileForPress2>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
    </tnsa:createLiveAnswerNoDetect>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

createReplicaCampaign

This function will create a copy of an existing campaign

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • campid - This is the campaign id that you wish to replicate

Input: createReplicaCampaign"

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campId 1 1 xsd:long the campaign id to start

Output: createReplicaCampaign

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createReplicaCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campId>-6334</tnsa:campId>
    </tnsa:createReplicaCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function createReplicaCampaign($api_key,$campid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$createReplicaCampaignList = array(
   		'key' => $api_key,
   		'campId' => $campid
		);
		try
		{
			$createReplicaCampaignResponse = $campaignOutboundClient->createReplicaCampaign($createReplicaCampaignList);
			$campaignId = $createReplicaCampaignResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long createReplicaCampaign(string key, long existingCampaignId)
        {
            LOG.Info("Entered createReplicaCampaign(string key, long existingCampaignId)");

            try
            {
                long campaignId = this.campaignService.createReplicaCampaign(key, existingCampaignId);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createReplicaCampaign(string key, long existingCampaignId)");
            }
        }

createSingleQuestionPoll

This function will create a broadcast to the phone numbers you specify, it allows customers to select one of three options. The sound file provided will be played back to live pickups and be left as a message on answering machines. On live answer, the user can select one of the digits that are valid and the response will be recorded as a "callstatus" string you specify.

  • Live Answer and Answering Machine Detection
  • Leave different messages for Live Answer and Answering Machine
  • Detect any 3 digits from the user to mark the call with a callstatus
  • Specifiy the string to mark the callstatus field for the digit pressed.
(ex. press 1 and set the callstatus to "ACCEPTED")
  • Playback a file when user chooses one of the digits
  • Use your own Callerid
  • Campaign DOES NOT start automatically
Parameters
  • api_key - This is the key that you were provided when you registerd with CallFire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • campid - This is the campaign id that you wish to replicate
  • phoneNumbers - phone numbers to call. You can provide your phone numbers list
  • dncDigit - currently unused please send non NULL value
  • la_file - Sound file to be played when the user picks up the phone. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • am_file - Sound file to be played when the call goes to voice mail. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • dnc_file - Sound file to be played when the user presses the Do Not call digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • poll1_file - Sound file to be played when the user presses the poll1Digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • poll2_file - Sound file to be played when the user presses the poll2Digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • poll3_file - Sound file to be played when the user presses the poll3Digit. File format :: binary sound file. Wav file 16 Bit 8kHz mono.
  • poll1Value - which DTMF digit will initiate the poll1File to be played and the poll1Value to be set
  • poll2Value - which DTMF digit will initiate the poll2File to be played and the poll2Value to be set
  • poll3Value - which DTMF digit will initiate the poll3File to be played and the poll3Value to be set
  • poll1Digit - which String should be used to mark the "status" field when pressing poll1Digit
  • poll2Digit - which String should be used to mark the "status" field when pressing poll2Digit
  • poll3Digit - which String should be used to mark the "status" field when pressing poll3Digit
Special note: to find responses use
  • getCallDetailsFor2000FinishedRecords-to get the call details for 2000 finished records
  • getCallDetailsFor2000Records-to get the call details of 2000 records
  • getSingleCallDetail-to get the details of a single call
and look at the "status" field of CallType

Input: createSingleQuestionPoll

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call
dncDigit 1 1 TRUE xsd:string currently unused please send non NULL value
laFile 1 1 TRUE xsd:base64Binary Live Answer sound file
amfile 1 1 TRUE xsd:base64Binary Answering machine sound file
dncfile 1 1 TRUE xsd:base64Binary Sound file to play when user presses Do Not Call
poll1File 1 1 TRUE xsd:base64Binary which sound should be used after pressing

poll1Digit

poll2File 1 1 TRUE xsd:base64Binary which sound should be used after pressing poll2Digit
poll3File 1 1 TRUE xsd:base64Binary which sound should be used after pressing poll3Digit
poll1Value 1 1 TRUE xsd:string
poll2Value 1 1 TRUE xsd:string which DTMF digit will initiate the poll2File to be played and the poll2Value to be set
poll3Value 1 1 TRUE xsd:string which DTMF digit will initiate the poll1File to be played and the poll1Value to be set
poll1Digit 1 1 TRUE xsd:string which String should be used to mark the "status" field when pressing poll1Digit
poll2Digit 1 1 TRUE xsd:string which String should be used to mark the "status" field when pressing poll2Digit
poll3Digit 1 1 TRUE xsd:string which String should be used to mark the "status" field when pressing poll3Digit

Output: createSingleQuestionPoll'

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:createSingleQuestionPoll xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:dncDigit>string</tnsa:dncDigit>
      <tnsa:lafile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:lafile>
      <tnsa:amfile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:amfile>
      <tnsa:dncfile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:dncfile>
      <tnsa:poll1File>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:poll1File>
      <tnsa:poll2File>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:poll2File>
      <tnsa:poll3File>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:poll3File>
      <tnsa:poll1Value>string</tnsa:poll1Value>
      <tnsa:poll2Value>string</tnsa:poll2Value>
      <tnsa:poll3Value>string</tnsa:poll3Value>
      <tnsa:poll1Digit>string</tnsa:poll1Digit>
      <tnsa:poll2Digit>string</tnsa:poll2Digit>
      <tnsa:poll3Digit>string</tnsa:poll3Digit>
    </tnsa:createSingleQuestionPoll>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
public function createSingleQuestionPoll($api_key,$caller_id,$phoneNumbers,$dncDigit,$la_file,$am_file,$dnc_file,$poll1_file,$poll2_file,$poll3_file
	,$poll1Value,$poll2Value,$poll3Value,$poll1Digit,$poll2Digit,$poll3Digit,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound file to byte format
		$handle = fopen($la_file,'r');
		$contents = fread($handle,filesize($la_file));
		$lafile = $contents;

		$handle1 = fopen($am_file,'r');
		$contents1 = fread($handle1,filesize($am_file));
		$amfile = $contents1;

		$handle2 = fopen($dnc_file,'r');
		$contents2 = fread($handle2,filesize($dnc_file));
		$dncfile = $contents2;

		$handle3 = fopen($poll1_file,'r');
		$contents3 = fread($handle3,filesize($poll1_file));
		$poll1File = $contents3;

		$handle4 = fopen($poll2_file,'r');
		$contents4 = fread($handle4,filesize($poll2_file));
		$poll2File = $contents4;

		$handle5 = fopen($poll3_file,'r');
		$contents5 = fread($handle5,filesize($poll3_file));
		$poll3File = $contents5;

		$createSingleQuestionArray = array(
		'key' => $api_key,
		'callerid' => $caller_id,
		'numbers' => $pnumber,
		'dncDigit' => $dncDigit,
		'lafile' => $lafile,
		'amfile' => $amfile,
		'dncfile' => $dncfile,
		'poll1File' => $poll1File,
		'poll2File' => $poll2File ,
		'poll3File' => $poll3File,
		'poll1Value' => $poll1Value,
		'poll2Value' => $poll2Value,
		'poll3Value' => $poll3Value,
		'poll1Digit' => $poll1Digit,
		'poll2Digit' => $poll2Digit,
		'poll3Digit' => $poll3Digit
		);
		try
		{
			$createSingleQuestionPollResponse = $campaignOutboundClient->createSingleQuestionPoll($createSingleQuestionArray);
			$campaignId = $createSingleQuestionPollResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
public long createSingleQuestionPoll(string key, string callerId, List<string> numbers, string dncDigit,
            byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile, byte[] poll1File, byte[] poll2File, byte[] poll3File,
            string poll1Value, string poll2Value, string poll3Value, string poll1Digit, string poll2Digit, string poll3Digit)
        {
            LOG.Info("Entered createSingleQuestionPoll(string key, string callerId, List<string> numbers, string dncDigit, "
                + "byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile, byte[] poll1File, byte[] poll2File, byte[] poll3File, "
                + "string poll1Value, string poll2Value, string poll3Value, string poll1Digit, string poll2Digit, string poll3Digit)");

            try
            {
                long campaignId = this.campaignService.creategenerateSingleQuestionPoll(key, callerId, numbers.ToArray(),
                    dncDigit, liveAnswer, answeringMachine, dncFile, poll1File, poll2File, poll3File,
                    poll1Value, poll2Value, poll3Value, poll1Digit, poll2Digit, poll3Digit);

                return campaignId;
            }
            finally
            {
                LOG.Info("Exited createSingleQuestionPoll(string key, string callerId, List<string> numbers, string dncDigit, "
                + "byte[] liveAnswer, byte[] answeringMachine, byte[] dncFile, byte[] poll1File, byte[] poll2File, byte[] poll3File, "
                + "string poll1Value, string poll2Value, string poll3Value, string poll1Digit, string poll2Digit, string poll3Digit)");
            }
        }

GET

getCallDetailsFor2000FinishedRecords

This function will return the results of the first 2000 finished records for a particular campaign

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • campaign_id - This is the campaign id that you wish to replicate
  • offset - This is the offset for retrieving the call records. If you have say 4000 records, then you would call the method with offset o first, then call with offset 2000 to get the next 2000 records

Input: getCallDetailsFor2000FinishedRecords

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignid 1 1 xsd:string the campaign id to start
offset 1 1 xsd:int the offset for retrieving the call details

Output: getCallDetailsFor2000FinishedRecordsResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfCallType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getCallDetailsFor2000FinishedRecords xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignid>5473</tnsa:campaignid>
      <tnsa:offset>-7220</tnsa:offset>
    </tnsa:getCallDetailsFor2000FinishedRecords>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getCallDetailsFor2000FinishedRecordsResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<ns1:CallType>
-<agentId xsi:nil="true"></agentId>
-<agentPhoneNumber xsi:nil="true"></agentPhoneNumber>
-<agentResponse xsi:nil="true"></agentResponse>
-<agentUserId xsi:nil="true"></agentUserId>
-<callid>591860562</callid>
-<duration>18</duration>
-<extra xsi:nil="true"></extra>
-<notes xsi:nil="true"></notes>
-<phonenumber>2134002029</phonenumber>
-<status>LA</status>
-<timestarted>2010-06-24T13:39:34-07:00</timestarted>
</ns1:CallType>
-<ns1:CallType>
-<agentId xsi:nil="true"></agentId>
-<agentPhoneNumber xsi:nil="true"></agentPhoneNumber>
-<agentResponse xsi:nil="true"></agentResponse>
-<agentUserId xsi:nil="true"></agentUserId>
-<callid>591860563</callid>
-<duration>14</duration>
-<extra xsi:nil="true"></extra>
-<notes xsi:nil="true"></notes>
-<phonenumber>8185537413</phonenumber>
-<status>LA</status>
-<timestarted>2010-06-24T13:39:34-07:00</timestarted>
</ns1:CallType>
</ns1:out>
</ns1:getCallDetailsFor2000FinishedRecordsResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
public function getCallDetailsFor2000FinishedRecords($api_key,$campaign_id,$offset,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getCallDetailsFor2000RecordsArray = array (
		'key' => $api_key,
		'campaignid' => $campaign_id,
		'offset' => $offset
		);
		try
		{
			$getcallDetailsfor2000RecordsResponse = $campaignOutboundClient->getCallDetailsFor2000FinishedRecords($getCallDetailsFor2000RecordsArray);
			$getCallDetails = $getcallDetailsfor2000RecordsResponse->out;
			if($debug)
			{
				echo "<table border=1><tr><td>agentId</td><td>agentPhoneNumber</td><td>agentResponse</td><td>agentUserId</td><td>callid</td><td>duration</td><td>extra</td><td>notes</td><td>phonenumber</td><td>status</td><td>timestarted</td></tr>";
				foreach($getCallDetails->CallType as $line)
				{
					echo "<tr>";
					echo "<td>".$line->agentId."</td>";
					echo "<td>".$line->agentPhoneNumber."</td>";
					echo "<td>".$line->agentResponse."</td>";
					echo "<td>".$line->agentUserId."</td>";
					echo "<td>".$line->callid."</td>";
					echo "<td>".$line->duration."</td>";
					echo "<td>".$line->extra."</td>";
					echo "<td>".$line->notes."</td>";
					echo "<td>".$line->phonenumber."</td>";
					echo "<td>".$line->status."</td>";
					echo "<td>".$line->timestarted."</td>";
					echo "</tr>";
				}
				echo "</table>";
				//print_r($getCallDetails);
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
public CallType[] getCallDetailsFor2000FinishedRecords(string key, long campaignId, int offset)
        {
            LOG.Info("Entered getCallDetailsFor2000FinishedRecords(string key, long campaignId, int offset)");

            try
            {
                CallType[] callTypeArray = 
                    this.campaignService.getCallDetailsFor2000FinishedRecords(key, campaignId, offset);

                return callTypeArray;
            }
            finally
            {
                LOG.Info("Exited getCallDetailsFor2000FinishedRecords(string key, long campaignId, int offset)");
            }
        }

getCallDetailsFor2000Records

This function will return the details of each call in a campaign. At the most it will return 2000 records. If you have a campaign with more than 2000 records, use the offset variable to retrieve all the records.

For example: To retrieve 4000 records, you would call the method with offset 0 first, then call with offset 2000 to get the next 2000 records.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • campaign_id - This is the campaign id that you wish to replicate
  • offset - This is the offset for retrieving the call records.

Input: getCallDetailsFor2000Records

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignid 1 1 xsd:long the id of the campaign
offset 1 1 xsd:int the offset for retrieving the call details

Output: getCallDetailsFor2000Records

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfCallType An array of CallType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getCallDetailsFor2000FinishedRecords xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignid>5473</tnsa:campaignid>
      <tnsa:offset>-7220</tnsa:offset>
    </tnsa:getCallDetailsFor2000FinishedRecords>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getCallDetailsFor2000RecordsResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<ns1:CallType>
-<agentId xsi:nil="true"></agentId>
-<agentPhoneNumber xsi:nil="true"></agentPhoneNumber>
-<agentResponse xsi:nil="true"></agentResponse>
-<agentUserId xsi:nil="true"></agentUserId>
-<callid>589431943</callid>
-<duration>0</duration>
-<extra xsi:nil="true"></extra>
-<notes xsi:nil="true"></notes>
-<phonenumber>2134000543</phonenumber>
-<status xsi:nil="true"></status>
</ns1:CallType>
</ns1:out>
</ns1:getCallDetailsFor2000RecordsResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
public function getCallDetailsFor2000Records($api_key,$campaign_id,$offset,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getCallDetailsFor2000RecordsArray1 = array (
		'key' => $api_key,
		'campaignid' => $campaign_id,
		'offset' => $offset
		);
		try
		{
			$getcallDetailsfor2000RecordsResponse1 = $campaignOutboundClient->getCallDetailsFor2000Records($getCallDetailsFor2000RecordsArray1);
			$getCallDetails1 = $getcallDetailsfor2000RecordsResponse1->out;
			if($debug)
			{
				echo "<table border=1><tr><td>agentId</td><td>agentPhoneNumber</td><td>agentResponse</td><td>agentUserId</td><td>callid</td><td>duration</td><td>extra</td><td>notes</td><td>phonenumber</td><td>status</td><td>timestarted</td></tr>";
				foreach($getCallDetails1->CallType as $line)
				{
					echo "<tr>";
					echo "<td>".$line->agentId."</td>";
					echo "<td>".$line->agentPhoneNumber."</td>";
					echo "<td>".$line->agentResponse."</td>";
					echo "<td>".$line->agentUserId."</td>";
					echo "<td>".$line->callid."</td>";
					echo "<td>".$line->duration."</td>";
					echo "<td>".$line->extra."</td>";
					echo "<td>".$line->notes."</td>";
					echo "<td>".$line->phonenumber."</td>";
					echo "<td>".$line->status."</td>";
					echo "<td>".$line->timestarted."</td>";
					echo "</tr>";
				}
				echo "</table>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
 public CallType[] getCallDetailsFor2000Records(string key, long campaignId, int offset)
        {
            LOG.Info("Entered getCallDetailsFor2000Records(string key, long campaignId, int offset)");

            try
            {
                CallType[] callTypeArray = this.campaignService.getCallDetailsFor2000Records(key, campaignId, offset);

                return callTypeArray;
            }
            finally
            {
                LOG.Info("Exited getCallDetailsFor2000Records(string key, long campaignId, int offset)");
            }
        }

getSingleCallDetail

This function will return the details of each call.

Input: getSingleCallDetail

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callid 1 1 xsd:long the id of the call

Output: getSingleCallDetail

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:CallType CallType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getSingleCallDetail xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callid>5473</tnsa:callid>
    </tnsa:getSingleCallDetail>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getSingleCallDetailResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<agentId xsi:nil="true"></agentId>
-<agentPhoneNumber xsi:nil="true"></agentPhoneNumber>
-<agentResponse xsi:nil="true"></agentResponse>
-<agentUserId xsi:nil="true"></agentUserId>
-<callid>591886360</callid>
-<duration>0</duration>
-<extra xsi:nil="true"></extra>
-<notes xsi:nil="true"></notes>
-<phonenumber>2134000543</phonenumber>
-<status xsi:nil="true"></status>
</ns1:out>
</ns1:getSingleCallDetailResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
public function getSingleCallDetail($api_key,$call_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getSingleCallDetailarray = array (
		'key' => $api_key,
		'callid' => $call_id
		);
		try
		{
			$getSingleCallDetailResponse = $campaignOutboundClient->getSingleCallDetail($getSingleCallDetailarray);
			$getSingleCallDetails = $getSingleCallDetailResponse->out;
			if($debug)
			{
				echo "<b>Call Details";
				echo "agentId : ".$getSingleCallDetails->agentId;
				echo "agentPhoneNumber : ".$getSingleCallDetails->agentPhoneNumber;
				echo "agentResponse : ".$getSingleCallDetails->agentResponse;
				echo "agentUserId : ".$getSingleCallDetails->agentUserId;
				echo "callid : ".$getSingleCallDetails->callid;
				echo "duration : ".$getSingleCallDetails->duration;
				echo "extra : ".$getSingleCallDetails->extra;
				echo "notes : ".$getSingleCallDetails->notes;
				echo "phonenumber : ".$getSingleCallDetails->phonenumber;
				echo "status : ".$getSingleCallDetails->status;
				echo "timestarted : ".$getSingleCallDetails->timestarted;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}


getCampaignByName

This function will return all campaigns that match the name passed in. This can be used to retrieve your campaigns by their name.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto callfire.com & then goto "Settings -> Account Settings"
  • campaignname - This is the name of the campaign

Input: getCampaignByName

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignName 1 1 TRUE xsd:string the name of the campaign

Output: getCampaignByNameResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfCampaignTypeAn array of CampaignType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getCampaignByName xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignName>string</tnsa:campaignName>
    </tnsa:getCampaignByName>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
public function getCampaignByName($api_key,$campaignname,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getCampaignByNamearray = array (
		'key' => $api_key,
		'campaignName' => $campaignname
		);
		try
		{
			$getCampaignBynameResponse = $campaignOutboundClient->getCampaignByName($getCampaignByNamearray);
			$getCampaignBynameDetails = $getCampaignBynameResponse->out;
			if($debug)
			{
				echo "<table border=1><tr><td>busy</td><td>campaignId</td><td>dialed</td><td>doNotCall</td><td>error</td><td>live</td><td>misc</td><td>name</td><td>noAnswer</td><td>status</td><td>total</td><td>transfer</td><td>type</td></tr>";
				foreach($getCampaignBynameDetails->CampaignType as $line)
				{
					echo "<tr>";
					echo "<td>".$line->busy."</td>";
					echo "<td>".$line->campaignId."</td>";
					echo "<td>".$line->dialed."</td>";
					echo "<td>".$line->doNotCall."</td>";
					echo "<td>".$line->error."</td>";
					echo "<td>".$line->live."</td>";
					echo "<td>".$line->misc."</td>";
					echo "<td>".$line->name."</td>";
					echo "<td>".$line->noAnswer."</td>";
					echo "<td>".$line->status."</td>";
					echo "<td>".$line->total."</td>";
					echo "<td>".$line->transfer."</td>";
					echo "<td>".$line->type."</td>";
					echo "</tr>";
				}
				echo "</table>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
public CampaignType[] getCampaignByName(string key, string campaignName)
        {
            LOG.Info("Entered getCampaignByName(string key, string campaignName)");

            try
            {
                CampaignType[] campaignTypeArray = this.campaignService.getCampaignByName(key, campaignName);

                return campaignTypeArray;
            }
            finally
            {
                LOG.Info("Exited getCampaignByName(string key, string campaignName)");
            }
        }

getCampaignIDs

This function will return all campaigns that match the id passed in. This can be used to retrieve your campaigns by their id's.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • acctid - This is your account id.
  • msgid - This is the message id.

Input: getCampaignIDs

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
acctid 1 1 TRUE xsd:string
msgid 1 1 TRUE xsd:string

Output: getCampaignIDsResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfLong
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getCampaignIDs xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:acctid>string</tnsa:acctid>
      <tnsa:msgid>string</tnsa:msgid>
    </tnsa:getCampaignIDs>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
public function getCampaignIDs($api_key,$acctid,$msgid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getCampaignIDsArray = array (
		'key' => $api_key,
		'acctid' => $acctid,
		'msgid' => $msgid
		);
		try
		{
			$getCampaignIDsResponse = $campaignOutboundClient->getCampaignIDs($getCampaignIDsArray);
			$getCampaignIDsDetails = $getCampaignIDsResponse->out;
			if($debug)
			{
				print_r($getCampaignIDsDetails);
				//print_r( $getCampaignstatsDetails[$name]);
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long[] getCampaignIds(string key, string acctId, string msgId)
        {
            LOG.Info("Entered getCampaignIds(string key, string acctId, string msgId)");

            try
            {
                long[] campaignIdArray = this.campaignService.getCampaignIDs(key, acctId, msgId);

                return campaignIdArray;
            }
            finally
            {
                LOG.Info("Exited getCampaignIds(string key, string acctId, string msgId)");
            }
        }

getCampaignStats

Use this function to return the statistics for a campaign. The statistics will include the following information ::

  • campaignId : The callfire unique id for the campaign
  • name : The name of the campaign
  • type : The type of campaign
  • status : The current state of the campaign (Running, Stopped, Finished, Cancelled)
  • total : The total calls in the campaign
  • dialed : The total dialed in the campaign
  • live : The total live answer in the campaign
  • answeringMachine : The total Answering Machine in the campaign
  • noAnswer : The total No Answers in teh campaign
  • doNotCall : The total DNC marked in the campaign
  • busy : The total Busy in the campaign
  • transfer : The total transfers in the campaign
  • error : The total calls that were Error's
  • misc : The total calls that faced a CallFire system error.
Parameters
  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"
  • campaign_id - The campaign id that you wish to start


Input: getCampaignStats

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long the campaign id to start

Output: getCampaignStatsResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:CampaignType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getCampaignStats xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>-3916</tnsa:campaignId>
    </tnsa:getCampaignStats>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getCampaignStatsResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<answeringMachine>0</answeringMachine>
-<busy>0</busy>
-<campaignId>1123231</campaignId>
-<dialed>0</dialed>
-<doNotCall>0</doNotCall>
-<error>0</error>
-<live>0</live>
-<misc>0</misc>
-<name>csdfsd api</name>
-<noAnswer>0</noAnswer>
-<status>Running</status>
-<total>2</total>
-<transfer>0</transfer>
-<type>CallCenterConnect</type>
</ns1:out>
</ns1:getCampaignStatsResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
	public function getCampaignStats($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getCampaignstatsArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);

		$campaigntype = new CampaignType();
		try
		{
			$getCampaignStatsResponse = $campaignOutboundClient->getCampaignStats($getCampaignstatsArray);
			$getCampaignstatsDetails = $getCampaignStatsResponse->out;
			if($debug)
			{
				echo "<b>Campaign Statistics";
				echo "answeringMachine : ".$getCampaignstatsDetails->answeringMachine;
				echo "busy : ".$getCampaignstatsDetails->busy;
				echo "campaignId : ".$getCampaignstatsDetails->campaignId;
				echo "dialed : ".$getCampaignstatsDetails->dialed;
				echo "doNotCall : ".$getCampaignstatsDetails->doNotCall;
				echo "error : ".$getCampaignstatsDetails->error;
				echo "live : ".$getCampaignstatsDetails->live;
				echo "misc : ".$getCampaignstatsDetails->misc;
				echo "name : ".$getCampaignstatsDetails->name;
				echo "noAnswer : ".$getCampaignstatsDetails->noAnswer;
				echo "status : ".$getCampaignstatsDetails->status;
				echo "total : ".$getCampaignstatsDetails->total;
				echo "transfer : ".$getCampaignstatsDetails->transfer;
				echo "type : ".$getCampaignstatsDetails->type;

			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public CampaignType getCampaignStats(string key, long campaignId)
        {
            LOG.Info("Entered getCampaignStats(string key, long campaignId)");

            try
            {
                CampaignType campaignType = this.campaignService.getCampaignStats(key, campaignId);

                return campaignType;
            }
            finally
            {
                LOG.Info("Exited getCampaignStats(string key, long campaignId)");
            }
        }

getFullCampaignList

Returns a list of all your campaigns and their statistics.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"

Input: getFullCampaignList

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page

Output: getFullCampaignListResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfCampaignType An array of CampaignType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getFullCampaignList xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
    </tnsa:getFullCampaignList>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getFullCampaignListResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<ns1:CampaignType>
-<answeringMachine>0</answeringMachine>
-<busy>0</busy>
-<campaignId>1091867</campaignId>
-<dialed>0</dialed>
-<doNotCall>0</doNotCall>
-<error>0</error>
-<live>0</live>
-<misc>0</misc>
-<name>api no AMD TTS campaign Fri Jun 04 18:33:43 PDT 2010</name>
-<noAnswer>0</noAnswer>
-<status>New</status>
-<total>2</total>
-<transfer>0</transfer>
-<type>Threshold</type>
</ns1:CampaignType>
</ns1:out>
</ns1:getFullCampaignListResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
	public function getFullCampaignList($api_key,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getFullCampaignListArray = array (
		'key' => $api_key
		);
		try
		{
			$getFullCampaignlistResponse = $campaignOutboundClient->getFullCampaignList($getFullCampaignListArray);
			$getFullCampaignDetails = $getFullCampaignlistResponse->out;
			if($debug)
			{
				echo "<table border=1><tr><td>busy</td><td>campaignId</td><td>dialed</td><td>doNotCall</td><td>error</td><td>live</td><td>misc</td><td>name</td><td>noAnswer</td><td>status</td><td>total</td><td>transfer</td><td>type</td></tr>";
				foreach($getFullCampaignDetails->CampaignType as $line)
				{
					echo "<tr>";
					echo "<td>".$line->busy."</td>";
					echo "<td>".$line->campaignId."</td>";
					echo "<td>".$line->dialed."</td>";
					echo "<td>".$line->doNotCall."</td>";
					echo "<td>".$line->error."</td>";
					echo "<td>".$line->live."</td>";
					echo "<td>".$line->misc."</td>";
					echo "<td>".$line->name."</td>";
					echo "<td>".$line->noAnswer."</td>";
					echo "<td>".$line->status."</td>";
					echo "<td>".$line->total."</td>";
					echo "<td>".$line->transfer."</td>";
					echo "<td>".$line->type."</td>";
					echo "</tr>";
				}
				echo "</table>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public CampaignType[] getFullCampaignList(string key)
        {
            LOG.Info("Entered getFullCampaignList(string key)");

            try
            {
                CampaignType[] campaignTypeArray = this.campaignService.getFullCampaignList(key);

                return campaignTypeArray;
            }
            finally
            {
                LOG.Info("Exited getFullCampaignList(string key)");
            }
        }

getMinuteBalance

This function will return the available balance (in minutes) in your account

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"

Input: getMinuteBalance

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page

Output: getMinuteBalance

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:string
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getMinuteBalance xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
    </tnsa:getMinuteBalance>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getMinuteBalanceResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>2,629</ns1:out>
</ns1:getMinuteBalanceResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
public function getMinuteBalance($api_key,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getMinutebalanceArray = array (
		'key' => $api_key
		);
		
		print_r($getMinutebalanceArray);
		try
		{
			$getMinuteBalanceResponse = $campaignOutboundClient->getMinuteBalance($getMinutebalanceArray);
			$getBalanceDetails = $getMinuteBalanceResponse->out;
			if($debug)
			{
				echo "Your Current Minute Balance is ".$getBalanceDetails;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
  public string getMinuteBalance(string key)
        {
            LOG.Info("Entered getMinuteBalance(string key)");

            try
            {
                string balance = this.campaignService.getMinuteBalance(key);

                return balance;
            }
            finally
            {
                LOG.Info("Exited getMinuteBalance(string key)");
            }
        }

getRunningCampaignList

Returns a list of Running Campaigns and their statistics.

Parameters

  • api_key - This is the key that you were provided when you registered with CallFire.com. You can view your key by logging onto CallFire.com & then goto "Settings -> Account Settings"


Input: getRunningCampaignList

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page

Output: getRunningCampaignList

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE tns:ArrayOfCampaignType
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:getRunningCampaignList xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
    </tnsa:getRunningCampaignList>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response
<soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
>
-<soap:Body>
-<ns1:getRunningCampaignListResponse xmlns:ns1="http://api.campaign.dialer.skyyconsulting.com">
-<ns1:out>
-<ns1:CampaignType>
-<answeringMachine>0</answeringMachine>
-<busy>0</busy>
-<campaignId>1123231</campaignId>
-<dialed>0</dialed>
-<doNotCall>0</doNotCall>
-<error>0</error>
-<live>0</live>
-<misc>0</misc>
-<name>csdfsd api</name>
-<noAnswer>0</noAnswer>
-<status>Running</status>
-<total>2</total>
-<transfer>0</transfer>
-<type>CallCenterConnect</type>
</ns1:CampaignType>
</ns1:out>
</ns1:getRunningCampaignListResponse>
</soap:Body>
</soap:Envelope>
Sample PHP Code
public function getRunningCampaignList($api_key,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getRunningCampaignListArray = array (
		'key' => $api_key
		);
		try
		{
			$getRunningCampaignResponse = $campaignOutboundClient->getRunningCampaignList($getRunningCampaignListArray);
			$getCampaignDetails = $getRunningCampaignResponse->out;
			if($debug)
			{
				echo "<table border=1><tr><td>busy</td><td>campaignId</td><td>dialed</td><td>doNotCall</td><td>error</td><td>live</td><td>misc</td><td>name</td><td>noAnswer</td><td>status</td><td>total</td><td>transfer</td><td>type</td></tr>";
				foreach($getCampaignDetails->CampaignType as $line)
				{
					echo "<tr>";
					echo "<td>".$line->busy."</td>";
					echo "<td>".$line->campaignId."</td>";
					echo "<td>".$line->dialed."</td>";
					echo "<td>".$line->doNotCall."</td>";
					echo "<td>".$line->error."</td>";
					echo "<td>".$line->live."</td>";
					echo "<td>".$line->misc."</td>";
					echo "<td>".$line->name."</td>";
					echo "<td>".$line->noAnswer."</td>";
					echo "<td>".$line->status."</td>";
					echo "<td>".$line->total."</td>";
					echo "<td>".$line->transfer."</td>";
					echo "<td>".$line->type."</td>";
					echo "</tr>";
				}
				echo "</table>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public CampaignType[] getRunningCampaignList(string key)
        {
            LOG.Info("Entered getRunningCampaignList(string key)");

            try
            {
                CampaignType[] campaignTypeArray = this.campaignService.getRunningCampaignList(key);

                return campaignTypeArray;
            }
            finally
            {
                LOG.Info("Exited getRunningCampaignList(string key)");
            }
        }

SEND

sendBroadcastToList

This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines.

Warning: This function will automatically start the campaign! Only call this if you are ready to broadcast right away.

Parameters

  • api_key - This is the key that you got when you registerd with CallFire.com
  • caller_id - Caller ID that would be presented on oubound calls
  • phoneNumbers - PhoneNumbers file that you wish to call
  • sound_file - Sound file that you wish to play. Format : binarysound File. Should be a .wav file 16Bit 8kHz mono


Input: sendBroadcastToList

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID presented on outbound calls (10 digits)
numbers 1 1 TRUE tns:ArrayOfString an Array of Phone numbers (10 digits)
soundFile 1 1 TRUE xsd:base64Binary binary sound file. Wav file 16 Bit 8kHz mono.

Output: sendBroadcastToListResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:long
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendBroadcastToList xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
    </tnsa:sendBroadcastToList>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Sample PHP Code
public function sendBroadcastToList($api_key,$caller_id,$phoneNumbers,$sound_file,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound files to byte format
		$handle = fopen($sound_file,'r');
		$contents = fread($handle,filesize($sound_file));
		$soundFile = $contents;

		$broadcastarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'soundFile' => $sound_file
		);
		try
		{
			$sendBroadcasttoListResponse = $campaignOutboundClient->sendBroadcastToList($broadcastarray);
			$campaignId = $sendBroadcasttoListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long sendBroadcastToList(string key, string callerId, string[] numbers, byte[] soundFile)
        {
            // LOG.Info("Entered sendBroadcastToList(string key, string callerId, string[] numbers, byte[] soundFile)");

            try
            {
                long broadcastId = this.campaignService.sendBroadcastToList(key, callerId, numbers, soundFile);
                return broadcastId;
            }
            finally
            {
               // LOG.Info("Exited sendBroadcastToList(string key, string callerId, string[] numbers, byte[] soundFile)");
            }
        }

sendBroadcastToList1

This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines. Warning: This function will automatically start the campaign!. Only call this if you are ready to broadcast right away.

Parameters

  • api_key - This is the key that you got when you registerd with CallFire.com
  • caller_id - Caller ID that would be presented on oubound calls
  • list_id - This is the id of the list that you wish to upload. You can view this id by logging onto callfire.com. Goto "Toolbox -> Phonebooks & DNC"
  • sound_file - Sound file that you wish to play. Format : binarysound File. Should be a .wav file 16Bit 8kHz mono

Input: sendBroadcastToList1

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
listid 1 1 xsd:long
soundFile 1 1 TRUE xsd:base64binary binarysound file. Wav file 16Bit 8kHz mono.

Output: sendBroadcastToList1Response

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:long
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendBroadcastToList1 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:listid>-3210</tnsa:listid>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
    </tnsa:sendBroadcastToList1>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Sample PHP Code
 	public function sendBroadcastToList1($api_key,$caller_id,$list_id,$sound_file,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		//Converting the sound files to byte format
		$handle = fopen($sound_file,'r');
		$contents = fread($handle,filesize($sound_file));
		$soundFile = $contents;

		$broadcastarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'listid' => $list_id,
   		'soundFile' => $sound_file
		);
		try
		{
			$sendBroadcasttoListResponse = $campaignOutboundClient->sendBroadcastToList1($broadcastarray);
			$campaignId = $sendBroadcasttoListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."<br/>";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public long sendBroadcastToList1(string key, string callerId, long listId, byte[] soundFile)
        {
            //LOG.Info("Entered sendBroadcastToList1(string key, string callerId, long listId, byte[] soundFile)");

            try
            {
                long broadcastId = this.campaignService.sendBroadcastToList1(key, callerId, listId, soundFile);
                return broadcastId;
            }
            finally
            {
                //LOG.Info("Exited sendBroadcastToList1(string key, string callerId, long listId, byte[] soundFile)");
            }
        }

sendBroadcastToList2

This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines. Warning: This function will automatically start the campaign! Only call this if you are ready to broadcast right away.

Parameters

  • api_key - This is the key that you got when you registered with CallFire.com
  • caller_id - Caller ID that would be presented on outbound calls
  • phoneNumbers - PhoneNumbers file that you wish to call
  • sound_file - Sound file that you wish to play. Format : binarysound File. Should be a .wav file 16Bit 8kHz mono
  • name - This is the name of the campaign

Input: sendBroadcastToList2

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls (10 digits)
numbers 1 1 TRUE tns:ArrayOfString 10 digit phone numbers to call
soundFile 1 1 TRUE xsd:base64Binary
name 1 1 TRUE xsd:string

Output: sendBroadcastToList2

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendBroadcastToList2 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
      <tnsa:name>string</tnsa:name>
    </tnsa:sendBroadcastToList2>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function sendBroadcastToList2($api_key,$caller_id,$phoneNumbers,$sound_file,$name,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		//Converting the sound files to byte format
		$handle = fopen($sound_file,'r');
		$contents = fread($handle,filesize($sound_file));
		$soundFile = $contents;
		$broadcastarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'soundFile' => $soundFile,
   		'name' => $name
		);
		try
		{
			$sendBroadcasttoListResponse = $campaignOutboundClient->sendBroadcastToList2($broadcastarray);
			$campaignId = $sendBroadcasttoListResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long sendBroadcastToList2(string key, string callerId, string[] numbers, byte[] soundFile, string name)
        {
            LOG.Info("Entered sendBroadcastToList2(string key, string callerId, string[] numbers, byte[] soundFile, string name)");

            try
            {
                long broadcastId = this.campaignService.sendBroadcastToList2(key, callerId, numbers, soundFile, name);
                return broadcastId;
            }
            finally
            {
                LOG.Info("Exited sendBroadcastToList2(string key, string callerId, string[] numbers, byte[] soundFile, string name)");
            }
        }

sendBroadcastToListWithSoundId

This function will allow you to send a broadcast out to the phone numbers you specify. The sound file provided will be played back to live pickups and be left as a message on answering machines. Warning: This function will automatically start the campaign! Only call this if you are ready to broadcast right away.

Parameters

  • api_key - This is the key that you got when you registered with CallFire.com
  • caller_id - Caller ID that would be presented on outbound calls
  • phoneNumbers - PhoneNumbers file that you wish to call
  • sound_file - This is the id of the sound file thay you wish to play. You can get this id by logging onto CallFire.com

Input: sendBroadcastToListWithSoundId

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID displayed on outbound calls
numbers 1 1 TRUE tns: ArrayOfString 10 digit phone numbers to call
soundFile 1 1 xsd:long

Output: sendBroadcastToListWithSoundIdResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendBroadcastToListWithSoundId xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:numbers>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:numbers>
      <tnsa:soundFile>-9742</tnsa:soundFile>
    </tnsa:sendBroadcastToListWithSoundId>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Sample PHP Code
	public function sendBroadcastToListWithSoundId($api_key,$caller_id,$phoneNumbers,$sound_file,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$lines = file($phoneNumbers) or die('Unable to upload phone numbers');
		foreach($lines as $line)
		{
			$pnumber['string'][] = $line;
		}
		$broadcastarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'numbers' => $pnumber,
   		'soundFile' => $sound_file
		);
		try
		{
			$sendBroadcasttoListwithSoundIDResponse = $campaignOutboundClient->sendBroadcastToListWithSoundId($broadcastarray);
			$campaignId = $sendBroadcasttoListwithSoundIDResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long sendBroadcastToListWithExistingSoundFile(string key, string callerId, string[] numbers, long soundFile)
        {
            LOG.Info("Entered sendBroadcastToListWithExistingSoundFile(string key, string callerId, string[] numbers,long soundFile)");

            try
            {
                long broadcastId = this.campaignService.sendBroadcastToListWithSoundId(key, callerId, numbers, soundFile);
                return broadcastId;
            }
            finally
            {
                LOG.Info("Exited sendBroadcastToListWithExistingSoundFile(string key, string callerId, string[] numbers, long soundFile)");
            }
        }

sendCallForCampaign

This function sends a single call out immediately. The call will follow the design of the campaign specified and be included in campaign stats

Parameters

  • api_key - This is the key that you got when you registered with CallFire.com
  • campaign_id - This is the campaign id that you wish to start
  • number - PhoneNumber that you wish to call
  • moreData - Additional data that you may have

Input: sendCallForCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long the campaign id to start
number 1 1 TRUE xsd:string
moreData 1 1 TRUE xsd:ArrayOfString

Output: sendCallForCampaignResponse

Name maxOccurs minOccurs nillable type description
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendCallForCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>-3447</tnsa:campaignId>
      <tnsa:number>string</tnsa:number>
      <tnsa:moreData>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
        <tnsa:string>string</tnsa:string>
      </tnsa:moreData>
    </tnsa:sendCallForCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function sendCallForCampaign($api_key,$campaign_id,$phoneNumber,$moreData,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$sendcallarray = array(
   		'key' => $api_key,
   		'campaignId' => $campaign_id,
   		'number' => $phoneNumber,
   		'moreData' => $moreData
		);
		try
		{
			$sendCallForCampaignResponse = $campaignOutboundClient->sendCallForCampaign($sendcallarray);
			$campaignId = $sendCallForCampaignResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public void sendCallForCampaign(string key, long campaignId, string number, string[] moreData)
        {
            LOG.Info("Entered sendCallForCampaign(string key, long campaignId, string number, string[] moreData)");

            try
            {
                this.campaignService.sendCallForCampaign(key, campaignId, number, moreData);
            }
            finally
            {
                LOG.Info("Exited sendCallForCampaign(string key, long campaignId, string number, string[] moreData)");
            }
        }

sendSingleBridgeCall

This function sends a single call out immediately with the ability to have the transfer option to an extension number. The call will follow the design of the campaign specified and be included in campaign stats

Parameters

  • api_key - This is the key that you got when you registered with CallFire.com
  • caller_id - This ID would be presented on all outbound calls
  • agentNumber - This is your agent's id
  • extension - The extension that you wish to use
  • transfer - The digit that you wish to use to make the transfer to the extension specified

Input: sendSingleBridgeCall

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string Caller ID presented on outbound calls (10 digits)
agentNumber 1 1 TRUE xsd:string
extension 1 1 TRUE xsd:string
transfer 1 1 TRUE xsd:string

Output: sendSingleBridgeCallResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:long


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendSingleBridgeCall xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:agentNumber>string</tnsa:agentNumber>
      <tnsa:extension>string</tnsa:extension>
      <tnsa:transfer>string</tnsa:transfer>
    </tnsa:sendSingleBridgeCall>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function sendSingleBridgeCall($api_key,$caller_id,$agentNumber,$extension,$transfer,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$sendSingleBridgeCallarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'agentNumber' => $agentnumber,
   		'extension' => $extension,
   		'transfer' => $transfer
		);
		try
		{
			$sendSinglebridgeCallResponse = $campaignOutboundClient->sendSingleBridgeCall($sendSingleBridgeCallarray);
			$campaignId = $sendSinglebridgeCallResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long sendSingleBridgeCall(string key, string callerId, string agentNumber, string extension, string transfer)
        {
            LOG.Info("Entered sendSingleBridgeCall(string key, string callerId, string agentNumber, string extension, string transfer)");

            try
            {
                long broadcastId = this.campaignService.sendSingleBridgeCall(key, callerId, agentNumber, extension, transfer);
                return broadcastId;
            }
            finally
            {
                LOG.Info("Exited sendSingleBridgeCall(string key, string callerId, string agentNumber, string extension, string transfer)");
            }
        }

sendSingleCallCampaign

This function sends a single call out immediately. The call will follow the design of the campaign specified and be included in campaign stats.

Parameters

  • api_key - This is the key that you got when you registered with CallFire.com
  • caller_id - This ID would be presented on all outbound calls
  • number - This is the number that you wish to send the call to.
  • sound_file - Sound file that you wish to play. Format : binarysound File. Should be a .wav file 16Bit 8kHz mono

Input: sendSingleCallCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
callerid 1 1 TRUE xsd:string the callerid that should be presented on each call (10 digits)
number 1 1 TRUE xsd:string
soundFile 1 1 TRUE xsd:base64Binary

Output: sendSingleCallCampaignResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:sendSingleCallCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:callerid>string</tnsa:callerid>
      <tnsa:number>string</tnsa:number>
      <tnsa:soundFile>YTM0NZomIzI2OTsmIzM0NTueYQ==</tnsa:soundFile>
    </tnsa:sendSingleCallCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Sample PHP Code
	public function sendSingleCallCampaign($api_key,$caller_id,$number,$sound_file,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';

		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));

		//Converting the sound files to byte format
		$handle = fopen($sound_file,'r');
		$contents = fread($handle,filesize($sound_file));
		$soundFile = $contents;

		$sendSingleCallCampaignarray = array(
   		'key' => $api_key,
   		'callerid' => $caller_id,
   		'number' => $number,
   		'soundFile' => $soundFile
		);
		try
		{
			$sendSingleCallcampaignResponse = $campaignOutboundClient->sendSingleCallCampaign($sendSingleCallCampaignarray);
			$campaignId = $sendSingleCallcampaignResponse->out;
			if($debug)
			{
				echo "CampaignID : ".$campaignId."";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."";
			}
		}
	}
Sample C# Code
        public long sendSingleCallCampaign(string key, string callerId, string number, byte[] soundFile)
        {
            LOG.Info("Entered sendSingleCallCampaign(string key, string callerId, string number, byte[] soundFile)");

            try
            {
                long broadcastId = this.campaignService.sendSingleCallCampaign(key, callerId, number, soundFile);
                return broadcastId;
            }
            finally
            {
                LOG.Info("Exited sendSingleCallCampaign(string key, string callerId, string number, byte[] soundFile)");
            }
        }

MODIFY

deleteCampaign

Use this function to delete a campaign from your callfire account.

Input: deleteCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long this is the id of the campaign that you want to delete.

Output: deleteCampaignResponse

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:long campaignid


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:deleteCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>363</tnsa:campaignId>
    </tnsa:deleteCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


Example Response

Sample PHP Code
	public function deleteCampaign($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$deleteCampaignArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);
		try
		{
			$deleteCampaignResponse = $campaignOutboundClient->deleteCampaign($deleteCampaignArray);
			$deleteCampaignId = $deleteCampaignResponse->out;
			if($debug)
			{
				echo "Campaign # ID ".$campaign_id ." successfully deleted..";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public string deleteCampaign(string key, long campaignId)
        {
            LOG.Info("Entered deleteCampaign(string key, long campaignId)");

            try
            {
                string status = this.campaignService.deleteCampaign(key, campaignId);

                return status;
            }
            finally
            {
                LOG.Info("Exited deleteCampaign(string key, long campaignId)");
            }
        }

useAnsweringMachineDetectionType2

Input: useAnsweringMachineDetectionType2

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long the campaign id to change to the new Answering machine detection

Output: useAnsweringMachineDetectionType2

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:void


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:useAnsweringMachineDetectionType2 xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>363</tnsa:campaignId>
    </tnsa:useAnsweringMachineDetectionType2>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>


scrubCampaign

Use this function to remove numbers from the DNC. (i.e. the Do Not Call List of a particular Campaign)

Input: scrubCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long campaign id for which you want to scrub the numbers from the DoNotCall(DNC) List


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:scrubCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>8499</tnsa:campaignId>
    </tnsa:scrubCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response

Sample PHP Code
	public function scrubCampaign($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$scrubCampaignArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);
		try
		{
			$scrubCampaignResponse = $campaignOutboundClient->scrubCampaign($scrubCampaignArray);
			$scrub = $scrubCampaignResponse->out;
			if($debug)
			{
				echo "Scrub Campaign Success";
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
   public void scrubCampaign(string key, long campaignId)
        {
            //LOG.Info("Entered scrubCampaign(string key, long campaignId)");

            try
            {
                this.campaignService.scrubCampaign(key, campaignId);
            }
            finally
            {
                //LOG.Info("Exited scrubCampaign(string key, long campaignId)");
            }
        }

startCampaign

Use this function to start a campaign that you created or stopped in the past.

Parameters

  • key - (String) your api key from the account page
  • campaignId - (long) the campaign id to start
Output
  • String "success"

Input: startCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long the campaign id to start

Output: startCampaign

Name maxOccurs minOccurs nillable type description
out 1 1 xsd:string
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:startCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>6070</tnsa:campaignId>
    </tnsa:startCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response

Sample PHP Code
	public function startCampaign($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$startCampaignArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);
		try
		{
			$startCampaignResponse = $campaignOutboundClient->startCampaign($startCampaignArray);
			$startCampaignId = $startCampaignResponse->out;
			if($debug)
			{
				echo "Campaign start status : ".$startCampaignId;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
       public string startCampaign(string key, long campaignId)
        {
            //LOG.info("Entered startCampaign(string key, long campaignId)");

            try
            {
                string status = this.campaignService.startCampaign(key, campaignId);
                return status;
            }
            finally
            {
                //LOG.info("Exited startCampaign(string key, long campaignId)");
            }
        }

stopCampaign

Use this function to stop a running campaign.

Parameters

  • key - (String) your api key from the account page
  • campaignId - (long) the campaign id to start
Response
  • Returns "success" upon successfully stopping the campaign.

Input: stopCampaign

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campID 1 1 xsd:long the campaign id to stop

Output: stopCampaignResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:string
Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:stopCampaign xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>-3409</tnsa:campaignId>
    </tnsa:stopCampaign>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response

Sample PHP Code
	public function stopCampaign($api_key,$campaign_id,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$stopCampaignArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id
		);
		try
		{
			$stopCampaignResponse = $campaignOutboundClient->stopCampaign($stopCampaignArray);
			$stopCampaignId = $stopCampaignResponse->out;
			if($debug)
			{
				echo "Campaign Stopped Result : ".$stopCampaignId;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public string stopCampaign(string key, long campaignId)
        {
            //LOG.info("Entered stopCampaign(string key, long campaignId)");

            try
            {
                string status = this.campaignService.stopCampaign(key, campaignId);
                return status;
            }
            finally
            {
                //LOG.info("Exited stopCampaign(string key, long campaignId)");
            }
        }

getRecording

Gets a recording for a call.

Parameters

  • key - (String) your api key from the account page
  • callId - (long) the id of the call you need a recording for
Output
  • byte [] - Byte array. Base64 encoded.
Example Response

Sample PHP Code
	public function getRecording($api_key,$callid,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$getRecordingArray = array (
		'key' => $api_key,
		'callId' => $callid
		);
		try
		{
			$getrecordingResponse = $campaignOutboundClient->getRecording($getRecordingArray);
			$getRecordingDetail = $getrecordingResponse->out;
			if($debug)
			{
				echo "Recording [returned value in bytes]";
				echo $getRecordingDetail;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
       public byte[] getRecording(string key, long callid)
        {
            try
            {
                byte[] RecordingResponse = this.campaignService.getRecording(key, callid);
                return RecordingResponse;
            }
            catch (Exception e)
            {
                string msg = "Unable to get the recording";
                throw new CampaignException(msg, e);
            }
        }

updateSpeed

Use this function to change the speed of your campaign. You can specify the calls per minute. Parameters

  • key - (String) your api key from the account page
  • campaignId - (long) the campaign id to start
  • speed - (int) the new speed in calls per minute for the campaign
Output
  • Return "success" upon successfully updating the speed of the campaign.

Input: updateSpeed

Name maxOccurs minOccurs nillable type description
key 1 1 TRUE xsd:string your api key from the account page
campaignId 1 1 xsd:long the campaign id to start
speed 1 1 xsd:int the new speed in calls per minute for the campaign


Output: updateSpeedResponse

Name maxOccurs minOccurs nillable type description
out 1 1 TRUE xsd:long


Example Request
<?xml version="1.0" encoding="utf-8"?>
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  <SOAP-ENV:Body>
<tnsa:updateSpeed xmlns:tns="http://schemas.xmlsoap.org/soap/encoding/" 
xmlns:tnsa="http://api.campaign.dialer.skyyconsulting.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <tnsa:key>string</tnsa:key>
      <tnsa:campaignId>-8599</tnsa:campaignId>
      <tnsa:speed>-4304</tnsa:speed>
    </tnsa:updateSpeed>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>
Example Response

Sample PHP Code
	public function updateSpeed($api_key,$campaign_id,$speed,$debug)
	{
		$createOtboundcampaignWsdl = 'https://www.callfire.com/service/CampaignService?wsdl';
		$campaignOutboundClient = new SoapClient($createOtboundcampaignWsdl,array('trace' => true));
		$updateSpeedArray = array (
		'key' => $api_key,
		'campaignId' => $campaign_id,
		'speed' => $speed
		);
		try
		{
			$updateSpeedResponse = $campaignOutboundClient->updateSpeed($updateSpeedArray);
			$update_speed = $updateSpeedResponse->out;
			if($debug)
			{
				echo "Campaign's speed update : ".$update_speed;
			}
		}
		catch(SoapFault $error)
		{
			if($debug)
			{
				echo $error."<br/>";
			}
		}
	}
Sample C# Code
        public string updateSpeed(string key, long campaignId, int speed)
        {
            //LOG.Info("Entered updateSpeed(string key, long campaignId, int speed)");

            try
            {
                string status = this.campaignService.updateSpeed(key, campaignId, speed);
                return status;
            }
            finally
            {
                //LOG.Info("Exited updateSpeed(string key, long campaignId, int speed)");
            }
        }

Other Services

CallType

This object contains all the information available for a call.

Variables

   String phonenumber : Phone number dialed
   long callid : A Callfire Unique ID
   Date timestarted : When the call was started
   int duration : duration in seconds
   String status : The status of the call
   String notes : Any notes if available (used for Call Center Only)
   String extra : Additional information if present for the call
   String agentId : Which Agent took the call (used for Call Center Only)
   String agentUserId : The userid that the agent used (used for Call Center Only)
   String agentPhoneNumber : The phone number of the Agent (used for Call Center Only)
   String agentResponse : Response an agent typed in (used for Call Center Only)
   Date responseTime : The time when Agent responded to the call (used for Call Center Only)

CampaignType

This object contains all the information available for a campaign.

Variables

    long campaignId : The callfire unique id for the campaign
    String name : The name of the campaign 
    String type : The type of campaign
    String status : The current state of the campaign (Running, Stopped, Finished, Cancelled)
    int total : The total calls in the campaign
    int dialed : The total dialed in the campaign
    int live : The total live answer in the campaign
    int answeringMachine : The total Answering Machine in the campaign
    int noAnswer : The total No Answers in teh campaign
    int doNotCall : The total DNC marked in the campaign
    int busy : The total Busy in the campaign
    int transfer : The total transfers in the campaign
    int error : The total calls that were Error's
    int misc : The total calls that faced a CallFire system error. 

If you want to record sounds to use in voice broadcasts, you should use the Sound File Service.

Examples

.Net Examples

C# (.Net) Campaign Examples

Sample Code

PHP

VB FAQ

Single Bridge Call

Additional Information

Different Call Status Types

Tools

Need help converting your file to a byte array?

ASP.NETFiletobyteArray

PHP - file to byte array

Java - file to byte array