LiveAvatar — a real-time avatar API from HeyGen that streams a talking 1080p face into your product over WebRTC

• LiveAvatar

  This page

  PricingRoughly even

  • Credit-metered by the minute, with the rate falling as volume grows and a published floor reserved for the enterprise tier
  • The free tier is real API access rather than a sandbox-only trial, but it holds concurrency to a single session, caps sessions at a couple of minutes and watermarks the stream
  • The entry paid tier is the interesting one: concurrency becomes unlimited and session length jumps, while custom avatars arrive at reduced resolution
  • Custom avatar resolution, watermark removal and session length are what separate the mid and upper tiers rather than concurrency
  • Avatar Only sessions meter at roughly half the credit rate of full-stack sessions, which is the single biggest lever on cost

• HeyGen

  PricingRoughly even

  • Credit-metered by the minute of generated output, sold as separate subscriptions from the realtime product
  • Because output is a rendered file rather than a live session, cost tracks finished minutes rather than time spent with a user
  • Credits are not transferable between it and its realtime sibling, so budgeting is per product
  • A no-code studio sits on the same plans, which is where most of its volume comes from

• Tavus

  PricingRoughly even

  • Per-minute metering across tiers, with conversational minutes and generative video minutes separated on the same plans
  • Concurrency is the thing tiers are organised around, so a session cap is part of the commercial model rather than a technical footnote
  • A free allowance exists for evaluation and is sized in minutes rather than tokens
  • Higher tiers exist mainly to buy minutes and concurrent sessions rather than new capability

• D-ID

  PricingRoughly even

  • Minute-based plans where a rendered video deducts from the same balance as a live agent session
  • Billing rounds a job up to a fixed interval, so a short piece is charged at the nearest block rather than exactly
  • Unused minutes expire at renewal rather than rolling over
  • Watermarking is used on the trial and lower tiers as an upgrade lever rather than only as an anti-abuse measure

1. LiveAvatar — official site
2. LiveAvatar — plans and per-minute rates
3. LiveAvatar — developer documentation
4. LiveAvatar — full-stack mode overview
5. LiveAvatar — sandbox mode
6. LiveAvatar — how it differs from HeyGen
7. LiveAvatar — agent skills repository
8. HeyGen — terms of service
9. HeyGen — privacy policy
10. Tavus — official site
11. D-ID — official site

Free tier

Yes

Pricing summary

Pricing is metered by the minute of avatar conversation, which is the right unit for this product because nothing is rendered ahead of time. The structure is worth understanding before the tiers, because the two integration modes bill at different rates: a session where LiveAvatar runs the whole speech pipeline costs roughly twice as much per minute as one where you supply your own speech-to-text, language model and text-to-speech. Choosing Avatar Only is therefore the largest cost decision on the page, and it is a technical decision rather than a commercial one. The free tier is genuine API access rather than a locked demo, but it enforces the constraints most likely to matter in production: a single concurrent session, a session length of a couple of minutes, and a watermark on the stream. That combination makes it useful for an integration you are building and unsuitable for anything a customer sees. The first paid tier changes the shape of the product rather than the volume — concurrency becomes unlimited, sessions get substantially longer, and custom avatars arrive at reduced resolution. Higher tiers then add resolution on custom avatars, remove the watermark, extend the maximum session length, and add the enterprise trappings: dedicated capacity, an SLA, single sign-on with administrative controls and audit logs, and avatar fine-tuning. The published per-minute rate falls at each step and reaches its floor on the enterprise tier, and the vendor states that adding concurrent sessions at that point is charged at that floor rate. Confirming current rates matters more than usual here because the per-minute figure is the product, and it moves — the plans page carries the live numbers.

Reviewed on 24 September 2026 · LiveAvatar — plans and per-minute rates

• A face that answers in the same turn

  The avatar streams over WebRTC with natural lip-sync, expression and gesture, and the vendor publishes a sub-300-millisecond median time to first frame. That number is the whole point of the product: a talking face that lags behind the voice reads as broken regardless of how good the rendering is, which is why this is a streaming latency problem before it is a graphics problem. Half-body and full-body framing are both available at professional resolution.

• Three ways in, with very different floors

  An embed endpoint returns a ready-to-use iframe, a JavaScript SDK mounts the stream in your own interface with interruption handling and reconnection built in, and the API underneath covers token minting and session lifecycle. The spread matters because it lets the same platform serve an afternoon evaluation and a production integration, and because the embed path is the reason a non-developer can get something on a page before any architecture is chosen.

• Full stack or bring your own

  One mode has LiveAvatar manage voice activity detection, speech-to-text, the language model, text-to-speech and the realtime transport. The other hands you the avatar and the streaming layer and expects you to supply the conversational stack. The trade is roughly a factor of two on the per-minute rate, which makes this the most consequential configuration choice on the platform, and it is a technical decision about who owns the pipeline rather than a feature comparison.

• Your own models, voices and transport

  Any OpenAI-compatible model or your own inference endpoint can sit behind the avatar, voices can come from the major speech providers, and the video layer can be connected through LiveKit or Agora if you already run WebRTC. For teams that have invested in a pipeline, this is the difference between adopting an avatar and rebuilding around a platform.

• Avatars from one image or two minutes of footage

  Alongside a large preset library, a custom avatar can be cloned from a single image or a short recording, then streamed to any number of simultaneous users. That collapse in production cost is what made custom avatars reachable for products that are not studios, and it is also why the consent question becomes an operational obligation rather than a legal footnote.

• Persona primitives that survive the session

  Voices, contexts and memory are modelled as reusable objects rather than set per call, and voice agents bundle them into a persona the avatar can be pointed at. The practical effect is that behaviour can be authored, versioned and reused across sessions instead of re-specified on every connection — the part of an avatar product that is usually left as glue code.

• Sandbox mode

  Integrations can be built and debugged without consuming credits, which matters more here than on a render-based product because the failure modes live in the middle of a live session. It changes the economics of getting it working, and it means the first real test against a customer does not have to be the first successful test at all.

• Setup handed to a coding agent

  The vendor publishes agent skills so a coding assistant can pick an integration mode, build it and troubleshoot symptoms like a silent avatar or garbled audio. For an API-first product this is a distribution decision as much as a convenience: it means the recommended path is the one a team already uses to write code, rather than a docs tree someone has to read first.

1. 1

   Prove it with the embed before you architect anything

   A backend call returns a ready-made iframe that can be pasted into a page, which is the cheapest way to find out whether the latency, the voice and the mannerisms are good enough for your product. Deciding that after building a custom front end is the expensive version of the same test. Sandbox mode covers this without spending credits, so there is no reason to skip it.

2. 2

   Mint session tokens on the backend, never in the client

   Session creation is authenticated with an API key, so the token is generated server-side and only the session credential reaches the browser. This is the same shape as any short-lived-credential pattern, and getting it backwards means shipping your key to users. The documentation is explicit about the backend/frontend split, and it is the one architectural mistake that is genuinely hard to walk back after launch.

3. 3

   Choose full-stack or bring-your-own by who owns the pipeline

   The two modes differ by roughly a factor of two per minute, which tempts teams into the cheaper one for the wrong reason. The real question is whether you already run speech-to-text, a model and text-to-speech you trust, and whether you want to be responsible for their latency and failure modes in a live conversation. If you do not, paying the full-stack rate is not a premium, it is the cost of not building a pipeline. If you do, you are paying twice for something you own.

4. 4

   Design for interruption, not just for answers

   A conversation is not a queue of responses: users talk over the avatar, change their minds mid-sentence and go quiet. Interruption handling, listen and idle states, and push-to-talk are the controls that make a session feel like a person rather than a player, and they are configuration you have to reach for deliberately. The SDK covers reconnection, but turn-taking quality is a product decision the platform cannot make for you.

5. 5

   Treat session length and concurrency as product decisions

   Session ceilings and concurrency are tier settings, so they define what your product can do before they define what it costs. A short free-tier session is fine for a demo and unusable for a tutoring session, and a single concurrent session means the second user waits. Decide the intended interaction length first, then pick the tier that supports it, rather than discovering the cap in production.

6. 6

   Get consent for the likeness before you clone it

   A custom avatar is someone’s face reproduced at scale, and a photo or two minutes of footage is enough to make one. The vendor frames custom avatars as consented likeness, and the obligation to hold that consent is the operator’s. Treat the release as part of the asset pipeline: without it, the avatar is not shippable, and with it, the question never comes up later.

• Developers bolting a face onto an existing agent

  The clearest fit: there is already a language model and a conversation worth having, and the missing piece is presence. Bringing your own model and voice means the avatar can be added to a pipeline that works instead of replacing it, and the higher per-minute tier is avoided by keeping the stack you built.

• Product teams shipping high-stakes conversations

  Onboarding, sales qualification, support triage and any flow where hesitation costs a conversion. A face that listens, pauses and responds changes how much a user is willing to say, which is the part a text box cannot replicate. Unlimited concurrency on the first paid tier means the product does not have to ration who gets the experience.

• Education and training products built on practice

  Language tutoring, interview rehearsal, sales role-play and assessment simulations all need a counterpart who responds in real time. A cloned presenter can be given a persona and reused across learners without a studio, and sessions can be authored once and rolled out at scale.

• Enterprise teams with procurement and compliance in the way

  The upper tier exists for exactly this: dedicated capacity, an availability commitment, single sign-on with administrative controls, audit logs and avatar fine-tuning, plus an enterprise floor on the per-minute rate. Being able to put those on a security questionnaire is often the difference between a pilot and a rollout.

• Teams who need the conversation to be someone else’s platform

  For products whose value is the conversation rather than the supporting infrastructure, letting the platform own speech-to-text, the model, text-to-speech and the realtime transport removes weeks of work that is not the product. It is the honest reason to pay the full-stack rate.

It streams rather than renders, so there is no artifact

Output is generated on the fly and delivered as a realtime stream with no batch step and no queued render. The consequence is more than a latency benefit: there is no video file produced by a session, which means no recording to review, moderate, reuse or store unless you build that capture yourself. For a support or training deployment that is a privacy advantage and an operations gap at the same time.

Free access is real, but watermarked and capped

The free tier includes the full API, the preset library and integration access rather than being a locked demo, which is unusually generous for an API product. It also enforces a single concurrent session, a session length measured in a couple of minutes and a watermark on the stream. The caps, not the watermark, are what make it a development tier: concurrency and session length are the two variables a realtime product cannot fake.

Custom avatars are resolution-gated and consent-gated

A custom avatar can be cloned from a single image or a short piece of footage, but resolution and availability track the tier: reduced-resolution custom avatars on the entry paid plan, full resolution further up, alongside a watermark that persists until the mid tier. The vendor frames these as avatars of a consented likeness, and holding that consent is the operator’s responsibility rather than something the platform enforces for you.

It sits inside a larger publisher, not beside it

The platform is operated by HeyGen and shares a login with its video product, but the workspace, avatars, credits and billing are separate and credits do not transfer between them. That distinction is worth internalising before planning a budget, because it is the single most common misunderstanding about the product and the publisher maintains a page explaining it.

Latency, uptime and concurrency are vendor-stated figures

The published latency, availability and concurrency numbers are measured on the vendor’s own infrastructure and are not independently audited here. They are the right claims to test against the sandbox and the embed before committing, because realtime quality depends on the user’s network and geography as much as on the platform, and a median figure says nothing about the tail.

What it does not do

It does not produce a video file, so it cannot feed an editing timeline, a scheduled post or a library of finished content. It does not offer a no-code studio for scripted video. It does not run on-device or offline, because rendering is a hosted service. It ships no analytics, review or moderation workflow for finished sessions, and no channel management — anything a teammate needs to see after the conversation is something you capture and build. And it does not decide how the conversation should go; the platform provides the face, the voice and the transport, not the judgement.