SIP providers sell capacity as channels: the number of calls that can run at the same time. Too few and callers get busy signals in your busiest hour; too many and you pay for lines nobody uses. This guide works out how many SIP channels you need from real data: measure the busy hour from your PBX call records, convert it to Erlangs, pick the channel count with Erlang B, then check the bandwidth and set the limit on the PBX.
Short answer: Find the busiest hour in your CDR, multiply its calls by the average call length in minutes and divide by 60 to get Erlangs, then use Erlang B at 1% blocking. 6 Erlangs (120 three-minute calls) needs 13 channels; 3 Erlangs needs 8. Our Erlang calculator does the maths and shows bandwidth. Add headroom for growth and calls that hold a channel without talking. (Reviewed November 2026.)
Table of Contents
Concurrent calls, channels and trunks
A channel is one simultaneous call over the trunk, inbound or outbound. Internal calls between extensions do not use trunk channels, but transfers and forwards to mobiles can use two: one leg in and one leg out. Queues and IVRs hold a channel from the moment the caller is answered by the PBX, not when an agent picks up. Count those when you size.
Measure your busy hour
-- approximate busiest hours over the last 30 days, external calls only (FreePBX CDR)
SELECT DATE_FORMAT(calldate, '%Y-%m-%d %H:00') AS hour,
COUNT(DISTINCT linkedid) AS calls,
ROUND(SUM(duration)/60) AS minutes
FROM asteriskcdrdb.cdr
WHERE calldate > NOW() - INTERVAL 30 DAY
AND (dstchannel LIKE 'PJSIP/my-trunk%' OR channel LIKE 'PJSIP/my-trunk%')
GROUP BY hour ORDER BY minutes DESC LIMIT 10;
Replace my-trunk with your trunk name. duration includes ringing time, which also occupies a channel, so it is the right column for sizing. Take a high but typical hour, not a one-off spike, and add expected growth.
Treat this as an approximation. It puts the whole of each call into the hour it started, so a call from 10:59 to 11:29 adds 30 minutes to 10:00 and nothing to 11:00. One call can also produce several CDR rows (transfers, ring groups, forwarding), which can count the same trunk time twice. For a closer figure, split each call across the hours it actually spans. This version works on MariaDB 10.2 and later, and gives Erlangs directly:
-- trunk occupancy per hour, each call clipped to hour boundaries
WITH RECURSIVE h AS (
SELECT CAST(DATE_FORMAT(NOW() - INTERVAL 30 DAY, '%Y-%m-%d %H:00:00') AS DATETIME) AS hs
UNION ALL
SELECT hs + INTERVAL 1 HOUR FROM h WHERE hs < NOW() - INTERVAL 1 HOUR
)
SELECT h.hs AS hour,
ROUND(SUM(TIMESTAMPDIFF(SECOND,
GREATEST(c.calldate, h.hs),
LEAST(c.calldate + INTERVAL c.duration SECOND, h.hs + INTERVAL 1 HOUR))) / 3600, 2) AS erlangs
FROM h
JOIN asteriskcdrdb.cdr c
ON c.calldate < h.hs + INTERVAL 1 HOUR
AND c.calldate + INTERVAL c.duration SECOND > h.hs
WHERE c.calldate > NOW() - INTERVAL 31 DAY
AND (c.dstchannel LIKE 'PJSIP/my-trunk%' OR c.channel LIKE 'PJSIP/my-trunk%')
GROUP BY h.hs ORDER BY erlangs DESC LIMIT 10;
If many calls are transferred or forked, check a few busy-hour linkedid values by hand to see whether one trunk call shows up in more than one row. Sampling core show channels every minute during the busy hour is a useful cross-check.
Work out the channels with Erlang B
Erlangs = minutes in the busy hour ÷ 60. Erlang B then gives the channels needed so that only a chosen share of calls finds every channel busy. 1 percent in the busy hour is the usual business target.
| Busy-hour traffic | Example | Channels at 1% blocking |
|---|---|---|
| 1.5 Erlangs | 30 calls × 3 min | 6 |
| 3 Erlangs | 60 calls × 3 min | 8 |
| 6 Erlangs | 120 calls × 3 min | 13 |
| 20 Erlangs | 300 calls × 4 min | 30 |
Larger groups need fewer channels per Erlang, which is why one shared trunk is cheaper than several small ones. Call centres with queues should also run Erlang C for agent numbers; the Erlang calculator does both.
Pick a blocking target
1% is a common target, not a rule. A lower target costs more channels; a higher one saves channels but gives more busy signals. For the same 6 Erlangs of busy-hour traffic, Erlang B gives:
| Blocking target | Blocked calls, at most | Channels for 6 Erlangs |
|---|---|---|
| 0.1% | 1 in 1,000 | 15 |
| 0.5% | 5 in 1,000 | 14 |
| 1% | 10 in 1,000 | 13 |
| 2% | 20 in 1,000 | 12 |
| 5% | 50 in 1,000 | 10 |
Here the step from 1% to 0.1% is only two channels, which is often worth paying for on a main inbound number where a lost call is a lost customer. An outbound-only trunk, where staff can simply redial, can run at 2% or more.
Erlang B assumes that a blocked caller gives up. If callers redial straight away, the retries add traffic to the same hour, so a trunk that already blocks often gets worse than the table suggests. Size so that blocking is rare, not routine.
Bandwidth for those calls
Each G.711 call uses about 87 kbps in each direction on Ethernet (20 ms packets), G.729 about 31 kbps. 13 channels of G.711 need about 1.1 Mbps up and 1.1 Mbps down. Keep voice under roughly half the upload capacity unless QoS is configured, and use the VoIP bandwidth calculator for SRTP or VPN overhead.
Set the limit on the PBX
Set the limit on your side too, so the PBX gives a clean busy or overflow route instead of an error from the provider. In FreePBX, open the trunk and set Maximum Channels on the General tab. On plain Asterisk, put every external call through one context, here [outbound-limited], that checks the count before dialling:
[outbound-limited]
exten => _X.,1,Set(GOT=${LOCK(trunk-out)}) ; one call at a time through the check
same => n,GotoIf($[${GOT} != 1]?busy)
same => n,Set(INUSE=${GROUP_COUNT(trunk-out)})
same => n,GotoIf($[${INUSE} >= 13]?full)
same => n,Set(GROUP()=trunk-out)
same => n,Set(GOT=${UNLOCK(trunk-out)})
same => n,Dial(PJSIP/${EXTEN}@my-trunk,60)
same => n,Hangup()
same => n(full),Set(GOT=${UNLOCK(trunk-out)})
same => n(busy),Busy(5)
The count, the check and the GROUP() assignment are three separate steps. Without the lock, two calls that start at the same moment can both see 12 in use and both dial, so the limit is exceeded by one. LOCK() makes the second call wait until the first has joined the group and released the lock, which takes milliseconds; the lock is also released if a call hangs up while holding it. Inbound calls take channels without passing through this check, so the PBX limit is a soft ceiling; the provider’s own limit still rejects anything above the contract.
Watch real usage after the change: asterisk -rx "core show channels" during the busy hour, and failed calls with cause 34 (no circuit available) or SIP 503 in the CDR suggest you are at the limit. Confirm it before buying channels: compare the time of each failure with group show channels or your channel count at that moment, and with the provider’s report. A 503 on its own does not prove purchased capacity ran out, because a provider also sends it when a server is overloaded or in maintenance.
Worked example: a 40-person office
A 40-person office runs the busy-hour query above. The top rows of the result (example figures) look like this:
+------------------+-------+---------+
| hour | calls | minutes |
+------------------+-------+---------+
| 2026-10-30 15:00 | 171 | 598 |
| 2026-10-14 10:00 | 104 | 312 |
| 2026-10-21 10:00 | 100 | 300 |
| 2026-10-07 11:00 | 97 | 296 |
+------------------+-------+---------+
- Drop the one-off: the 30 October hour happened once. Sizing for it (about 10 Erlangs) would mean 18 channels. The typical high hour is about 300 minutes.
- Convert: 300 ÷ 60 = 5 Erlangs, which needs 11 channels at 1% blocking.
- Add growth: with 20% planned growth the office needs to carry 6 Erlangs, so 13 channels.
- Check bandwidth: 13 G.711 calls need about 1.1 Mbps each way, or about 0.4 Mbps with G.729. Keeping voice under half the upload means at least about 2.3 Mbps of upload for G.711.
- Set the limit: 13 on the PBX (Maximum Channels or the
GROUP_COUNTcheck), matching the 13 channels on the provider contract.
If the same company split the traffic over two sites with a separate trunk each, each 3-Erlang site would need 8 channels: 16 in total, against 13 on one shared trunk.
Check real usage after go-live
Asterisk counts channels differently from your provider. A call bridged between a phone and the trunk is two Asterisk channels (the phone leg and the trunk leg), and core show channels includes internal calls too. Count only the trunk legs:
asterisk -rx "core show channels count" # totals for the whole PBX
asterisk -rx "group show channels" # channels in each GROUP(), e.g. trunk-out
asterisk -rx "core show channels concise" | grep -c '^PJSIP/my-trunk-' # trunk legs only
The dialplan check above only counts calls that pass through [outbound-limited]. Inbound calls use the same provider channels, so put them in the same group in the inbound context:
[from-trunk]
exten => _X.,1,Set(GROUP()=trunk-out) ; inbound calls count against the same limit
same => n,Dial(PJSIP/1001,30)
same => n,Hangup()
An inbound call that is forwarded to an outside number (follow-me, call forwarding to a mobile, a ring group with external members) uses two provider channels: the inbound leg and a new outbound leg. If the forward dials the trunk directly, the second leg is never counted and the PBX limit is too generous. Send forwards through the same limited context with a Local channel, so each trunk leg is counted once:
; in the forwarding or follow-me context: dial the outside number via the limit
exten => s,1,Dial(Local/${FWDNUM}@outbound-limited/n,30) ; /n keeps the Local channel in the call
same => n,Hangup()
The ;2 half of the Local channel runs [outbound-limited], takes the lock, joins trunk-out and stays in the group for the whole forwarded call. The /n option matters: without it Asterisk can optimise the Local channel out of the call once it is answered, and its group membership goes with it. With this in place, group show channels shows one entry per trunk leg. Check it during a test forward: one forwarded call should appear as two entries.
To see when your own limit stops a call, log it before the busy tone by adding same => n,Log(NOTICE,trunk-out full: ${INUSE} in use) straight after the n(full) line of the outbound example, before Busy(5). For calls the provider rejects, set congestion = yes in the [general] section of cdr.conf: calls that fail with cause 34 are then logged with disposition CONGESTION instead of FAILED, and you can count them per hour:
SELECT DATE_FORMAT(calldate, '%Y-%m-%d %H:00') AS hour, COUNT(*) AS congested
FROM asteriskcdrdb.cdr
WHERE calldate > NOW() - INTERVAL 30 DAY
AND disposition = 'CONGESTION'
GROUP BY hour ORDER BY congested DESC LIMIT 10;
A few congested calls in the worst hour of the month is what 1% blocking looks like. Congestion every day means it is time to add channels.
Common sizing mistakes
- Sizing by headcount or daily totals: rules such as “one channel per three users” ignore how much people phone. A 20-person sales team and a 20-person warehouse need very different trunks. Use the busy hour.
- Sizing inbound and outbound separately: most providers count both directions against one channel limit. Size on the combined traffic, as the CDR query does, unless the contract splits them.
- Measuring a quiet month: 30 days without month-end, a campaign or the seasonal peak understates the busy hour. Run the query over the period that includes your peak.
- Forgetting dial-in conferences: each outside participant holds a trunk channel for the whole meeting, so a ten-person dial-in meeting uses ten channels.
- Splitting capacity for redundancy: with two trunks for failover, the one left running must carry the whole busy hour on its own if you want full service during an outage.
SIP channel sizing at a glance



Official documentation: ITU-T E.500: traffic intensity, Asterisk GROUP_COUNT function, Asterisk LOCK function, Asterisk CDR specification.
Related: Erlang calculator · VoIP bandwidth calculator · VoIP codec bandwidth · Migrate a PBX to the cloud.
Frequently asked questions
How many SIP channels does a 20-person office need?
It depends on how much they phone. At a typical 0.1 to 0.2 Erlang per person in the busy hour, 20 people produce 2 to 4 Erlangs, which needs about 7 to 10 channels at 1% blocking. Measure your own CDR before buying.
Does an internal call between extensions use a SIP channel?
No. Only calls that go over the trunk use channels. A call forwarded or transferred to an outside number uses two: the incoming leg and the outgoing leg.
What happens when all SIP channels are busy?
The provider rejects the extra call, usually with 503 or 486, and the caller hears busy or is sent to an overflow route. Set a matching limit on the PBX so you control what callers hear.
Should I buy channels for the absolute peak?
Usually not. Erlang B at 1% blocking already covers a normal busy hour, and the rare extra peak costs a few busy signals rather than paying for idle channels all month.
Do inbound and outbound calls share the same SIP channels?
On most SIP trunks, yes: the channel count is the total of simultaneous calls in both directions. Some providers sell inbound and outbound capacity separately, so check the contract, and size on the combined busy-hour traffic unless it is split.
Why does Asterisk show more channels than my provider?
Asterisk counts every leg. A call between a phone and the trunk is two Asterisk channels, and internal calls appear too. Count trunk legs with core show channels concise filtered on the trunk name, or with group show channels if your dialplan sets GROUP() on trunk calls.
