PBXScalabilityCapacity PlanningAsteriskFreeSWITCHKamailio

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.

Kaushik ParmarFounder & VoIP Architect · 12+ years in telecom and VoIP 15 min read
5
Layers that can run out first
1,029
Channels for 1,000 Erlangs at 1%
83/s
REGISTERs: 50k devices, 600 s
70%
Max planned load vs tested

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

Scale-out PBX architecture: 50,000 phones and SIP trunks reach a Kamailio or OpenSIPS edge pair acting as registrar and load balancer, which dispatches calls to a pool of FreeSWITCH or Asterisk media servers, uses RTPengine for media and stores state in PostgreSQL and Redis, with Homer and Prometheus monitoring.
Each layer scales on its own: signalling, calls, packets and state.

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

LimitWhat runs outTypical triggerWhere to fix it
Signalling (CPS)CPU for SIP parsing, routing and dialplan logicDiallers, call bursts, retries after an outageSIP edge capacity; simpler dialplan; caching
RegistrationsEdge CPU and database writes for REGISTER and keepalivesLarge device counts, short intervals, mass re-registrationRegistrar at the edge; sensible intervals; in-memory location store
Media processingCPU for bridging, transcoding, recording, conferencingCodec mismatches, recording everything, big conferencesAvoid transcoding; more media servers
Packets and networkPackets per second, NIC interrupts, bandwidthThousands of RTP streams at 50 packets per second eachMedia relays (RTPengine), NIC tuning, more relays
Database and storageQuery latency, connection pools, disk I/OPer-call lookups, CDR writes, voicemail and recordingsCaching, 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.

FigurePublished rangeSource typeConditions
Asterisk concurrent calls, tuned 8-core serverAbout 1,500–3,000Vendor and consultancy blogsPassthrough audio, simple dialplan
Asterisk under stress testAbout 1,200Academic paper (small intranet test)Lab conditions
FreeSWITCH concurrent calls, 8-core serverAbout 3,000–10,000Vendor and consultancy blogsPassthrough audio
Calls per secondAsterisk about 50–150; FreeSWITCH about 200–500Vendor comparison tablesVaries widely with dialplan
Passthrough vs transcoding5–8× more calls with pure G.711 passthrough than G.729↔Opus on every legPublished transcoding guideSame 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

PBX capacity planning in six steps: measure busy-hour data, model with Erlang B and registrations per second, find the limiting layer, load test with SIPp, scale out with headroom, and monitor.
Size from your own busy hour, test the weakest layer, keep headroom.
  1. 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. 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. 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. 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. 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. 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 trafficChannels for 1% blockingChannels for 0.1% blocking
100 Erlangs117128
250 Erlangs273291
500 Erlangs527555
1,000 Erlangs1,0291,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))                # 1072

Erlang 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.

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.

FeatureRelative CPU costHow to reduce it
Bridging in the same codecLowNegotiate a common codec end to end
Transcoding (e.g. Opus ↔ G.711, G.729 ↔ G.711)HighOffer matching codecs to phones and trunks; transcode only at the edge of the network
Call recordingMedium (plus disk I/O)Record to local disk, move to object storage asynchronously
ConferencingMedium to high (mixing)Dedicated conference servers; limit participants per bridge
IVR with speech recognition or AIVaries; mostly externalStream audio to external speech services; scale them separately
Fax (T.38)Low to mediumIsolate 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 rateIP bandwidth per direction1,000 calls, both directions
G.711 (PCMU/PCMA)64 kbpsAbout 80 kbpsAbout 160 Mbps
G.7298 kbpsAbout 24 kbpsAbout 48 Mbps
Opus (voice at about 24 kbps)VariableAbout 40 kbpsAbout 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.

SettingWhereWhy it matters
max-sessionsFreeSWITCH switch.conf.xmlHard cap on concurrent sessions; the default is far below what a large server can handle
sessions-per-secondFreeSWITCH switch.conf.xmlCaps new sessions per second; raise it for diallers and busy contact centres
RTP port rangeFreeSWITCH switch.conf.xml / Asterisk rtp.confEach call leg uses ports; the range must exceed peak legs
Open file and process limitssystemd unit (LimitNOFILE, LimitNPROC)Sockets and threads per process
usrloc db_modeKamailio usrloc moduleChoose in-memory with write-back rather than writing every registration through
Children and memoryKamailio children, shared and private memoryEnough 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

MetricAlert whenTool
Concurrent calls per media serverAbove 70% of tested capacityPBX API or event socket → Prometheus
New calls per second at the edgeAbove 70% of tested CPSKamailio statistics → Prometheus
Registrations per secondSudden spike (storm)Kamailio statistics
CPU and packets per secondSustained high loadNode exporter
Packet loss and jitterAbove your quality thresholdRTCP stats, Homer
SIP error responses (5xx, 408)Rate risesHomer 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.