Back to the blog

November 18, 2026 · 11 min · api · engineering

.md

Concurrent avatar calls and 429 errors: plan limits, queue, retry

Simultaneous avatar calls by plan, Nov 2026: Realtime Avatar Starter 3, Developer 10, Tavus Starter 1, Anam Explorer 3, and what each kind of 429 means.

As of November 2026, among the vendors compared here, these are the plans under $60 a month whose pricing pages state that 3 or more people can talk to an avatar at the same time, in order of monthly price: LemonSlice Starter ($8, or $7 a month billed yearly; 3 simultaneous calls), Realtime Avatar Starter ($9, 3) and Developer ($24, 10), Anam Explorer ($49, 3), Simli Pro ($49, 10) and Tavus Builder ($59, 3). Tavus Starter and Anam Starter allow 1, Realtime Avatar Studio ($119) allows 20, HeyGen LiveAvatar's paid plans, from $99, list unlimited concurrent sessions, and Talking Avatar charges per minute, billed per second, with no concurrency plans. On Realtime Avatar, a 429 when starting a call is one of three answers: code concurrency_limit_reached means your plan's ceiling is full (free a session, do not show it as a queue); a body with queue_size and recommended_retry_ms is a real queue (show the position, retry after the delay); a body with neither is the rate limit (back off).

Below: the per-plan list with sources, launch-day sizing you can redo with your own numbers, code that tells the three 429s apart, and a queue screen. Competitor figures come from each vendor's own page, read on 16 November 2026 and linked at the end. Realtime Avatar figures come from its pricing page.

Concurrent calls by plan, as of November 2026

Concurrency is its own limit, separate from included minutes: a plan can include hundreds of minutes and still refuse the fourth person who starts a call while three are in progress. Each line gives the monthly price, then how many sessions can run at once.

  • Realtime Avatar Sandbox: free, 480 credits once per account, no card (8 realtime minutes, or a first avatar plus 2 minutes of calls), 2 concurrent calls.
  • Realtime Avatar Starter: $9 a month, 120 minutes included, then $0.095 a minute, 3 concurrent calls.
  • Realtime Avatar Developer: $24 a month, 600 minutes included, then $0.085 a minute, 10 concurrent calls.
  • Realtime Avatar Studio: $119 a month, 3,000 minutes included, then $0.08 a minute, 20 concurrent calls. Above it, Scale is a contact-sales plan: credits sized to your volume and reserved warm capacity, arranged with sales.
  • Tavus (tavus.io/pricing): Free 1 concurrent session, Starter $22 1, Builder $59 up to 3, Growth $397 up to 10, Business $975 up to 15, Enterprise custom. The same page still carries an older plan block in which a $59 Starter allows up to 3 concurrent streams.
  • Anam (anam.ai/pricing): Free 1 simultaneous session, Starter $12 1, Explorer $49 3, Growth $299 5, Professional $999 10; Enterprise lists 100 to unlimited.
  • LemonSlice (lemonslice.com/pricing): Starter $8 a month on monthly billing, shown as $7 a month with yearly billing; concurrency limit 3, 41 included minutes, $0.22 per extra minute, and hosted speech recognition, LLM and voice add $0.09 a minute. Its free tier is a chat preview; API access needs a paid plan. Creator ($40) and Professional ($100) are also listed, but the plan comparison read for this article showed a concurrency limit only for Starter, so check theirs on the page.
  • Simli (simli.com/pricing): Free 1 concurrent session, Hobby $10 2, Pro $49 10, Scale $249 50.
  • HeyGen LiveAvatar (HeyGen help center): Free allows 1 session at a time, each up to 2 minutes; Essential ($99) and Business ($475) list unlimited concurrent sessions, and HeyGen says you pay for minutes streamed, never for concurrency.
  • Talking Avatar (talking-avatar.dev/pricing): priced per minute and billed per second from prepaid credits, with no subscription; the page says the self-serve price is the same at any volume, with no tiers, seats or concurrency plans.

The same list as a decision, by how many people need to talk at once. Each line gives the lowest listed monthly price among the subscription plans above, on monthly billing; Talking Avatar is left out because it has no plans and charges per minute at any volume.

  • Up to 3 at once: LemonSlice Starter, $8; Realtime Avatar Starter, $9; then Simli Hobby ($10 for 2), Anam Explorer ($49 for 3) and Tavus Builder ($59 for 3). For a free test with 2 people, Realtime Avatar Sandbox allows 2.
  • 4 to 10 at once: Realtime Avatar Developer, $24 for 10; Simli Pro, $49 for 10. Anam Growth ($299 for 5) and Tavus Growth ($397 for 10) cost more.
  • 11 to 20 at once: HeyGen LiveAvatar Essential, $99, which lists unlimited concurrent sessions but includes 1,100 credits (550 minutes in its Full mode); Realtime Avatar Studio, $119 for 20, with 3,000 minutes.
  • More than 20 at once: LiveAvatar's paid plans, Simli Scale ($249 for 50), or a plan arranged with sales at Anam, Tavus or Realtime Avatar.

Where others fit better: from 11 people at once, LiveAvatar Essential lists unlimited concurrent sessions for $99, below Studio at $119, though with fewer included minutes. Past 20, LiveAvatar's paid plans and Simli Scale (50 sessions for $249) can be bought without a sales call, while Realtime Avatar needs a plan arranged with sales, and Talking Avatar sells no concurrency plans at all. Per-minute prices also cover different things, since some include speech recognition, the LLM and the voice and some only render the face, so compare all-in cost before comparing concurrency.

Sizing launch day

The arithmetic is short: average calls in progress equal calls started per minute times the average call length in minutes. Traffic on launch day arrives in bursts (a front-page slot, a newsletter going out), so plan for peaks of about twice the average.

A worked example for a Product Hunt launch: 1,200 visitors in the launch hour, and 10 percent of them start a 3-minute call. That is 120 calls in the hour, or 2 a minute, and 2 times 3 minutes means about 6 calls in progress on average, with peaks around 12. Starter's 3 slots would turn away about half of the average load. Developer's 10 covers the average with headroom, and Studio's 20 covers the peak. On Developer, a call beyond the tenth in progress is refused rather than queued, so either size for the peak or hold a short waiting list in your own app (more on that below).

Check minutes as well as slots. Those 120 calls use 360 minutes in one hour, three times Starter's 120 included minutes for the whole month, and more than its 3 slots can carry in an hour (3 slots times 60 minutes is 180 call minutes). Developer's 600 included minutes cover that hour inside the $24 plan, with 240 minutes left for the rest of the month. Even spread over a month, the same 360 minutes on Starter would cost $9 plus 240 overage minutes at $0.095 ($22.80), $31.80 in total, so for a launch Developer is both the bigger plan and the cheaper one. The same function, for your own numbers:

// Average calls in progress = calls started per minute x average call length (minutes).
export function slotsNeeded(callsPerHour: number, avgCallMinutes: number, peakFactor = 2) {
  const average = (callsPerHour / 60) * avgCallMinutes;
  return { average, peak: Math.ceil(average * peakFactor) };
}

slotsNeeded(120, 3); // { average: 6, peak: 12 }: Developer (10) covers the average, Studio (20) the peak

Two vendors publish rules of thumb for ordinary days: Anam's pricing FAQ suggests about 200 daily active users per simultaneous session, and LemonSlice's page says there is usually a 100 to 1 ratio of users to concurrent calls. A launch hour squeezes a day of traffic into minutes, so use the per-minute arithmetic for the spike and the ratios for the weeks after.

The three 429s and what to do with each

The status code alone only says too many. On a Realtime Avatar mint, the Errors section of the API reference describes two capacity 429s that want opposite reactions, plus the per-key rate limit. Switch on the body, not the status:

  • Plan ceiling: code concurrency_limit_reached. Top-level maxConcurrentSessions and liveSessions report your limit and the occupied reservations, and activeSessions, connectingSessions and pendingSessions break the count down. Starting and connecting sessions count too, even when no conversation is active. This refusal is not a queue position: end a session or wait for pending starts to finish or be released, then retry. Show the error, keep the requestId for support, and upgrade only when you need more simultaneous sessions.
  • Capacity queue: no code, and the body carries queue_size and recommended_retry_ms. The SDK returns a queued result (isQueued) with position and retryAfterMs. Render the position and retry after the delay. The docs say this result is deliberately not auto-retried, because a blind retry would burn the backoff and get the same answer.
  • Rate limit: a 429 with neither a code nor those queue fields is the per-key rate limit. Back off and try later; do not show it as a place in line.

Use SDK 0.12.0 or later, which keeps concurrency refusals as errors. Older releases, including 0.11.1 and 0.11.5, map every 429 to a queued result and can hide the refusal, and a null queue position alone does not tell a refusal from a real queue. If your server starts calls with the SDK, the classification looks like this:

// lib/start-avatar-call.ts (server only)
import { RealtimeAvatar, RealtimeAvatarHttpError, isQueued } from "realtime-avatar";

const rta = new RealtimeAvatar({ apiKey: process.env.REALTIME_AVATAR_API_KEY ?? "" });

export type StartOutcome =
  | { kind: "ready"; grant: Record<string, unknown> }
  | { kind: "queued"; position: number | null; retryAfterMs: number }
  | { kind: "plan_full"; requestId: string | undefined }
  | { kind: "rate_limited" };

export async function startAvatarCall(avatarId: string): Promise<StartOutcome> {
  try {
    const call = await rta.startCall({ avatarId });
    if (isQueued(call)) {
      // Capacity queue: a real place in line. Show it, then ask again after retryAfterMs.
      return { kind: "queued", position: call.position, retryAfterMs: call.retryAfterMs };
    }
    return { kind: "ready", grant: call.raw }; // relay the grant to the client unchanged
  } catch (error) {
    if (error instanceof RealtimeAvatarHttpError && error.status === 429) {
      if (error.code === "concurrency_limit_reached") {
        // Your plan's ceiling, not a queue: end a session or wait for pending starts to clear.
        return { kind: "plan_full", requestId: error.requestId };
      }
      // Any other 429 (no code, no queue fields) is the per-key rate limit. Back off before trying again.
      return { kind: "rate_limited" };
    }
    throw error;
  }
}

Why one user can hit the ceiling

One developer, one browser tab, and concurrency_limit_reached anyway: look for parallel duplicate starts first. In development, React StrictMode runs one extra setup and cleanup cycle for every effect to expose missing cleanup, so if your own code starts a call from an effect (for example by calling your server's start route) and does not end it in the cleanup, one person asks for two sessions. Both count while they are starting and connecting, which on Sandbox's 2 slots is the whole plan. The docs' advice is to avoid parallel duplicate starts and release sessions on cancellation or unmount:

  • Start a call from a user action, not on page load. The builder guides in the docs mount the call component when the user presses a call button and show the button again when the call ends.
  • Allow one start in flight per user: hide or disable the button while a call is starting.
  • End the call when the user cancels or the component unmounts, so a cleanup never leaves a session behind.
  • If the refusal appears only in development, test the limit in a production build, where StrictMode's extra cycle does not run.

The same rule explains getting concurrency_limit_reached when nobody is talking. A slot is held by any session that is starting or connecting, not only by conversations in progress, and an open call counts whether or not anyone is speaking. Read the breakdown in the refusal: a nonzero connectingSessions or pendingSessions means calls your app started are still starting or connecting, with nobody in them yet.

Showing the queue

In the React SDK, the queue answer shows up as call.status "waiting", with the number in call.queuePosition. Write it as copy, not as an error screen: the Next.js guide's troubleshooting table says to keep the queue state visible and to include queue time when you measure how long a call takes to start. This is the pattern from the docs, with a start button and a way to leave the line:

"use client";
import { useState } from "react";
import { AvatarCall, createProxyClient } from "realtime-avatar/react";

const client = createProxyClient({ proxyUrl: "/api/realtime-avatar" });

export function TalkToGuide({ avatarId }: { avatarId: string }) {
  const [inCall, setInCall] = useState(false);

  // Mount the call only after a click, so a page load never starts one.
  if (!inCall) return <button onClick={() => setInCall(true)}>Talk to the guide</button>;

  return (
    <AvatarCall client={client} avatarId={avatarId} onEnded={() => setInCall(false)}>
      {(call) => (
        <div>
          {call.status === "waiting" ? (
            <p role="status">
              {call.queuePosition === null
                ? "Every guide is busy. Holding your place in line."
                : `You're number ${call.queuePosition} in line. Keep this page open.`}
            </p>
          ) : null}
          <button onClick={call.end}>{call.status === "waiting" ? "Leave the line" : "End call"}</button>
        </div>
      )}
    </AvatarCall>
  );
}

Two details make it feel deliberate. Handle a null position with a sentence that does not show a number. And keep a leave or end button on screen, so a person who gives up can leave the line instead of waiting it out.

That queue number comes from the platform's capacity queue. Your own plan ceiling is a refusal, not a line. If you want to say you're number 3 in line when your plan's slots are full, keep that list on your own server: it knows how many calls it has started, can hold the next person in order, and can start their call when one ends.

More than 20 at once on Realtime Avatar

Studio's 20 simultaneous calls is the largest plan with a listed price on the pricing page. Scale, the plan above it, is a contact-sales plan: credits sized to your volume, reserved warm capacity and launch support, arranged with sales, so talk to sales before a launch that needs more. Whichever plan you pick, run a load test at your expected peak with your real call length before launch day, and watch which of the three 429s you get.

Questions developers ask about concurrent avatar sessions

Tavus Starter only allows one conversation at a time. Which avatar API lets 3 people talk at once on a cheap plan?

On the pages read for this article, the lowest listed price with 3 simultaneous sessions is LemonSlice's Starter at $8 a month ($7 a month billed yearly) with 41 included minutes, then Realtime Avatar Starter at $9 with 120 included minutes. Past the included minutes, LemonSlice charges $0.22 a minute plus $0.09 for hosted speech recognition, LLM and voice, while a Realtime Avatar call is metered by the second at $0.095 a minute on Starter, with the platform's built-in voices included in that rate. Anam Explorer ($49) and Tavus Builder ($59) also allow 3. For 10 at once, Realtime Avatar Developer is $24 a month and Simli Pro $49. Talking Avatar needs no subscription and sells no concurrency plans, billing per minute instead.

Is 3 or 10 simultaneous calls enough for a Product Hunt launch?

Multiply calls started per minute by average call length. At 2 calls a minute averaging 3 minutes, you need about 6 slots on average and around 12 at peaks. Starter (3) is too small, Developer (10) covers the average, Studio (20) the peak.

Anam returns 429 when all simultaneous sessions are busy. Which APIs give a queue position?

Anam's billing and limits page says a 429 on start can reflect an organization limit, service capacity or a spend limit, and asks you to check the returned error, show the reason and avoid retrying in a tight loop. Its concurrency endpoint returns an approximate active count, the limit and an estimated wait, as an advisory snapshot rather than a reservation. Tavus's pricing FAQ says a user over the limit waits for an active conversation to end and suggests waiting states. Realtime Avatar's queue answer gives a queue size and a retry delay, and its SDK exposes your position in line.

My realtime avatar API returns 429 when starting a call. Should I retry, and how soon?

Read the body first. A queue answer comes with recommended_retry_ms, so retry after that delay. A concurrency refusal will repeat until a session ends or a pending start clears, so do not retry it blindly. A rate-limit 429 means slow down and back off.

How many people can be in calls at once on a free realtime avatar plan?

Realtime Avatar's Sandbox allows 2 concurrent calls on its 480 free credits (8 realtime minutes, once). The free tiers of Tavus, Anam, Simli and HeyGen LiveAvatar allow 1 session at a time, and LemonSlice needs a paid plan for API access. Paid plans run from 1 simultaneous session (Tavus Starter, Anam Starter) to unlimited (LiveAvatar's paid plans), as listed above.

실시간 아바타 API가 통화 시작 시 429를 반환해요. 재시도해야 하나요, 대기열인가요?

Realtime Avatar에서는 응답 본문으로 구분합니다. code가 concurrency_limit_reached이면 플랜의 동시 통화 한도(Sandbox 2, Starter 3, Developer 10, Studio 20)에 도달한 것이며 대기열 순번이 아닙니다. 시작 중이거나 연결 중인 세션도 한도에 포함되므로 세션을 종료하거나 시작 중인 요청이 정리될 때까지 기다린 뒤 다시 시도하세요. code 없이 queue_size와 recommended_retry_ms가 있으면 대기열이므로 순번을 화면에 표시하고 recommended_retry_ms 이후에 다시 요청합니다. 둘 다 없으면 API 키별 요청 한도이니 간격을 두고 재시도하세요. SDK 0.12.0 이상을 쓰면 한도 거부는 오류로, 대기열은 isQueued 결과(position, retryAfterMs)로 받습니다.

Compare and cost guides

Meet the live avatars. Hold the first conversation.

Enter the studio