PBX Scalability: Capacity Planning for 1,000+ Concurrent Calls
How many calls can one Asterisk or FreeSWITCH server handle? Search for the answer and you will find numbers from 1,200 to 10,000, often with no method behind them. This guide explains what really limits a PBX, how to size one from your own traffic with Erlang B and registration maths, how to load test it, and how to scale out past a single server to 1,000+ concurrent calls and 50,000+ extensions.
Quick answer
How many concurrent calls can a PBX handle, and how do you size one?
There is no single answer to how many calls a PBX can handle, because the limit depends on codecs, transcoding, recording, call rate and registrations, not just CPU cores. Published figures for a tuned 8-core server range from about 1,500 to 3,000 concurrent calls for Asterisk and 3,000 to 10,000 for FreeSWITCH, but they are vendor estimates. Size from your own busy hour with Erlang B, load test with SIPp using your real call mix, and scale out behind a Kamailio or OpenSIPS edge.
Why "how many calls?" has no single answer
Ask ten VoIP engineers how many calls a server can handle and you will get ten answers, all starting with "it depends". That is not evasion. A call that simply bridges two legs in the same codec costs very little. The same call with transcoding, recording, a conference bridge, an IVR with speech recognition or an AI voice agent can cost many times more. A system that handles 2,000 quiet calls can struggle with 300 calls that all start within the same few seconds.
So capacity is not a property of the software alone. It is a property of the software, the hardware, the codecs, the features in use and the traffic pattern together. The useful question is not "how many calls can Asterisk handle?" but "how many of my calls can my design handle, and which part runs out first?" This guide gives a method for answering that.
It complements two related guides: PBX high availability, which covers surviving failures, and multi-tenant VoIP platform architecture, which covers isolating customers. Here the focus is load.
The five limits of a PBX
| Limit | What runs out | Typical trigger | Where to fix it |
|---|---|---|---|
| Signalling (CPS) | CPU for SIP parsing, routing and dialplan logic | Diallers, call bursts, retries after an outage | SIP edge capacity; simpler dialplan; caching |
| Registrations | Edge CPU and database writes for REGISTER and keepalives | Large device counts, short intervals, mass re-registration | Registrar at the edge; sensible intervals; in-memory location store |
| Media processing | CPU for bridging, transcoding, recording, conferencing | Codec mismatches, recording everything, big conferences | Avoid transcoding; more media servers |
| Packets and network | Packets per second, NIC interrupts, bandwidth | Thousands of RTP streams at 50 packets per second each | Media relays (RTPengine), NIC tuning, more relays |
| Database and storage | Query latency, connection pools, disk I/O | Per-call lookups, CDR writes, voicemail and recordings | Caching, connection pooling, async CDR writes, object storage |
In our experience, teams usually look at media first, but the first limit they hit is often elsewhere: a database query in the dialplan that takes 50 milliseconds under load, a registration storm when a site's internet connection comes back, or a dialler that starts 100 calls in one second. Sizing well means checking all five.
Published per-server figures, and how to read them
Plenty of figures circulate. Here are the commonly published ranges, with where they come from. Treat them as a rough starting point for a test plan, not as design inputs.
| Figure | Published range | Source type | Conditions |
|---|---|---|---|
| Asterisk concurrent calls, tuned 8-core server | About 1,500–3,000 | Vendor and consultancy blogs | Passthrough audio, simple dialplan |
| Asterisk under stress test | About 1,200 | Academic paper (small intranet test) | Lab conditions |
| FreeSWITCH concurrent calls, 8-core server | About 3,000–10,000 | Vendor and consultancy blogs | Passthrough audio |
| Calls per second | Asterisk about 50–150; FreeSWITCH about 200–500 | Vendor comparison tables | Varies widely with dialplan |
| Passthrough vs transcoding | 5–8× more calls with pure G.711 passthrough than G.729↔Opus on every leg | Published transcoding guide | Same hardware |
Published concurrent-call ranges on an 8-core server (upper end of each range)
Upper ends of published vendor and consultancy estimates, not benchmarks we ran. Your own figure depends on codecs, features and hardware.
Two things stand out. The ranges are wide, which tells you the conditions matter more than the software. And the gap between Asterisk and FreeSWITCH is real but smaller than the gap between passthrough and transcoding on either. Our Asterisk vs FreeSWITCH guide covers the wider comparison.
A six-step sizing method
1. Measure your busy hour
From CDRs or carrier reports, find the busiest hour of the busiest regular day: calls started, average duration, peak concurrent calls and peak new calls per second.
2. Model the load
Convert busy-hour traffic to Erlangs and use Erlang B to find channels for your blocking target; calculate registrations per second from device count and registration interval.
3. Find the limiting layer
Check which layer runs out first: SIP signalling and registrations at the edge, media and transcoding on the media servers, packets on the relays, or queries in the database.
4. Load test with your real call mix
Use SIPp or a similar tool with your real codecs, recording, IVR and call durations, and raise load until quality or CPU degrades.
5. Scale out with headroom
Add media servers, relays or edge nodes so busy-hour load stays below about 70% of tested capacity, with one node spare in each pool.
6. Monitor and repeat
Track concurrent calls, CPS, CPU, packet loss and registration rates against tested limits, and repeat the test after major changes.
If you are designing a new platform with no history, estimate the busy hour from the business: number of users, share likely to be on a call at the busiest time, and expected call length. Then plan to repeat the exercise with real data after the first few months.
Erlang B: a worked example
Telephone traffic is measured in Erlangs: one Erlang is one channel busy for one hour. Busy-hour traffic in Erlangs is the number of calls in the busy hour multiplied by the average call duration in hours. The Erlang B formula then gives the probability that a call is blocked for a given number of channels, which tells you how many channels, trunks or licences you need.
Example: a contact centre handles 20,000 calls in its busiest hour, averaging 3 minutes each. That is 20,000 × 3 ÷ 60 = 1,000 Erlangs. How many channels are needed?
| Busy-hour traffic | Channels for 1% blocking | Channels for 0.1% blocking |
|---|---|---|
| 100 Erlangs | 117 | 128 |
| 250 Erlangs | 273 | 291 |
| 500 Erlangs | 527 | 555 |
| 1,000 Erlangs | 1,029 | 1,072 |
These figures were calculated with the Erlang B formula below. Note how efficiency improves with size: 100 Erlangs needs 17% more channels than its average load for 1% blocking, while 1,000 Erlangs needs only about 3% more. Large shared pools are efficient, which is one reason multi-tenant platforms work.
# Python: Erlang B, channels needed for a target blocking probability
def erlang_b(traffic_erlangs: float, channels: int) -> float:
inv_b = 1.0
for k in range(1, channels + 1):
inv_b = 1.0 + inv_b * k / traffic_erlangs
return 1.0 / inv_b
def channels_needed(traffic_erlangs: float, target_blocking: float) -> int:
n = 1
while erlang_b(traffic_erlangs, n) > target_blocking:
n += 1
return n
busy_hour_calls, avg_minutes = 20_000, 3
erlangs = busy_hour_calls * avg_minutes / 60 # 1,000 Erlangs
print(channels_needed(erlangs, 0.01)) # 1029
print(channels_needed(erlangs, 0.001)) # 1072Erlang B assumes blocked calls are lost, which suits trunks and channel licences. For call centre queues where callers wait, use Erlang C to size agents; our predictive dialler guide covers outbound pacing.
Registration load: the hidden limit
Every SIP phone and softphone registers with the PBX and refreshes that registration before it expires. At 50,000 devices, that background load is significant even when nobody is calling. The minimum rate is the device count divided by the registration interval; real devices refresh before expiry, so actual rates are higher.
REGISTER requests per second for 50,000 devices, by registration interval (calculated)
Calculated as devices ÷ interval. Real rates are higher because devices refresh before expiry, and NAT keepalives add more.
Three practical points. First, handle registrations at the SIP edge, not on the media servers. Kamailio and OpenSIPS are built for this, and Kamailio's usrloc module can keep locations in memory with database write-back rather than writing every refresh straight to the database. Second, keep NAT bindings open with lightweight keepalives instead of very short registration intervals. Third, plan for the storm: when an office or a whole region reconnects after an outage, thousands of devices register at once, so the edge needs headroom well above the average rate.
Media, transcoding and recording
Media processing is where most CPU goes on the media servers. The cheapest call is one where both legs use the same codec and the server only relays or bridges packets. Every feature that touches the audio adds cost.
| Feature | Relative CPU cost | How to reduce it |
|---|---|---|
| Bridging in the same codec | Low | Negotiate a common codec end to end |
| Transcoding (e.g. Opus ↔ G.711, G.729 ↔ G.711) | High | Offer matching codecs to phones and trunks; transcode only at the edge of the network |
| Call recording | Medium (plus disk I/O) | Record to local disk, move to object storage asynchronously |
| Conferencing | Medium to high (mixing) | Dedicated conference servers; limit participants per bridge |
| IVR with speech recognition or AI | Varies; mostly external | Stream audio to external speech services; scale them separately |
| Fax (T.38) | Low to medium | Isolate on dedicated servers if volume is high |
The single most effective scaling step is usually removing unnecessary transcoding. WebRTC clients typically use Opus while many carriers use G.711, so somewhere a conversion is needed; doing it once, on servers sized for it, is better than doing it on every media server. AI voice agents add a different load: streaming audio to speech recognition and receiving synthesised speech. Our Asterisk AGI vs ARI vs AudioSocket guide covers the options for that.
Bandwidth per call
Bandwidth is easy to calculate and easy to forget. Each RTP packet carries 40 bytes of IP, UDP and RTP headers; at the common 20-millisecond packet time that is 50 packets a second, or 16 kbps of overhead per direction, on top of the codec rate.
| Codec (20 ms packets) | Codec rate | IP bandwidth per direction | 1,000 calls, both directions |
|---|---|---|---|
| G.711 (PCMU/PCMA) | 64 kbps | About 80 kbps | About 160 Mbps |
| G.729 | 8 kbps | About 24 kbps | About 48 Mbps |
| Opus (voice at about 24 kbps) | Variable | About 40 kbps | About 80 Mbps |
Figures are calculated at the IP layer, before Ethernet framing, VPN or TLS overhead. Packets per second often matter more than megabits: 1,000 calls in both directions is about 100,000 packets a second through your media relays, which is why NIC tuning and multiple relays matter at scale.
Scale-out architecture past one server
Beyond a few hundred concurrent calls, or whenever one server failing would affect too many users, a single PBX becomes a risk. The standard pattern separates the layers so each can grow on its own.
SIP edge (Kamailio or OpenSIPS)
A pair of proxies that handles registrations, authentication, routing and load balancing to media servers. One edge pair can front many media servers. See our OpenSIPS load balancing guide.
Media server pool (FreeSWITCH or Asterisk)
Several servers with the same configuration behind the edge, plus at least one spare. Keep them as stateless as possible so they can be added or replaced freely.
Media relays (RTPengine)
Handle NAT traversal and media anchoring, and optionally transcoding and recording, separately from call logic.
Data layer
PostgreSQL or similar for configuration and CDRs, Redis for fast-changing state such as locations and limits, object storage for recordings and voicemail.
# Kamailio: spread calls over a FreeSWITCH pool with health checks
loadmodule "dispatcher.so"
modparam("dispatcher", "list_file", "/etc/kamailio/dispatcher.list")
modparam("dispatcher", "ds_ping_interval", 10) # OPTIONS ping every 10 s
modparam("dispatcher", "ds_probing_mode", 1) # probe all destinations
modparam("dispatcher", "ds_probing_threshold", 2) # mark down after 2 failures
modparam("dispatcher", "flags", 2) # keep alternatives for failover
# /etc/kamailio/dispatcher.list (setid destination)
# 1 sip:10.0.1.11:5080
# 1 sip:10.0.1.12:5080
# 1 sip:10.0.1.13:5080
route[TO_MEDIA] {
# algorithm 4 = round-robin; the flags modparam enables failover
if (!ds_select_dst("1", "4")) {
sl_send_reply("503", "No media server available");
exit;
}
t_on_failure("MEDIA_FAILOVER");
t_relay();
}
failure_route[MEDIA_FAILOVER] {
if (t_check_status("(408)|(5[0-9][0-9])") && ds_next_dst()) {
t_on_failure("MEDIA_FAILOVER");
t_relay();
}
}With this pattern, adding capacity means adding a media server to the dispatcher list. Phones and trunks never see the change. The OpenSIPS load balancing guide shows the equivalent on OpenSIPS, including load-based rather than round-robin distribution.
Software limits to raise
Both main PBX engines ship with conservative limits that protect small systems and silently cap large ones. Check them before load testing.
| Setting | Where | Why it matters |
|---|---|---|
| max-sessions | FreeSWITCH switch.conf.xml | Hard cap on concurrent sessions; the default is far below what a large server can handle |
| sessions-per-second | FreeSWITCH switch.conf.xml | Caps new sessions per second; raise it for diallers and busy contact centres |
| RTP port range | FreeSWITCH switch.conf.xml / Asterisk rtp.conf | Each call leg uses ports; the range must exceed peak legs |
| Open file and process limits | systemd unit (LimitNOFILE, LimitNPROC) | Sockets and threads per process |
| usrloc db_mode | Kamailio usrloc module | Choose in-memory with write-back rather than writing every registration through |
| Children and memory | Kamailio children, shared and private memory | Enough worker processes and memory for peak signalling |
<!-- FreeSWITCH autoload_configs/switch.conf.xml (excerpt) --> <param name="max-sessions" value="5000"/> <param name="sessions-per-second" value="200"/> <param name="rtp-start-port" value="16384"/> <param name="rtp-end-port" value="32768"/> # systemd override for freeswitch.service [Service] LimitNOFILE=1000000 LimitNPROC=60000
Raise limits to just above what your load tests show the server can handle, not to arbitrary large numbers. A limit that is slightly too low fails visibly; one that is far too high lets an overloaded server accept calls with broken audio.
Load testing with SIPp
SIPp is the standard open-source tool for generating SIP load. Use it to find where your design breaks, with your real codecs, call durations and features. Test one layer at a time, then the whole path.
# Ramp test: start 20 calls/s, hold each call 60 s, cap at 3,000 concurrent
sipp -sn uac -r 20 -rp 1000 -l 3000 -d 60000 \
-s 1000 -i 10.0.9.5 10.0.1.10:5060 -trace_stat -fd 5
# Burst test: 200 calls/s for 30 s to find the CPS limit at the edge
sipp -sn uac -r 200 -rp 1000 -m 6000 -d 20000 -i 10.0.9.5 10.0.1.10:5060
# With media: use a scenario that plays RTP (pcap_play) so media servers do real work
sipp -sn uac_pcap -r 10 -l 1000 -d 120000 -i 10.0.9.5 10.0.1.10:5060- Run SIPp from separate machines so the load generator is not the bottleneck
- Include real media; signalling-only tests overstate media server capacity
- Match your real codec mix, including the share of calls that need transcoding
- Turn on recording, IVR and other features in the same proportion as production
- Watch audio quality (packet loss, jitter) as well as CPU; quality fails before CPU hits 100%
- Record the point where quality degrades and plan production load at 70% of it
Our voice agent testing and monitoring guide covers load testing for AI voice agents, where speech services add their own limits.
Monitoring against tested capacity
| Metric | Alert when | Tool |
|---|---|---|
| Concurrent calls per media server | Above 70% of tested capacity | PBX API or event socket → Prometheus |
| New calls per second at the edge | Above 70% of tested CPS | Kamailio statistics → Prometheus |
| Registrations per second | Sudden spike (storm) | Kamailio statistics |
| CPU and packets per second | Sustained high load | Node exporter |
| Packet loss and jitter | Above your quality threshold | RTCP stats, Homer |
| SIP error responses (5xx, 408) | Rate rises | Homer SIP capture |
Capacity planning is never finished. Traffic grows, features change, and a new customer can double your peak overnight. Review the busy hour monthly, re-test after major changes, and add capacity before alerts fire, not after.
A real example: 1,000+ channels and 50,000+ extensions
CelloIP built a multi-tenant hosted PBX platform for a North American enterprise on public cloud. It runs FreeSWITCH behind a Kamailio/OpenSIPS SIP layer and was designed to grow past 1,000 concurrent channels by adding servers rather than redesigning. It serves 50,000+ extensions and 50,000+ DIDs across 100+ tenants.
CelloIP project outcome (client kept private)
1,000+ concurrent channels, 50,000+ extensions and 50,000+ DIDs for 100+ tenants, scaled by adding servers behind the SIP edge.
Frequently asked questions
How many concurrent calls can Asterisk handle?
Published estimates for a tuned 8-core server range from roughly 1,500 to 3,000 concurrent calls when audio passes through without transcoding, and one academic stress test measured about 1,200. These are not guarantees: transcoding, recording, conferencing and complex dialplans can cut capacity several times over. Load test your own call mix before relying on any figure.
How many concurrent calls can FreeSWITCH handle?
Vendor and consultancy estimates for an 8-core server range from about 3,000 to 10,000 concurrent calls without transcoding. FreeSWITCH also has configurable limits, max-sessions and sessions-per-second in switch.conf.xml, that must be raised for high-volume systems. As with Asterisk, measure with your own codecs and features.
What is the difference between concurrent calls and calls per second?
Concurrent calls is how many calls are up at the same moment; it is limited mainly by media processing. Calls per second (CPS) is how many new calls start each second; it is limited mainly by SIP signalling, database lookups and dialplan logic. Diallers and contact centres often hit CPS limits before concurrent call limits.
How do I calculate how many channels I need?
Measure busy-hour traffic in Erlangs, which is calls in the busiest hour multiplied by average call duration in hours, then use the Erlang B formula to find the channels needed for an acceptable blocking rate. For example, 1,000 Erlangs needs 1,029 channels for 1% blocking and 1,072 for 0.1%.
Does transcoding really reduce capacity that much?
Yes. Passing audio through in the same codec costs little CPU, while converting between codecs, for example Opus to G.711 or G.729, decodes and re-encodes every packet. One published guide estimates a box doing pure G.711 passthrough handles 5 to 8 times more calls than the same box transcoding G.729 to Opus on every leg. Avoid transcoding where you can by negotiating common codecs.
How many SIP registrations can a PBX handle?
Registrations are usually handled by the SIP edge rather than the media servers. The load is the number of devices divided by the registration interval: 50,000 devices re-registering every 600 seconds send at least about 83 REGISTER requests a second, while a 60-second interval would mean over 800. NAT keepalives and re-registration storms after an outage matter more than the average.
When should I split a PBX into multiple servers?
Split before a single server is your capacity or failure limit: when busy-hour load passes about 70% of the tested capacity of one server, when one failure would drop more calls than the business accepts, or when you need to add tenants or regions independently. A SIP edge with a pool of media servers lets you add servers without changing phones or trunks.
What does a scalable PBX platform cost to build?
As a guide, a company IP PBX is typically $8,000 to $20,000 over 4 to 8 weeks, and a multi-tenant cloud PBX platform with portals, billing, softphone apps and high availability is typically $30,000 to $80,000 over 10 to 20 weeks. Carrier-scale systems are scoped after discovery.
Work with CelloIP
Need a PBX that scales with you?
CelloIP designs and builds PBX and hosted PBX platforms on Asterisk, FreeSWITCH, Kamailio and OpenSIPS, from single servers to multi-tenant estates with thousands of concurrent calls. We reply within one business day, and you own the code.