2.1.1 - Inbound Calls (Calls from Source Queue)

The first call source we are looking at is Queue. All calls matching this source are initiated by customers, so they are incoming. But it's a bit more complicated than that, so let's look at the details.

Differentiating "Parent" and "Child" calls

When your service receives an incoming call, there will always be a "Parent" call with the following parameters:

type = Inbound
source = queue
domain = external

Whenever the platform tries to connect one of your agents with this incoming call, it will create a "Child" call that has these parameters:

type = Outbound (because it is sent out from the babelforce platform)
source = queue
domain = internal

If the agent doesn't pick up or rejects the Child call, the platform will call the next available agent, and so on. This means, there can be a very large number of Child calls for each Inbound Parent call (see picture below). You recognize a successful Child call by looking at the call duration which will be greater than 0. There also are ways to differentiate Child calls by hangup reason, but this will go too far for now.

To understand this better, let's look at some examples.

Use cases

First use case: Call Duration

Let's say you create a ticket for every call. Whenever the call is finished, you want to know how long the call lasted. In other words, you want to have the exact time between the start and the end of the call printed on your ticket.

To achieve this, babelforce needs to update the ticket. So you need two automations: one to create a ticket and another to have it updated. The update happens on the finished calls, that's when you add the call duration to the ticket (placeholder: {call.duration}).

Give it a try: build automation on "Call Finished", select the action "Update Ticket" (in your Helpdesk type), and choose the trigger Always.

Now call your test number, have your agent accept the call, and end the call. You will see that you have two updates on your ticket. The duration of one will be longer than the other.

What happened? Remember, every Inbound Call also has a Child call (which is an outbound call connected to the agent). This means that at the moment the customer hangs up the call, not only one call is ended but two (the Inbound and the Outbound call). So what you now see in the ticket is the call duration of the Parent call (which is the full length of the phone call) and the duration of the Child call (which is equivalent to the talk time of the caller with the agent).

What you can do instead: build a trigger that only fires if "Call type: inbound" is given. See the screenshot for details.

And that's how the event should look in the end:

As you can see, we are using the trigger you build above. Now your ticket will only have one update informing you how long the whole call lasted.

You can check the process here:

Second use case: Talk Time

As you remember, in our first try to update a ticket with the call duration, the ticket was updated twice. This use case wants to look at the second update, the talk time.

Every time a call that was connected to an agent is finished, we want to add the talk time to the ticket. This way you know how long your agent talked to the customer.

You will need to build a trigger that fires on the Child Call to ensure that you only print the talk time. It's slightly more complex than the one we build in the use case above.

You will need three conditions:

Call duration > 0 - you will need this condition to avoid printing the talk time of unsuccessful calls. What if you don't? Imagine you have a call that tries to reach three different agents but none of them is answering the call - what would happen? Without this condition, you would have three updates on the ticket all saying "Talk time: 0 seconds".
Type: Outbound is given - here you ensure that no update happens on an Inbound Call, in other words, it fires on the Child Call.
Call source: queue - the last condition ensures that the trigger only fires on calls that came from the queue.

You are probably wondering why it has to be so complicated. Wouldn't it be enough to have the Call type: outbound & the condition on the call duration? You are right, if you are only planning to integrate Inbound calls (so you decide not to integrate Outbound, Dialer, or Transferred calls) you can work with the first two conditions. However, if you are planning to integrate also calls that are leaving your platform, you need to make sure that the trigger only fires once and only under the conditions you want.

To round that up, exchange the trigger in the automation you created before and adjust the ticket description in the event. It could look like this:

And this could be the result in your Helpdesk:

Here's a picture showing the duration and the talk time:

You can check the entire process here:

Now that you learned all about Inbound Calls, let's move on to calls that you or your agents do to call a customer, usually referred to as "Outbound Calls". There are four different Outbound calls sourced, we will start with API.