Click-to-Call (Customer Initiated)

Customer-initiated click-to-call is a common call center software feature that allows customers to directly contact a company's call center by clicking a button, link, or specific number on a website or mobile application. This service instantly connects customers with a customer service representative, without the need for dialing a number manually. Customer initiated click to call generally triggers a call center to make an outbound call to a phone number provided by the customer (although some types of click-to-call use WebRTC to allow the customer to speak with a call center agent directly through the customer's web browser). Customers often are able to use click-to-call to schedule a time to receive a call back from the call center. Customer-initiated click-to-call is different than agent-initiated click to call.

How Customer-Initiated Click-to-Call Works

In many click-to-call approaches, when a customer clicks on the designated click-to-call button, the request is sent to a server, which then triggers a telephony system associated with the call center. This system initiates an outbound call to the customer's designated contact number and another to the call center. The call center ACD then searches for an available agent. When both calls are answered, they are bridged together, creating a connection between the customer and the call center representative. In some WebRTC based approaches, when the customer clicks on the click-to-call button or link, a telephony session is initiated between the customer's web browser and the call center server (which hunts for an available agent to handle the call).

Examples of How Customer-Initiated Click-to-Call Work

There are a number of different ways that call center software platforms handle click-to-call. We provide several examples here. Note that many click-to-call implementations use third party software (that must be managed separately from whatever call center platform you choose).

Example of a Twilio-implemented Click to Call

Many call centers implement click-to-call using Twilio. A typical Twilio implementation requires two bits of code — the client-side code that creates a click-to-call button that can be placed on a customer-facing website, and the server-side code that handles the call bridging.

Here's an example client-side code that may be used:

<form id="clickToCallForm">
  <input type="tel" id="phoneNumber" name="phoneNumber" required>
  <button type="submit">Call Me</button>
</form>

<script>
document.getElementById('clickToCallForm').addEventListener('submit', function(event) {
  event.preventDefault();

  var phoneNumber = document.getElementById('phoneNumber').value;

  fetch('/call', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ phoneNumber: phoneNumber })
  });
});
</script>

And here is an example of the server side code (this example uses node.js a common server-side language).

const express = require('express');
const twilio = require('twilio');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

const twilioClient = twilio('TWILIO_ACCOUNT_SID', 'TWILIO_AUTH_TOKEN');

app.post('/call', (req, res) => {
  twilioClient.calls.create({
    url: 'http://demo.twilio.com/docs/voice.xml', // TwiML Bin URL or a URL that returns TwiML instructions
    to: req.body.phoneNumber,
    from: 'YOUR_TWILIO_PHONE_NUMBER'
  })
  .then(call => console.log(call.sid))
  .catch(err => console.error(err));

  res.sendStatus(200);
});

app.listen(3000, () => console.log('Server listening on port 3000'));

In this example, the client sends the phone number to the server when the form is submitted. The server then uses the Twilio API to initiate a call to that phone number. The ‘url' parameter in the twilioClient.calls.create function is a URL that returns TwiML instructions for handling the call.

Please note that this is a simple example and doesn't include error handling and other considerations for a production environment, such as validating the phone number, securing the API endpoint, and managing API keys securely.

Example Click-to-Call Using WebRTC

Another common approach is to use a browser feature called “WebRTC” to implement click to call.

WebRTC (Web Real-Time Communication) provides the ability to have real-time communication, including audio and video, directly in the browser without the need for plugins or external applications. In the context of a customer-initiated click-to-call system, WebRTC can be used to create a direct communication channel between the customer's browser and the call center's system.

Here's a high-level overview of how this might work:

Client-side functionality: The client's browser has a button or link that, when clicked, triggers a JavaScript function to start a WebRTC call. The JavaScript uses the WebRTC API to access the user's microphone (with their permission) and to create an RTCPeerConnection, which will manage the call.
Signal exchange: In order to establish the RTCPeerConnection, the client's browser and the call center's system need to exchange certain information, including Session Description Protocol (SDP) and ICE candidates. SDP includes information like media formats the browsers can handle, and ICE candidates are potential network paths for the data to travel. This information is exchanged using a process called signaling, which isn't part of the WebRTC API and needs to be implemented separately, often using WebSockets or XHR along with a server-side language.
Server-side functionality: The server receives the call request and the signaling data, and uses this to establish its own RTCPeerConnection that can communicate with the client's RTCPeerConnection. It also connects this to the call center's phone system, likely using a gateway that can convert between WebRTC and traditional telephony protocols like SIP.

Here's a very basic example of the client-side JavaScript code to start a WebRTC call:

// Get the button that starts the call
var callButton = document.getElementById('callButton');

// When the button is clicked, start the call
callButton.addEventListener('click', startCall);

function startCall() {
  // Request access to the user's microphone
  navigator.mediaDevices.getUserMedia({ audio: true })
    .then(startStream)
    .catch(handleError);
}

function startStream(stream) {
  // Create a new RTCPeerConnection
  var pc = new RTCPeerConnection();

  // Add the audio stream to the RTCPeerConnection
  pc.addStream(stream);

  // Create an offer and set it as the local description
  pc.createOffer().then(offer => pc.setLocalDescription(offer));

  // Once the local description is set, send it to the server
  pc.onnegotiationneeded = () => {
    if (pc.signalingState != 'stable') return;
    sendToServer(pc.localDescription);
  };

  // When ICE candidates are generated, send them to the server
  pc.onicecandidate = event => {
    if (event.candidate) {
      sendToServer(event.candidate);
    }
  };
}

function sendToServer(data) {
  // This function would use WebSocket, XHR, or another method to send
  // the SDP or ICE candidates to the server
}

function handleError(error) {
  // Handle any errors that occur
  console.error('Error: ', error);
}

Again, this is a simplified example and doesn't include error handling and other considerations for a production environment. The exact details can vary depending on your specific requirements and the telephony system you are using. WebRTC can be complex to implement, especially when it comes to dealing with different network conditions, so you might want to consider using a library or a service that abstracts some of the complexity away.

Key Factors to Consider When Choosing Call Center Software with Customer-Initiated Click-to-Call

While choosing a call center software that supports customer-initiated click-to-call, you should consider the following:

Integration Capabilities: The right customer-initiated click-to-call software should easily integrate with your existing technology stack, including your CRM, helpdesk software, and other customer service tools. This ensures seamless data sharing and can improve agent efficiency and customer experiences.
Ease of Use: The interface should be intuitive for both your agents and customers. On the customer side, initiating a call should be as simple as clicking a button.
Scalability: As your business grows, your call center software should be able to grow with it. This includes being able to handle an increasing volume of calls and adding more agents or teams.
Reliability: The software should have a strong track record of uptime and provide good call quality. Any downtime or poor call quality can directly impact your customer service.
Customizability: You should be able to customize the software to meet your specific business needs, including setting up custom call flows, messages, and more.
Security and Compliance: The software should comply with industry regulations and have strong security measures in place to protect sensitive customer data.
Cost: Evaluate the pricing structure of the software. Some providers may charge based on the number of agents, while others may charge based on the volume of calls. Consider your call volume, number of agents, and budget when reviewing this aspect.
Customer Support: The provider should offer robust support to help you resolve any issues that arise with the software.

Benefits of Customer Initiated Click-to-Call

Implementing a customer initiated click-to-call feature in your call center software can have numerous benefits for both your organization and your customers:

Ease of Use for Customers: Click-to-call simplifies the process of reaching out to your company for customers. Instead of searching for a contact number and manually dialing it, customers can initiate a call with a single click, making the process more user-friendly.
Increased Customer Engagement: By making it easier for customers to contact you, click-to-call features can encourage customers to engage with your company more frequently. This can lead to increased sales, improved customer satisfaction, and stronger customer relationships.
Improved Customer Service: Click-to-call features can be integrated with your CRM or other customer service tools, providing your agents with relevant customer information the moment a call is initiated. This can lead to more personalized and effective customer service.
Efficient Use of Resources: With click-to-call, calls can be routed to the appropriate department or agent based on the context of the customer's inquiry. This reduces the need for transfers and can increase the efficiency of your call center operations.
Detailed Call Tracking: Click-to-call features often come with analytics and reporting capabilities. This allows you to track key call metrics, like call duration, time of call, and call outcomes, which can provide valuable insights into your customer service performance.
Increased Conversion Rates: Click-to-call features have been shown to increase conversion rates. When customers can easily reach out to ask questions or get assistance, they're more likely to complete their purchase.
Competitive Advantage: Offering a click-to-call feature can give your company a competitive advantage, particularly if your competitors do not offer a similar feature. It demonstrates a commitment to customer service and can help attract and retain customers.

By offering a simple and convenient way for customers to contact you, a customer initiated click-to-call feature can be a valuable addition to your customer service strategy.

Example call center software providers with customer initiated click-to-call

If customer-initiated click to call is an important feature to you, make sure to confirm that the provider you select supports this features. Here are a few providers do provide this feature:

Five9: Five9 offers a robust click-to-call solution that supports both agent initiated and customer initiated click-to-call functionality. Their solution is highly customizable, enabling businesses to configure the click-to-call feature to meet specific operational needs. Furthermore, Five9's click-to-call solution seamlessly integrates with various CRM systems, providing agents with customer information and interaction history at their fingertips.
Twilio: Twilio is well-known for its robust APIs that allow businesses to build a variety of communication solutions, including click-to-call functionality. Twilio's click-to-call solution is highly customizable and can be tailored to meet a business's specific needs. It allows customers to initiate a call directly from a website, email, or app, and it can be integrated into various CRM systems for a unified customer view.
Avaya: Avaya offers a comprehensive communication suite that includes click-to-call functionality. With Avaya's solution, businesses can enable customers to initiate a call directly from their website, enhancing the customer experience and improving communication efficiency. Like Five9 and Twilio, Avaya's click-to-call solution can be integrated with various CRM systems, providing agents with a unified view of customer interactions.

These are just a few examples of providers that offer customer initiated click-to-call functionality. However, it's important to research and evaluate multiple providers to find a solution that best fits your business's unique needs and requirements.

How to effectively implement customer initiated click-to-call in your call center

Implementing a customer initiated click-to-call system in your call center can be an invaluable tool for enhancing customer interaction and improving efficiency. However, proper planning and execution are necessary to ensure the feature is used to its full potential. Here are some steps to effectively implement this feature:

Identify Your Needs: The first step in implementing a customer initiated click-to-call system is to identify your call center's specific needs. This could depend on the nature of your business, the volume of calls your center handles, and the specific requirements of your customers.
Choose the Right Software: Once you've identified your needs, you can start looking for call center software that offers a customer initiated click-to-call feature. Look for software that is easy to use, reliable, and can scale with your business. Remember, a good click-to-call system should be able to seamlessly integrate with your existing CRM and other software tools.
Train Your Agents: Before implementing the feature, ensure your agents are adequately trained on how to use it. This can help minimize errors and improve the customer experience.
Ensure Good Network Infrastructure: Ensure that you have a reliable and strong network infrastructure. This is especially crucial if you're considering a WebRTC-based solution, as it requires a good internet connection to work effectively.
Implement Call Scheduling if Necessary: If your call center experiences high call volumes, consider implementing a call scheduling feature alongside click-to-call. This way, customers can choose a convenient time for the call, reducing wait times and increasing customer satisfaction.
Monitor and Evaluate: After implementing the click-to-call system, it's important to continuously monitor and evaluate its performance. This can help you identify any issues early and make necessary improvements to optimize efficiency and effectiveness.

Remember, the goal of a customer initiated click-to-call system is to improve the customer experience. If implemented properly, it can be an effective tool for boosting customer satisfaction and improving your call center's overall efficiency.