Questions About LiveKit SIP, Multi-Tenant Architecture, Concurrency, and Pricing

Getting Started
, , , , , , ,
1

Hello LiveKit Support Team,

I am currently building a multi-tenant AI calling platform using LiveKit. We are currently evaluating LiveKit Cloud versus self-hosting and would like to clarify a few architectural and scalability questions before moving to production.

Our platform will be used by multiple organizations, and each organization may have its own phone numbers and SIP providers. We are currently planning to support Twilio and Plivo.

Our architecture is roughly:

  • Our own AI agents
  • LiveKit Rooms
  • WebRTC
  • SIP
  • VAD / AMD and other call-handling/tuning techniques
  • Noise cancellation, including Krisp where applicable
  • We are not planning to deploy our AI agents on LiveKit; the agents will be managed by our own infrastructure.

Could you please help us with the following?

1. LiveKit Cloud concurrency on the Free tier

We are currently using the LiveKit Cloud Free tier.

Our application will serve multiple organizations/users. Could you clarify:

  • How many simultaneous/concurrent SIP calls can a Free-tier project handle?
  • Are there any concurrency limits specifically for SIP calls?
  • Does the concurrency limit apply at the project level, or per user/organization?
  • Are WebRTC participants and SIP calls counted differently?

2. Recommended plan vs self-hosting

Our expected production scale is approximately:

  • 5,000 calls/day
  • Up to approximately 5 concurrent calls per organization/user
  • Multiple organizations using the platform simultaneously.

Which approach would you recommend:

  1. LiveKit Cloud, and if so, which plan?
  2. Self-hosted LiveKit?
  3. A combination of LiveKit Cloud and our own infrastructure?

We would particularly like to understand the expected concurrency limits, SIP limitations, bandwidth considerations, and approximate cost implications at this scale.

3. Our own AI agents

We are building and hosting our own AI agents.

We intend to use LiveKit primarily for:

  • WebRTC
  • SIP connectivity
  • LiveKit Rooms
  • Audio streaming/media transport
  • VAD and call-control functionality where provided
  • AMD where supported
  • Noise cancellation/Krisp where available.

Could you clarify which of these capabilities are subject to LiveKit Cloud usage/concurrency limits, and which are handled entirely by our own infrastructure?

4. Multi-tenant SIP trunk architecture

Our platform is multi-tenant, with potentially hundreds or thousands of organizations.

We are considering creating a separate LiveKit SIP trunk for each organization.

For example:

Organization A
   └── Twilio numbers
       └── LiveKit SIP Trunk A

Organization B
   └── Twilio numbers
       └── LiveKit SIP Trunk B

Organization C
   └── Plivo numbers
       └── LiveKit SIP Trunk C

Is this a recommended/ supported architecture?

Can multiple phone numbers belonging to the same SIP provider be assigned to a single LiveKit SIP trunk for one organization?

5. Number limits per SIP trunk

How many phone numbers can be associated with a single LiveKit SIP inbound/outbound trunk?

Are there:

  • Hard limits?
  • Soft limits?
  • Recommended limits?
  • Any limits that change based on the LiveKit Cloud plan?

For example, could one trunk contain 10, 100, or 1,000 phone numbers?

6. Multiple SIP providers

We currently plan to support both:

  • Twilio
  • Plivo

What is the recommended LiveKit architecture when an application uses multiple SIP providers simultaneously?

For example:

                 LiveKit
                    |
          ┌─────────┴─────────┐
          │                   │
      Twilio Trunk        Plivo Trunk
          │                   │
      Twilio numbers      Plivo numbers

Does LiveKit officially support multiple inbound SIP trunks belonging to different SIP providers within the same project?

If yes, is there any official documentation or recommended configuration for this architecture?

7. allowed_addresses / SIP provider IP addresses

We have seen the allowed_addresses functionality in the LiveKit SIP API documentation.

Could you clarify whether allowed_addresses is required when using multiple SIP providers such as Twilio and Plivo, or whether it is simply an optional security/authentication mechanism?

Specifically:

  • Is it mandatory to configure Twilio and Plivo SIP signaling IP addresses?
  • If we have multiple trunks, how does LiveKit determine which inbound trunk a SIP call belongs to?
  • Is the trunk identified by the phone number, SIP credentials, source IP, or some combination of these?
  • Does using multiple SIP providers change this behavior?

We would like to make sure we are following the officially recommended architecture rather than implementing an unnecessary IP-filtering mechanism.

8. India region for Plivo

Our Plivo traffic will primarily be for Indian customers.

If our LiveKit project is deployed/operating in another region, is it possible to configure only the Plivo SIP traffic to use an India SIP endpoint/region, while keeping the rest of our LiveKit project configuration unchanged?

For example:

Twilio
   ↓
Twilio SIP region
   ↓
LiveKit


Plivo
   ↓
India SIP region
   ↓
LiveKit

Can different SIP providers/trunks use different LiveKit SIP regions within the same project?

If so, what is the recommended configuration?

9. One organization using both Twilio and Plivo

A particularly important use case for us is that one organization may use both Twilio and Plivo simultaneously.

For example:

Organization A

Twilio
 ├── +1 XXX XXX XXXX
 └── +1 XXX XXX XXXX

Plivo
 ├── +91 XXXXX XXXXX
 └── +91 XXXXX XXXXX

We would potentially have:

Organization A
   │
   ├── Twilio SIP Trunk
   │       └── Twilio numbers
   │
   └── Plivo SIP Trunk
           └── Plivo numbers

How does LiveKit distinguish these trunks when both belong to the same organization?

Is the recommended approach to create:

Organization A
   ├── LiveKit Twilio Trunk
   └── LiveKit Plivo Trunk

and then associate the phone numbers/dispatch rules accordingly?

If so, could you provide an example of the recommended configuration?

Our main goal

Before moving to production, we want to design the SIP architecture correctly for a multi-tenant platform with multiple SIP providers, rather than having to redesign it later.

Our expected scale is approximately 5,000 calls/day, with approximately 5 concurrent calls per organization, potentially across many organizations.

We would particularly appreciate guidance on:

  1. Recommended LiveKit Cloud plan for this workload
  2. SIP concurrency limits
  3. Multi-tenant trunk architecture
  4. Maximum/recommended numbers per trunk
  5. Multiple SIP providers in one project
  6. How LiveKit identifies/differentiates multiple trunks
  7. Whether allowed_addresses is actually required for this architecture
  8. Using different SIP regions for different providers, particularly India for Plivo
  9. Cloud vs self-hosted LiveKit at our expected scale

If there is any official documentation, architecture guide, or reference implementation covering multi-tenant + multiple SIP providers, please share it as well.

Thank you,

Current Plan: Free
Use Case: Multi-tenant AI calling platform

2

Hi, this is a huge question and I’ve tried to answer the specifics but in summary I’d say yes, it’s definitely possible. I’m sorry I don’t have more specific material I can point you towards.

There are no specific concurrency limits for SIP, but you will be affected by the Participant Concurrent connections and WebRTC minutes. You will also be affected by Inference concurrency, if you are using LiveKit Inference.

It would be easier to start with LiveKit Cloud. Honestly, most folks start on build like yourselves, then move to ship at launch, then move up to scale as needed. The first thing you would probably hit is the cap on Third-Party SIP minutes on ship, which is 5,000 a month, but you can stay on ship and pay for excess rather than jump straight to Scale.

Anything going over LiveKit cloud would be subject to the concurrency limits listed at Pricing | LiveKit. Where you are exempt is for anything in the ‘AI voice and video agents’ section on that page, since you are not hosting your agents in LiveKit.

That looks like a sensible architecture. You would manage this within a single LiveKit project and I assume you’ll have dispatch rules that will define which agent handles which trunk (maybe you have a separate agent for each trunk - since you’re not subject to the limits on Agent deployments that will be very possible)

The docs do not define hard published limits for “numbers per trunk” such as 10/100/1000. Since trunks support arrays of numbers and update operations, large multi-number trunks are supported operationally, but no official maximum is documented.

We don’t have any official documentation for this, but you match numbers to trunks so when you define the trunks so this will work as you define, it looks sensible.

It’s entirely optional. You would presumably be matching calls to trunks based on the number.

Yes, you would configure your inbound Plivo trunk as pinned to India: Region pinning for telephony | LiveKit Documentation. That’s at the trunk level, so you can have other trunks in your project that aren’t pinned.

You would define that in your dispatch rule, for example to route calls from both of these trunks to the same agent with the same metadata.

I don’t have anything I can share I’m afraid. We have many customers with multi-tenant set-ups but a lot of those are our enterprise customers with dedicated support.

3

Thank you so much Darryn