By using the Aculab site, you agree with our use of cookies.

Cloud Guides Calls Per Second

Calls Per Second

Calls Per Second (CPS) is a common industry term which we use to refer to the number of outbound services which Aculab Cloud will start in every second.

For new accounts, Aculab Cloud will start a maximum of one outbound service every second. We impose this limit to play our part in the fight against call spam. We’re happy to increase it, but first we need to know what you’ll be using Aculab Cloud for. So, if you’d like to request an increase, please contact support and we’ll arrange a call to discuss it.

Values to control CPS

When you issue service_start requests, they are queued up and started at a rate consistent with the CPS values you set.

We have two values you can use to control CPS:

Minimum guaranteed CPS

We guarantee to start at least this many of your outbound services every second, measured over a two minute running average. We can only meet this guarantee while you’ve queued up sufficient service_start requests for us to start.

Maximum allowed CPS

We will start at most this many of your outbound services every second.

Where to set the CPS values

Each of those CPS values may be set on your account and, optionally, on your outbound services.

Account CPS

The minimum guaranteed and maximum allowed CPS values for your account are set by Aculab. If you’d like us to change them, please contact support. You can view them on your account’s Settings page.

We charge a monthly fee for minimum guaranteed CPS, because we need to reserve appropriate cloud and carrier capacity for you to use on demand whenever you need it. We do not charge for maximum allowed CPS, because we do not need to reserve capacity. Instead, we rely on the excess capacity we maintain in order to be able to start outbound services quickly enough for less time critical use cases.

Outbound service CPS

The minimum guaranteed and maximum allowed CPS values for each of your outbound services are set by you. You can set and view them on your outbound services page, and also on the General tab when editing an outbound service.

How can I use them?

Let’s take the example of a system which calls patients to remind them of medical appointments. It will call each patient a week, a few days before, and then on the day a few hours before their appointment. The calls are all placed from outbound services, and each type of call has different time constraints.

The timing of the calls placed in the days before the appointment is not that critical – any time between 9am and 5pm will do. So, they may be placed by an outbound service with high maximum allowed CPS and zero minimum guaranteed CPS. These services run within our excess capacity, generally achieving rates well in excess of the industry norm default 1 CPS. No capacity needs to be reserved so we do not charge a monthly fee.

However, the timing of the on-the-day calls is more critical – each must be placed around three hours before the appointment. To guarantee that the calls keep up with the appointments and to allow them to be placed at the right time, they must be placed by an outbound service with minimum guaranteed CPS set to the appointment rate (per second), summed across all the practices the user is serving. These services run within reserved capacity, for which we charge a monthly fee.

Why is this useful? The minimum guaranteed CPS, which attracts a monthly fee, is required only for the on-the-day calls – only one third of the total. You don’t need to pay a monthly fee for the earlier calls, because their more relaxed timing allows us to place them within our excess capacity. By keeping in contact with our customers to understand their usage patterns, we ensure we keep sufficient excess capacity available to place calls within these long time windows.

Cloud WebRTC Version 2 Application Developer Guide

WebRTC Interface Version 2 Application Developer Guide

How to Write WebRTC Apps

This guide shows the basic steps how to write WebRTC applications for Aculab Cloud. Refer to the API guide for detailed documentation on the APIs used.

WebRTC Client instances can call, and be called from, Aculab Cloud services only. They cannot call PSTN or SIP phones directly, although of course Aculab Cloud services can call those devices.

A web page can handle a number of concurrent WebRTC Client instances. The maximum number of concurrent instances is browser dependent. The code shown in the Integrating WebRTC section handles only one concurrent WebRTC Client instance.

Integrating WebRTC

The WebRTC specification is currently a moving target and, along with the rest of the industry, we do our best to keep in step with it. Before deployment, please be sure to try out our WebRTC interface in the environment where you expect to use it.

  • Include the JavaScript library by adding the following line to your HTML header:
    <script src="https://webrtc.aculabcloud.net/js/2/AculabCloudCaller.js" type="text/javascript"></script>
  • In your HTML page, create a WebRTC element by adding the following:
    <audio id="player"></audio>

Registering a WebRTC Client Instance with Aculab Cloud

To register a WebRTC Client instance for use with Aculab Cloud, you will need the following information:

InformationDescription
Cloud ID The Cloud ID for your Aculab Cloud account, for example 1-2-0.
WebRTC Access Key Your WebRTC Access Key which can be found in the Aculab Cloud portal.
Client Id A text identifier which Aculab Cloud uses to identify a specific WebRTC Client instance.
WebRTC Token For incoming WebRTC calls only, a WebRTC token is needed to enable incoming calls. Instructions for generating a token are shown in Enabling Incoming Calls on a WebRTC Instance.

Basics of Registering an Instance

All WebRTC calls are controlled through the AculabCloudClient class. Create a new instance of the class with:

    acc = new AculabCloudClient(cloudId, webRtcAccessKey, clientId, logLevel);

where logLevel is between 0 and 6 inclusive. 0 disables logging.

If you will be accepting incoming WebRTC calls, then set up maxConcurrent, onIncoming and onIncomingState properties. The example code in this guide assumes only 1 call at a time.

    acc.maxConcurrent = <number of concurrent WebRTC calls to handle>;
    acc.onIncoming = newCall;
    acc.onIncomingState = incomingState;

See Accepting an Incoming WebRTC Call for information on the newCall and incomingState functions.

Enabling Incoming Calls on a WebRTC Client Instance

A WebRTC Client instance needs a token to be able to receive incoming WebRTC calls. This token is retrieved from the webrtc_generate_token Web Services API, it should be generated by server side code. An example as follows:

    // Use the token to enable incoming WebRTC calls
    acc.enableIncoming(<webrtc_token>);

The onIncomingState callback is used to notify you if incoming WebRTC calls are enabled or disabled.

Calling an Aculab Cloud Service from WebRTC

WebRTC Client instances can only call Aculab Cloud inbound services. This is achieved by calling AculabCloudClient.makeOutgoing() then setting up the AculabCloudOutgoingCall callbacks to handle the call control events.

    call = acc.makeOutgoing(encodeURIComponent("incoming_service_name"));
    call.onDisconnect = callDisconnected;
    call.onRinging = ringing;
    call.onMedia = gotMedia;
    call.onConnecting = connecting;
    call.onConnected = connected;
    call.onError = handleError;

See Call Control Callbacks for information on these callbacks.

Calling a WebRTC Client Instance from Aculab Cloud

UAS and REST applications can call a WebRTC Client instance by setting the call destination to webrtc:<username>.

Calling a WebRTC Client Instance from the REST API

An example of using the Connect action to call a WebRTC Client instance, written in Python.

    my_connect = Connect()
    my_connect.set_next_page("/call_finished")
    my_connect.append_destination("webrtc:{0}".format(username))
    my_connect.set_call_origin('441234567890')
    my_connect.set_hold_media(Play(file_to_play='holdmusic.wav'))
    my_connect.set_secondary_call(SecondaryCall(first_page=WebPage(url='secondary_first'),
                                                final_page=WebPage(url='secondary_final'),
                                                error_page=WebPage(url='error_page')))

Calling a WebRTC Client Instance from the UAS API

A Python example of using the UASCallChannel object to call a WebRTC Client instance.

    if channel.start_call('webrtc:{0}'.format(username), call_from='441234567890') is True:
        # we have started an outbound call
        pass

Accepting an Incoming WebRTC Call

onIncomingState

onIncomingState is used to inform you whether incoming WebRTC calls are enabled or disabled.

    function incomingState(state) {
        if (state.ready) {
            // We can receive incoming calls
        } else {
            // We cannot receive incoming calls
            // Report state.cause to the user
        }
    }

onIncoming

If WebRTC Client has been configured to accept incoming calls, then the onIncoming callback is used to accept any incoming call.

The onIncoming callback should set up the AculabCloudIncomingCall callbacks, connect audio to the player, and send the ringing notification to the remote end.

    // newCall has been assigned to the onIncoming callback above
    function newCall(obj) {
        call = obj.call;
        inbound = true;

        // Set up callbacks
        call.onDisconnect = callDisconnected;
        call.onRinging = ringing;
        call.onMedia = gotMedia;
        call.onConnecting = connecting;
        call.onConnected = connected;
        call.onError = handleError;

        // Send ringing notification
        call.ringing();
    }

See Call Control Callbacks for information on these callbacks.

Call Control Callbacks

The various call control callbacks have been set up in the code snippets above. Example code showing how these callbacks are implemented is shown in this section.

onDisconnect

This callback is called when the call has been disconnected. The player element should be reset, and any resources cleaned up.

    function callDisconnected(obj) {
        if (obj.call != null) {
            obj.call.disconnect();
        }
        
        // Call the gotMedia callback to disable the player element
        gotMedia(obj.call, null);
    }

onRinging

If you have not got an audio stream from the remote end, then you can generate a ringtone locally.

    function onRinging(obj) {
        // get the <audio> element
        var player = document.getElementById('player');
        if (!playing_ringing) {
            if (player.canPlayType('audio/wav')) {
                // Play a ring tone if we have not got an audio stream
                // from the remote end
                // gotremotestream is initialised in gotMedia()
                if (!gotremotestream) {
                    player.loop = 'loop';
                    player.src = 'audio/ringback.wav';
                    player.type = 'audio/wav';
                    player.load();
                    var p = player.play();
                    if (p !== undefined) {
                        // handle error
                    }
                }
            } else {
                // Browser can't play audio/wav
            }
            playing_ringing = true;
        }
    }

onMedia

The onMedia callback is used to give you the remote audio stream which you can connect to your <audio> element.

    function gotMedia(call, stream) {
        // Get the <audio> element
        var player = document.getElementById('player');
 
        // Reset the player state
        player.pause();
        player.loop = '';
        player.src = '';
        player.srcObject = '';
        player.type = '';
        player.load();
        playing_ringing = false;
        gotremotestream = false;

        // If there is a stream then connect it to the <audio> element
        if (stream !== null) {
            gotremotestream = true;
            player.srcObject = stream;
            player.load();
            var p = player.play();
            if (p !== undefined) {
                // Handle error
            }
        }
    }

onConnecting

onConnecting is called when the browser is preparing the sockets needed to transport the call media. There is nothing that specifically needs doing in this callback, but it can be used to notify the user about call progress.

    function connecting(obj) {
        // Update a web page element to notify the user that the
        // call is connecting
    }

onConnected

When the call has been answered the onConnected callback will be called. You can use this callback to notify the user about call progress.

    function connected(obj) {
        // Update a web page element to notify the user that the
        // call is connected
        connected = true;
    }

onError

The onError callback can be used to clean up connected calls, and report issues to the user.

    function handleError(obj) {
        // Report the error to the user

        // Call the callDisconnected callback to clean up the call
        // and reset the audio player
        callDisconnected(obj.call)
    }

Disconnecting a Call

Disconnecting a connected call is as simple as calling disconnect() on the call object. Inbound calls that have not connected should be rejected with a valid SIP cause, for example 486 busy here, instead.

    function stopCall() {
        if (call) {
            // If inbound call has not been accepted, then reject the call
            if (inbound && !connected) {
                call.reject(486);
            } else {
                call.disconnect();
            }
        }
    }

Troubleshooting

A number of common issues can cause problems with audio in a WebRTC call.

HTML5 autoplay blockers will prevent the <audio> element from automatically playing the audio from the remote end. Ensure that any blockers are disabled for your WebRTC page.

If the same username is registered from more than one browser instance then the most recently registered instance will receive incoming WebRTC calls. As WebRTC Client instances are automatically re-registered at various intervals, the most recently registered instance may change without warning. Therefore, in general it's best to register a given username with only one browser instance at a time.

 

 

Cloud WebRTC Interface Version 2

WebRTC Interface Version 2

The interface consists of several JavaScript classes. These classes hide the complexity of the browser's WebRTC APIs and the differences in implementation between the supported browsers. The classes also handle the call set-up and tear-down, with the host page being informed of the call progress by means of callbacks.

Integrating WebRTC

The WebRTC specification is currently a moving target and, along with the rest of the industry, we do our best to keep in step with it. Before deployment, please be sure to try out our WebRTC interface in the environment where you expect to use it.

You can include the JavaScript library by adding the following line to your HTML header:

<script src="https://webrtc.aculabcloud.net/js/2/AculabCloudCaller.js" type="text/javascript"></script>

The version 2 library also includes an implementation of the version 1 interface.

The Application Developer Guide describes how to write applications that use the WebRTC Interface.

API Classes

AculabCloudClient

AculabCloudClient Constructor:

AculabCloudClient.constructor(cloudId, webRtcAccessKey, clientId, logLevel)

Creates an AculabCloudClient object

Parameter Description
cloudId The identifier of the Aculab Cloud where services that interact with the user are located (e.g. 1-2-0).
webRtcAccessKey The WebRTC access key of your Aculab Cloud account.
clientId identifies this client object. It is the value that will be placed in the call_from field in the call details of the application's main channel when making calls to inbound services. It is also the value used when services make outbound calls to WebRTC clients. Must be a valid SIP URI 'user' element, see RFC 3261 - Section 25 for details.
logLevel A numeric value between 0 and 6 inclusive. 0 disables logging and 6 is the most detailed logging.

This throws a string exception if any parameter is invalid.

AculabCloudClient Functions:

static boolean AculabCloudClient.isSupported()

Returns true if the browser supports the necessary functionality and false if not.

AculabCloudOutgoingCall AculabCloudClient.makeOutgoing(serviceName)

This initiates a call to the specified Aculab Cloud incoming service. Call progress is reported by callbacks, these should be set on the object returned by this function.

Parameter Description
serviceName The name of the Aculab Cloud incoming service that the call will be connected to.

This throws a string exception if:

  • the browser doesn't support calling the cloud
  • there are too many calls already in progress
  • serviceName contains disallowed characters

void AculabCloudClient.enableIncoming(token)

This function initiates registration of this client object as the destination for calls to the specified user. The status of the registration is reported by the onIncomingState callback.

Parameter Description
token The token is an authenication token. These are generated using an Aculab Cloud web service. The token can be updated by calling this function with the new token.

This throws a string exception if the token format is invalid.

void AculabCloudClient.disableIncoming()

This function initiates the removal of this client as the destination for call to the specified user. The status of the registration is reported by the onIncomingState callback.

AculabCloudClient Properties:

AculabCloudClient.iceServers

Must be null or an array of RTCIceServer objects. This value can be changed at any time. Outgoing calls will use the value set when the call is made. Incoming calls will use the value set when the call is answered. If the value is null, an Aculab provided set of iceServers is used. Using an empty array will disable the Aculab provided iceServers.

AculabCloudClient.maxConcurrent

This is the number of concurrent calls this client is allowed to handle. The default is 1. This value must be 1 or greater. The upper limit is browser dependent.

AculabCloudClient Callback Properties:

It is possible to set callback functions that trigger on WebRTC events, for example, when the call has disconnected, or ringing. Each of these callback properties must be either null or a function. The function will be passed a single object parameter. Additional information may be included as properties of that object. All such properties are detailed below.

AculabCloudClient.onIncomingState

Called when user registration state changes.

Parameter Description
ready A boolean indicating whether this client is waiting for incoming calls.
cause The reason for the registration state change.
retry A boolean indicating whether the client will automatically retry the registration.

The parameter cause will be one of the following strings:

Cause Description
'DISCONNECTED' The connection to the cloud has been lost.
'INVALIDTOKEN' The token specified is not valid (for example, it has expired).
'FAILED' The registration was unsuccessful for some other reason.
'NORMAL' The state change was in response to API calls.

AculabCloudClient.onIncoming

Called when an incoming call occurs. If this is null or throws an exception, the incoming call is rejected.

Parameter Description
call An AculabCloudIncomingCall object.
from The CallerID passed by the calling service.

Call progress is reported by callbacks, these should be set on the passed call object before returning from the callback function.

AculabCloudCall

The base class for call objects. Instances derived from this object are returned by makeOutgoing() or passed in calls to the onIncoming callback.

AculabCloudCall Functions:

void AculabCloudCall.mute(mic, output)

Mutes audio for the call.

Parameter Description
mic A boolean. If true, then the microphone (sent audio) is muted. If false, then the microphone is unmuted.
output A boolean. If true, then the received audio is muted. If false, then the received audio is unmuted.

void AculabCloudCall.sendDtmf(dtmfStr)

Sends DTMF characters.

Parameter Description
dtmfStr A string containing the DTMF digits to be sent. Valid characters are 0,1,2,3,4,5,6,7,8,9,*,#,A,B,C and D.

This throws a string exception if there is an invalid digit in the string.

void AculabCloudCall.disconnect()

Disconnects the call. This can be called at any time.

AculabCloudCall Callback Properties:

AculabCloudCall.onDisconnect

The call has disconnected.

Parameter Description
call The call object that is reporting the event.
cause The reason the call disconnected.

The parameter cause will be one of the following strings:

Cause Description
'MIC_ERROR' No microphone is available, usually because the user refused access or there is no microphone.
'BUSY' The service called hangup() with the busy cause or the service could not be started (due to limited UAS capacity, for example).
'UNOBTAINABLE' The specified incoming service name does not exist.
'MOVED' The service attempted to redirect the call.
'REJECTED' The call was rejected either by the incoming service or an intermediary.
'NOANSWER' The call did not connect.
'FAILED' The call was unsuccessful for some other reason.
'ERROR' An internal error occurred.
'NORMAL' The call has disconnected in the normal way after having connected.

AculabCloudCall.onMedia

Called when remote media is available to be played to the user.

Parameter Description
call The call object that is reporting the event.
stream A MediaStream object suitable connecting to an <audio> HTMLMediaElement as the srcObject.

AculabCloudCall.onConnecting

Called once the local microphone input has been obtained and the connection to the Aculab Cloud has been established. The browser will now start to prepare the sockets needed to transport the call media.

Parameter Description
call The call object that is reporting the event.

AculabCloudCall.onConnected

Called when the call has been answered.

Parameter Description
call The call object that is reporting the event.

AculabCloudOutgoingCall

The class extends AculabCloudCall. This class represents outgoing calls and is returned by AculabCloudClient.makeOutgoing().

AculabCloudOutgoingCall Callback Properties:

AculabCloudOutgoingCall.onRinging

Called when incoming service has signalled that the call is ringing.

Parameter Description
call The call object that is reporting the event.

AculabCloudIncomingCall

The class extends AculabCloudCall. This class represents incoming calls and is passed in calls to the AculabCloudClient.onIncoming() callback.

AculabCloudIncomingCall Functions:

void AculabCloudIncomingCall.ringing()

Notify the calling service that the user is being alerted to the incoming call.

void AculabCloudIncomingCall.answer()

Answer the incoming call.

void AculabCloudIncomingCall.reject(cause)

Reject the incoming call.

Parameter Description
cause The cause to give for rejecting the call. The value should be a SIP response code between 400 and 699 inclusive. If no cause is given or the specified cause is not a number, the cause 486 (Busy Here) will be used.

This throws a string exception if the cause is not in the valid range.

Cloud WebRTC Interface Version 1

WebRTC Interface Version 1

WebRTC allows you to embed a phone into any web page. A WebRTC capable browser can send audio from a microphone over the internet and play audio it receives in real-time. The Aculab Cloud WebRTC interface provides a way to use this functionality to connect users to an Inbound Service.

The interface consists of a single JavaScript class, AculabCloudCaller. This class hides the complexity of the browser's WebRTC APIs and the differences in implementation between the supported browsers. The class also handles the call set-up and tear-down, with the host page being informed of the call progress by means of callbacks.

Integrating WebRTC

The WebRTC specification is currently a moving target and, along with the rest of the industry, we do our best to keep in step with it. Before deployment, please be sure to try out our WebRTC interface in the environment where you expect to use it.

  • Include the JavaScript library by adding the following line to your HTML header:
    <script src="https://webrtc.aculabcloud.net/js/1/AculabCloudCaller.js" type="text/javascript"></script>
  • In your HTML page, create a WebRTC element by adding the following:
    <audio id="player"></audio>
  • Use our cut down template as a base for your JavaScript code.

API - AculabCloudCaller

Object that provides access to the WebRTC interface on Aculab Cloud. A page can have more than one AculabCloudCaller at a time.

AculabCloudCaller Constructors

AculabCloudCaller.AculabCloudCaller()

Creates an AculabCloudCaller object

AculabCloudCaller Functions:

boolean AculabCloudCaller.isSupported()

Returns true if the browser supports the necessary functionality and false if not.

void AculabCloudCaller. makeCall(cloudid, servicename, callerid)

Initiates the call to the specified Aculab Cloud incoming service. Call progress is reported by the callbacks, so these should be set before calling this function.

Parameter Description
cloudid The identifier of the Aculab Cloud that is hosting the incoming service (e.g. 1-2-0).
servicename The name of the Aculab Cloud incoming service that the call will be connected to. Must be a valid SIP URI 'user' element, see RFC 3261 - Section 25 for details.
callerid The value that will be placed in the call_from field in the call details of the application's main channel. Must be a valid SIP URI 'user' element, see RFC 3261 - Section 25 for details.

This throws a string exception if:
  • the browser doesn't support calling the cloud
  • there is another call already in progress
  • the cloudid is not of the correct format (i.e. X-Y-Z)
  • either servicename or callerid contain disallowed characters

void AculabCloudCaller.sendDtmf(dtmf_str)

Sends a DTMF character.

Parameter Description
dtmf_str A string containing the DTMF digits to be sent. Valid characters are 0,1,2,3,4,5,6,7,8,9,*,#,A,B,C and D.

This throws a string exception if there is an invalid digit in the string. There is no return value.

void AculabCloudCaller.disconnect()

Disconnects any existing call. This can be called at any time.

void AculabCloudCaller. attachMediaStreamToElement(element, stream)

Attaches the media stream stream to the <audio> element. It does not force the element into the playing state.

Parameter Description
element The <audio> element
steam The media stream at attach

This is a helper function to deal with the different ways browsers currently handle attaching media streams to <audio> elements. You may use your own code to perform this action. However, if you have used this function then detachMediaStreamFromElement() must be called when the call disconnects to ensure all resources can be released.

void AculabCloudCaller. detachMediaStreamFromElement(element)

Detaches any current media stream from the <audio> element. This should be called when the call disconnects to ensure the resources are released.

AculabCloudCaller Properties

AculabCloudCaller.iceServers

Must be null or an array of RTCIceServer objects. If used, this must be set before calling makeCall().

AculabCloudCaller.logLevel

Must be a numeric value between 0 and 3 inclusive. 0 disables logging.

AculabCloudCaller Callback Properties

It is possible to set callback functions that trigger on WebRTC events, for example, when the call has disconnected, or ringing. Each of these callback properties must be either null or a function. The function will be passed a single object parameter. Additional information may be included as properties of that object. All such properties are detailed below.

AculabCloudCaller.onDisconnect

The call has disconnected. The parameter 'cause' will be one of the following strings:

Cause Description
'MIC_ERROR' No microphone is available to the AculabCloudCaller, usually because the user refused access or there is no microphone.
'BUSY' The incoming service called hangup() with the busy cause or the service could not be started (due to limited UAS capacity, for example).
'UNOBTAINABLE' The specified incoming service name does not exist.
'MOVED' The incoming service attempted to redirect the call.
'REJECTED' The call was rejected either by the incoming service or an intermediary.
'NOANSWER' The call did not connect.
'FAILED' The call was unsuccessful for some other reason.
'ERROR' An internal error occurred.
'NORMAL' The call has disconnected in the normal way after having connected.

AculabCloudCaller.onRinging

The incoming service has signalled that the call is ringing.

AculabCloudCaller.onMedia

Called when remote media is available to be rendered to the user. The parameter object will have a 'stream' property:

Parameter Description
stream A MediaStream object suitable for passing to the attachMediaStreamToElement() function above.

AculabCloudCaller.onConnecting

Called once the local microphone input has been obtained and the connection to the Aculab Cloud has been established. The browser will now start to prepare the sockets needed to transport the call media. Once this has been done, the request to start the incoming service will be sent.

AculabCloudCaller.onConnected

Called when the incoming service has answered the call.

AculabCloudCaller.onError

Called when an internal error has occurred. The parameter object will have the following properties:

Parameter Description
error A string describing the error that has occurred.

Archive

The Aculab blog

News, views and industry insights from Aculab

  • Are facemasks a problem for Voice Biometrics?

    Wearing a mask is now the primary way to limit the spread of coronavirus, and has been found to reduce the daily growth rate of reported infections in large scale populations by around 45%- but this raises a potential problem for voice biometric security.

    Read more

  • Voice Biometrics: Why Businesses and Users are driving its adoption

    In this blog post, we’ll look at the rapidly growing market of Voice Biometrics, and what drives its increasing rate of adoption, as more businesses and services are made aware of the need for multi-factor authentication.

    Read more

  • An underused tool in the fight against the second wave of Coronavirus

    In this article, we'll go into a bit more depth as to why exactly Broadcast Messaging is such a powerful tool. We have compiled a list of six unique characteristics to highlight exactly how it can be used productively, to shore up the lines of communication in the ongoing situation with Coronavirus.

    Read more

  • The seven realms of Broadcast Messaging

    Broadcast messaging that uses a cloud-based service is a natural choice. Using a cloud as-a-service approach gives a variety of message delivery options, and cuts down costs by automatically scaling to meet demand. Find out what makes Aculab Cloud such a natural choice for voice and SMS broadcast messaging, and how other customers are already reaping the benefits from using Aculab's CPaaS platform.

    Read more

  • The technology working behind the scenes to support emergency services networks

    Now more than ever, telecoms infrastructures play a vital role in supporting the health of our communities. Behind the scenes, networking technologies are working to keep the lines of communications open between emergency services and those in need.

    A recent example from the Lombardy region of Italy highlights a typical scenario:

    Read more