Voice360 API Documentation

class Voice360API {
  constructor(apiKey, accountId) {
    this.apiKey = apiKey;
    this.accountId = accountId;
    this.baseUrl = 'https://api.voice360.app/v3/voice';
  }

  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}/${this.accountId}${endpoint}`;
    const response = await fetch(url, {
      ...options,
      headers: {
        'X-API-Key': this.apiKey,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });

    if (!response.ok) {
      throw new Error(`API Error: ${response.status} ${response.statusText}`);
    }

    return response.json();
  }

  // User methods
  async getUserAvailability() {
    return this.request('/availability');
  }

  // Queue methods
  async getQueues() {
    return this.request('/queues');
  }

  async getQueueDetails(queueId) {
    return this.request(`/queues/${queueId}`);
  }

  async getQueueAvailability(queueId = null) {
    const endpoint = queueId
      ? `/availability/queues/${queueId}`
      : '/availability/queues';
    return this.request(endpoint);
  }

  // Call methods
  async initiateCall(from, to, options = {}) {
    return this.request('/call/outbound', {
      method: 'POST',
      body: JSON.stringify({ from, to, ...options })
    });
  }

  // SMS methods
  async sendSMS(from, to, message) {
    return this.request('/sms/send', {
      method: 'POST',
      body: JSON.stringify({ from, to, message })
    });
  }
}

// Usage example
async function main() {
  const api = new Voice360API('your_api_key', 61);

  try {
    // Get all online users
    const availability = await api.getUserAvailability();
    const onlineUsers = availability.result.filter(u => u.devices_registered);
    console.log(`${onlineUsers.length} users online`);

    // Check queue status
    const queues = await api.getQueueAvailability();
    const readyQueues = queues.result.filter(q => q.is_ready);
    console.log(`${readyQueues.length} queues have agents available`);

    // Make an outbound call
    const call = await api.initiateCall('1001', '+15551234567', {
      caller_id: '+15559876543',
      recording: true
    });
    console.log(`Call initiated: ${call.result.call_id}`);

  } catch (error) {
    console.error('API Error:', error);
  }
}

main();

import requests
import json
from typing import Optional, Dict, Any

class Voice360API:
    """Voice360 API Client for Python"""

    def __init__(self, api_key: str, account_id: int):
        self.api_key = api_key
        self.account_id = account_id
        self.base_url = 'https://api.voice360.app/v3/voice'
        self.session = requests.Session()
        self.session.headers.update({
            'X-API-Key': api_key,
            'Content-Type': 'application/json'
        })

    def _request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
        """Make an API request"""
        url = f'{self.base_url}/{self.account_id}{endpoint}'
        response = self.session.request(method, url, **kwargs)
        response.raise_for_status()
        return response.json()

    def get_user_availability(self) -> Dict[str, Any]:
        """Get user availability status"""
        return self._request('GET', '/availability')

    def get_queues(self) -> Dict[str, Any]:
        """List all queues"""
        return self._request('GET', '/queues')

    def get_queue_details(self, queue_id: int) -> Dict[str, Any]:
        """Get details for a specific queue"""
        return self._request('GET', f'/queues/{queue_id}')

    def get_queue_availability(self, queue_id: Optional[int] = None) -> Dict[str, Any]:
        """Get queue availability metrics"""
        endpoint = f'/availability/queues/{queue_id}' if queue_id else '/availability/queues'
        return self._request('GET', endpoint)

    def initiate_call(self, from_ext: str, to_number: str, **options) -> Dict[str, Any]:
        """Initiate an outbound call"""
        data = {'from': from_ext, 'to': to_number, **options}
        return self._request('POST', '/call/outbound', json=data)

    def send_sms(self, from_number: str, to_number: str, message: str) -> Dict[str, Any]:
        """Send an SMS message"""
        data = {'from': from_number, 'to': to_number, 'message': message}
        return self._request('POST', '/sms/send', json=data)


def main():
    # Initialize the API client
    api = Voice360API('your_api_key', 61)

    try:
        # Get user availability
        availability = api.get_user_availability()
        online_users = [u for u in availability['result'] if u['devices_registered']]
        print(f"Online users: {len(online_users)}")

        # Check queue status
        queues = api.get_queue_availability()
        ready_queues = [q for q in queues['result'] if q['is_ready']]
        print(f"Queues with agents: {len(ready_queues)}")

        # Display queue details
        for queue in ready_queues:
            print(f"  - {queue['queue_name']}: {queue['agents_online']} agents online")

        # Initiate a call
        call = api.initiate_call(
            from_ext='1001',
            to_number='+15551234567',
            caller_id='+15559876543',
            recording=True
        )
        print(f"Call initiated: {call['result']['call_id']}")

        # Send an SMS
        sms = api.send_sms(
            from_number='+15559876543',
            to_number='+15551234567',
            message='Hello from Voice360!'
        )
        print(f"SMS sent: {sms['message']}")

    except requests.exceptions.RequestException as e:
        print(f"API Error: {e}")
    except KeyError as e:
        print(f"Unexpected response format: {e}")


if __name__ == '__main__':
    main()

<?php

class Voice360API {
    private $apiKey;
    private $accountId;
    private $baseUrl = 'https://api.voice360.app/v3/voice';

    public function __construct($apiKey, $accountId) {
        $this->apiKey = $apiKey;
        $this->accountId = $accountId;
    }

    private function request($method, $endpoint, $data = null) {
        $url = "{$this->baseUrl}/{$this->accountId}{$endpoint}";

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'X-API-Key: ' . $this->apiKey,
            'Content-Type: application/json'
        ]);

        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            if ($data) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            }
        }

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode >= 400) {
            throw new Exception("API Error: HTTP {$httpCode}");
        }

        return json_decode($response, true);
    }

    public function getUserAvailability() {
        return $this->request('GET', '/availability');
    }

    public function getQueues() {
        return $this->request('GET', '/queues');
    }

    public function getQueueDetails($queueId) {
        return $this->request('GET', "/queues/{$queueId}");
    }

    public function getQueueAvailability($queueId = null) {
        $endpoint = $queueId
            ? "/availability/queues/{$queueId}"
            : '/availability/queues';
        return $this->request('GET', $endpoint);
    }

    public function initiateCall($from, $to, $options = []) {
        $data = array_merge(['from' => $from, 'to' => $to], $options);
        return $this->request('POST', '/call/outbound', $data);
    }

    public function sendSMS($from, $to, $message) {
        return $this->request('POST', '/sms/send', [
            'from' => $from,
            'to' => $to,
            'message' => $message
        ]);
    }
}

// Usage example
try {
    $api = new Voice360API('your_api_key', 61);

    // Get user availability
    $availability = $api->getUserAvailability();
    $onlineUsers = array_filter($availability['result'], function($u) {
        return $u['devices_registered'];
    });
    echo "Online users: " . count($onlineUsers) . "\n";

    // Check queue status
    $queues = $api->getQueueAvailability();
    foreach ($queues['result'] as $queue) {
        if ($queue['is_ready']) {
            echo "Queue {$queue['queue_name']}: {$queue['agents_online']} agents online\n";
        }
    }

    // Make a call
    $call = $api->initiateCall('1001', '+15551234567', [
        'caller_id' => '+15559876543',
        'recording' => true
    ]);
    echo "Call initiated: {$call['result']['call_id']}\n";

} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

?>

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Text;
using Newtonsoft.Json;

public class Voice360API
{
    private readonly HttpClient client;
    private readonly string accountId;
    private readonly string baseUrl = "https://api.voice360.app/v3/voice";

    public Voice360API(string apiKey, int accountId)
    {
        this.accountId = accountId.ToString();
        client = new HttpClient();
        client.DefaultRequestHeaders.Add("X-API-Key", apiKey);
    }

    private async Task<T> RequestAsync<T>(HttpMethod method, string endpoint, object data = null)
    {
        var url = $"{baseUrl}/{accountId}{endpoint}";
        var request = new HttpRequestMessage(method, url);

        if (data != null)
        {
            var json = JsonConvert.SerializeObject(data);
            request.Content = new StringContent(json, Encoding.UTF8, "application/json");
        }

        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();

        var responseJson = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<T>(responseJson);
    }

    public async Task<dynamic> GetUserAvailabilityAsync()
    {
        return await RequestAsync<dynamic>(HttpMethod.Get, "/availability");
    }

    public async Task<dynamic> GetQueuesAsync()
    {
        return await RequestAsync<dynamic>(HttpMethod.Get, "/queues");
    }

    public async Task<dynamic> InitiateCallAsync(string from, string to, object options = null)
    {
        var data = new { from, to };
        if (options != null)
        {
            // Merge options with data
            var json = JsonConvert.SerializeObject(data);
            var optionsJson = JsonConvert.SerializeObject(options);
            var merged = JsonConvert.DeserializeObject<dynamic>(json);
            var optionsObj = JsonConvert.DeserializeObject<dynamic>(optionsJson);
            foreach (var prop in optionsObj)
            {
                merged[prop.Name] = prop.Value;
            }
            data = merged;
        }

        return await RequestAsync<dynamic>(HttpMethod.Post, "/call/outbound", data);
    }
}

// Usage
class Program
{
    static async Task Main(string[] args)
    {
        var api = new Voice360API("your_api_key", 61);

        try
        {
            // Get user availability
            var availability = await api.GetUserAvailabilityAsync();
            Console.WriteLine($"Users fetched: {availability.result.Count}");

            // Get queues
            var queues = await api.GetQueuesAsync();
            Console.WriteLine($"Queues fetched: {queues.result.Count}");

            // Initiate a call
            var call = await api.InitiateCallAsync("1001", "+15551234567", new {
                caller_id = "+15559876543",
                recording = true
            });
            Console.WriteLine($"Call initiated: {call.result.call_id}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.HashMap;

public class Voice360API {
    private final HttpClient client;
    private final String apiKey;
    private final int accountId;
    private final String baseUrl = "https://api.voice360.app/v3/voice";
    private final ObjectMapper mapper;

    public Voice360API(String apiKey, int accountId) {
        this.apiKey = apiKey;
        this.accountId = accountId;
        this.client = HttpClient.newHttpClient();
        this.mapper = new ObjectMapper();
    }

    private Map<String, Object> request(String method, String endpoint, Map<String, Object> data) throws Exception {
        String url = baseUrl + "/" + accountId + endpoint;

        HttpRequest.Builder builder = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("X-API-Key", apiKey)
            .header("Content-Type", "application/json");

        if ("POST".equals(method) && data != null) {
            String json = mapper.writeValueAsString(data);
            builder.POST(HttpRequest.BodyPublishers.ofString(json));
        } else {
            builder.GET();
        }

        HttpRequest request = builder.build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() >= 400) {
            throw new RuntimeException("API Error: " + response.statusCode());
        }

        return mapper.readValue(response.body(), Map.class);
    }

    public Map<String, Object> getUserAvailability() throws Exception {
        return request("GET", "/availability", null);
    }

    public Map<String, Object> getQueues() throws Exception {
        return request("GET", "/queues", null);
    }

    public Map<String, Object> initiateCall(String from, String to, Map<String, Object> options) throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("from", from);
        data.put("to", to);
        if (options != null) {
            data.putAll(options);
        }
        return request("POST", "/call/outbound", data);
    }

    public static void main(String[] args) {
        Voice360API api = new Voice360API("your_api_key", 61);

        try {
            // Get user availability
            Map<String, Object> availability = api.getUserAvailability();
            System.out.println("Availability: " + availability);

            // Get queues
            Map<String, Object> queues = api.getQueues();
            System.out.println("Queues: " + queues);

            // Initiate call
            Map<String, Object> options = new HashMap<>();
            options.put("caller_id", "+15559876543");
            options.put("recording", true);

            Map<String, Object> call = api.initiateCall("1001", "+15551234567", options);
            System.out.println("Call initiated: " + call);

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}