Tavus review, pricing and limits

Pick Tavus when the product needs a face that talks back in real time and you want a coding agent to build and regression-test that persona in 19 tool groups without touching keys. It is the wrong tool for pre-rendered avatar videos or voice-only bots, and short calls are expensive because of the per-conversation minimum.

Tavus is a conversational video platform whose PALs (configured personas with a generated face and voice) hold real-time calls. Agents reach it two ways: a hosted Model Context Protocol server at mcp.tavus.io with 78 tools for building, wiring and testing PALs from Claude Code, Codex or Cursor, and a REST API with an x-api-key header that creates faces, voices, tools, knowledge and the conversations themselves.

Maker: Tavus · Protocol: MCP · Auth: oauth

Compatible agents: Claude Code (user-scope HTTP MCP), Codex (codex mcp add / login), Cursor and any MCP client over HTTPS, Any LLM inside the PAL (bring your own LLM supported), Your own MCP servers as PAL connectors

Required runtime: An MCP client (Claude Code, Codex, Cursor or another) for the hosted server; nothing to install, Any HTTP client for the REST API; a Daily-hosted room or a Meet, Zoom or Teams URL for the call itself, A browser for the one-time OAuth sign-in and for joining preview conversations

About Tavus

Tavus makes real-time conversational video agents: a PAL (its name for a configured persona) with a generated human face and voice that joins a WebRTC room, a Google Meet, Zoom or Teams call, listens, sees and talks back. For a human the product is the PAL Maker portal; for an agent it is two surfaces. The REST API at tavusapi.com (key in an x-api-key header) creates faces, voices, PALs, tools, connectors, knowledge documents, memory stores and the conversations themselves. The hosted MCP server at mcp.tavus.io lets a coding agent in Claude Code, Codex or Cursor do the build work: create and patch a PAL, define the tools it may call and scaffold the matching handler in your repo, attach guardrails, objectives, knowledge and capabilities, then test it in text-only chat or a full audio-video preview, in a loop, until it behaves. The vendor's point is that the PAL's tool definitions and your application's handlers drift apart when maintained by hand, and one agent working both sides keeps them in step.

There is nothing to install for the MCP route: the client connects over HTTPS and authenticates once in the browser, where the PAL Maker mints a per-user API key that the server forwards downstream, so no Tavus key ever sits in a client config. The toolset is grouped into 19 families (PAL CRUD, faces, conversations, quickstart, templates, embed scaffolding, guardrails, objectives, tools, pronunciation dictionaries, PAL tools, PAL capabilities, raw skills, knowledge documents, PAL knowledge, builder sessions, chat mode, preview and build-and-verify). MCP tools return data and file manifests rather than writing files, and the client decides what to write. A Tavus CLI covers the same resources for terminal use, and PALs themselves can delegate multi-step work to your own MCP servers through connectors during a call.

Under the conversation sit Tavus's own models: Phoenix-4 generates every pixel of the face at 1080p, Raven-1 gives the PAL perception of the participant's video, and Sparrow-1 handles turn-taking; audio is 24 kHz and the vendor lists dozens of languages. Conversations take knowledge-base documents for retrieval, persistent memory stores per participant, objectives with completion criteria, guardrails, function calling to your APIs, a bring-your-own LLM option, transcripts and optional recordings, and built-in skills such as internet search, slide presentation, a browser-use skill and the Magic Canvas for on-screen cards. On HokAI the adjacent records are tools rather than skills: HeyGen and Synthesia for generated video without the live conversation, ElevenLabs for the voice layer, Vapi and Retell AI for voice-only agents, and Daily, whose rooms host Tavus conversations by default. Among skills, Kernel and Notte are what a PAL's browser-use skill resembles, and Composio is the kind of connector a PAL can call mid-conversation.

Developer pricing combines a monthly fee with metered minutes, with a free tier that includes a small allowance of conversational and generated video minutes and access to stock faces. Conversational minutes are rounded to the nearest six seconds with a thirty-second minimum per conversation, recordings are metered separately, custom face training has a monthly quota and a flat overage fee, and concurrency is capped per plan until Enterprise. Separate consumer plans with MCP early access exist for people who want to talk to a PAL rather than build one.

The docs publish an llms.txt, an MCP tools reference, a CLI guide and an agentic build-and-verify recipe, which is more agent tooling than most video vendors offer. If you are choosing between a video agent, a voice agent and an avatar generator for a product, Smart Match will separate them in five questions.

Key Features

• Hosted MCP server for the build loop: Coding agents create and patch PALs, define tools, scaffold handlers and run chat or video previews over mcp.tavus.io with browser OAuth and no keys in config.
• Full-face generation at 1080p: Phoenix-4 renders every pixel of the face; Raven-1 lets the PAL see the participant and Sparrow-1 decides when to speak.
• Objectives, guardrails and tools: Completion criteria, branching guardrails and function calls to your APIs are first-class resources attachable to any PAL.
• Knowledge and memory: Documents (PDF, CSV, PPTX, images, crawled sites) feed retrieval, and per-participant memory stores persist across conversations.
• Joins Meet, Zoom and Teams: A conversation can be created with a meeting_url so the PAL dials into an existing call instead of a Tavus room.
• Built-in skills: Internet search, slide presentation, browser use and the Magic Canvas can be attached to a PAL as capabilities.
• Model-agnostic language layer: Bring your own LLM, 24 kHz audio and a multilingual voice layer, per the pricing page.

Use Cases

• Build and verify a support PAL from an editor: Call tavus_pal_build_and_verify with one creator prompt; the server drafts the PAL, asks follow-ups, publishes it and runs chat-mode checks, returning a preview conversation URL.
• Wire a tool call end to end: tavus_tool_create defines a lookup tool, tavus_pal_tools_attach puts it on the PAL, tavus_scaffold_embed and the returned manifest give the handler and embed code the agent writes into the repo.
• Interview or sales-call agent that joins a meeting: POST /v2/conversations with pal_id, a meeting_url for Meet, Zoom or Teams, an objectives_id and document_tags so the PAL arrives briefed and scored.
• Regression-test a PAL in text: tavus_chat_start, a scripted series of tavus_chat_turn calls and tavus_chat_end exercise objectives and guardrails without spending video minutes.

Install

claude mcp add -s user --transport http tavus https://mcp.tavus.io/mcp

Requirements

• A Tavus account (platform.tavus.io, free plan available); the MCP server mints its own per-user API key during the browser OAuth flow
• Never place a Tavus API key or shared bearer token in an MCP client config; the hosted server keeps keys user-scoped
• For REST calls: an API key generated in the PAL Maker, sent as x-api-key
• A valid face_id (stock or custom) for any conversation that is not audio-only

Actions

Quickstart

One-shot recipe: creates a PAL from a system prompt, picks a stock face when none is given, and starts a conversation.

tavus_quickstart(system_prompt="You are a patient onboarding guide for a payroll app. Keep answers under two sentences.", pal_name="Payroll Guide")

• system_prompt (string) — required: The PAL's instructions.
• pal_name (string): Display name.
• face_id (string): Face to render; a stock face is chosen when omitted.

Create PAL

Creates a PAL and configures how it behaves in every conversation that uses it: prompt, face, pipeline mode, greeting, context, layers, memories and objectives.

tavus_pal_create(pal_name="Interviewer", system_prompt="Run a 20-minute structured interview for a junior analyst role.", default_face_id="rfe12d8b9597", pipeline_mode="full", greeting="Hi, thanks for joining. Shall we start?")

• system_prompt (string): Behavioural instructions.
• pal_name (string): Name shown in the portal.
• default_face_id (string): Face used unless a conversation overrides it.
• pipeline_mode (string): Which Tavus layers run; full is the default.
• greeting (string): Opening line.
• context (string): Background the PAL can draw on.
• layers (object): Perception, STT, LLM, TTS and MCP connector configuration.
• memories (object): Memory settings.
• objectives_id (string): Objective set to apply.

PAL from Template

Creates a PAL from a built-in prompt template such as customer-support or interview, with business context filled in.

tavus_pal_from_template(template="customer-support", pal_name="Acme Support", business_context="Acme sells smart thermostats; warranty is two years.")

• template (string) — required: Built-in template name.
• pal_name (string): Name for the new PAL.
• business_context (string): Facts the template weaves in.
• default_face_id (string): Face to use.
• layers (object): Layer overrides.

Patch PAL

Applies JSON Patch operations to a PAL; inline tool writes are steered to the create-and-attach flow.

tavus_patch_pal(pal_id="p4c1f2", ops=[{"op": "replace", "path": "/greeting", "value": "Welcome back. Where did we leave off?"}])

• pal_id (string) — required: PAL to change.
• ops (array) — required: RFC 6902 operations.

Describe PAL Options

Returns one PAL plus the account's guardrails, objectives, documents, tools and voices that could be attached to it.

tavus_describe_pal_options(pal_id="p4c1f2")

• pal_id (string) — required: PAL to describe.

List Faces

Lists faces, optionally only the stock library.

tavus_face_list(limit=25, stock=True)

• limit (number): Faces per page.
• stock (boolean): Only system stock faces.

Create Conversation (REST)

Starts a real-time video conversation with a PAL and face, in a Tavus-hosted room or by joining a Meet, Zoom or Teams URL.

curl -X POST https://tavusapi.com/v2/conversations \
  -H "x-api-key: $TAVUS_API_KEY" -H "Content-Type: application/json" \
  -d '{
    "pal_id": "p4c1f2",
    "face_id": "rfe12d8b9597",
    "conversation_name": "Analyst interview, Tan",
    "conversational_context": "Candidate applied for the Singapore analyst role.",
    "document_tags": ["interview-rubric"],
    "callback_url": "https://hooks.example.com/tavus",
    "properties": {"max_call_duration": 1500, "enable_recording": false}
  }'

• pal_id (string): PAL that drives the call.
• face_id (string): Face to render; required directly or via the PAL unless audio_only.
• audio_only (boolean): Voice-only conversation.
• conversation_name (string): Label for the call.
• conversational_context (string): Appended to the PAL's context for this call.
• custom_greeting (string): Spoken verbatim when the participant joins.
• dynamic_greeting (boolean): Generate a greeting instead of the PAL default.
• participant_tags (array): Zero or one stable tag that selects the participant's memory store.
• document_ids (array): Knowledge documents available during the call.
• document_tags (array): Knowledge documents selected by tag.
• document_retrieval_strategy (string): speed, quality or balanced.
• objectives_id (string): Objective set for this call only.
• callback_url (string): Receives webhooks about conversation state.
• meeting_url (string): Google Meet, Zoom or Teams link the PAL joins instead of a Tavus room.
• require_auth (boolean): Private room; a meeting_token is returned.
• max_participants (number): Room capacity, at least 2 including the PAL.
• policy (string): eu applies EU AI Act defaults.
• test_mode (boolean): Create the room without the PAL joining; no cost.
• properties (object): Call options such as duration limits and recording.

Create Conversation (MCP)

Creates a conversation from the coding agent with an optional PAL and face, returning the id and join URL.

tavus_conversation_create(pal_id="p4c1f2", conversation_name="smoke test 3")

• pal_id (string): PAL to use.
• face_id (string): Face override.
• conversation_name (string): Label.

End Conversation

Ends a running conversation by id.

tavus_conversation_end(conversation_id="c9a7e3")

• conversation_id (string) — required: Conversation to end.

Create Tool

Defines a standalone tool the PAL's LLM can call, with parameters, delivery, origin and resolve behaviour, then attachable to many PALs.

tavus_tool_create(name="lookup_order", description="Fetch an order by number and return its status.", parameters={"type": "object", "properties": {"order_number": {"type": "string"}}, "required": ["order_number"]}, origin="llm", on_resolve="fire_and_forget")

• name (string) — required: Function name.
• description (string) — required: When the LLM should call it.
• parameters (object): JSON Schema of arguments.
• delivery (object): How the call reaches your app.
• origin (string): llm, or a vision or audio trigger.
• on_call (string): What the PAL says when the call fires.
• on_resolve (string): fire_and_forget or wait for the result.
• static_filler (string): Filler line while waiting.

Attach Tools to PAL

Attaches existing tools to a PAL (up to 50); vision or audio tools switch on perception.

tavus_pal_tools_attach(pal_id="p4c1f2", tool_ids=["t81b", "t82c"])

• pal_id (string) — required: Target PAL.
• tool_ids (array) — required: Tools to attach.

Create Guardrail

Creates a flat guardrail with a prompt, modality and optional callback or tool call when it triggers.

tavus_guardrail_create(guardrail_name="no_pricing_promises", guardrail_prompt="Never quote a discount; refer pricing questions to a human.", modality="verbal", tags=["sales"])

• guardrail_name (string) — required: Name.
• guardrail_prompt (string) — required: The rule.
• modality (string): verbal or visual.
• callback_url (string): Webhook on trigger.
• tool_call (object): Tool to fire on trigger.
• app_message (boolean): Emit an app message on trigger.
• tags (array): Labels.

Create Objective Set

Creates an objective set whose items carry a name, prompt and optional confirmation criteria, validated for cycles and a single root.

tavus_objective_create(name="intake", data=[{"objective_name": "collect_email", "objective_prompt": "Get and confirm the caller's email."}, {"objective_name": "book_slot", "objective_prompt": "Offer two slots and confirm one."}])

• data (array) — required: Objective items.
• name (string): Set name.
• allow_loops (boolean): Permit cycles.

Create Knowledge Document

Registers a URL (optionally crawled) as a Knowledge document for retrieval during conversations.

tavus_document_create(document_url="https://example.com/help", document_name="Help centre", tags=["support"], crawl={"max_pages": 50})

• document_url (string) — required: Source URL.
• document_name (string): Display name.
• tags (array): Tags for selection.
• participant_tags (array): Scope to participants.
• crawl (object): Crawl settings for a site.
• custom_description (string): Retrieval hint.
• is_customer_support_document (boolean): Support-doc handling.

Add Knowledge to PAL

Attaches Knowledge documents or document tags to a PAL.

tavus_pal_knowledge_add(pal_id="p4c1f2", document_tags=["support"])

• pal_id (string) — required: Target PAL.
• document_ids (array): Documents by id.
• document_tags (array): Documents by tag.

Attach PAL Capability

Attaches one of the five PAL Maker capabilities (Magic Canvas, Slide Presenter, Web Search, Perception, Memory) with its configuration.

tavus_pal_capability_attach(pal_id="p4c1f2", capability_id="web_search")

• pal_id (string) — required: Target PAL.
• capability_id (string) — required: Capability to attach.
• config (object): Capability settings.
• document_ids (array): For Slide Presenter.
• prompt (string): Capability prompt.

Scaffold Embed

Returns starter files for embedding a conversation URL as an iframe or component.

tavus_scaffold_embed(conversation_url="https://tavus.daily.co/c9a7e3", target="react", component_name="SupportCall")

• conversation_url (string) — required: Join URL to embed.
• target (string): iframe or a component framework.
• component_name (string): Component name.

Builder Chat

Sends a turn to a builder session that drafts the PAL conversationally and reports when a draft is ready.

b = tavus_builder_create(name="concierge draft")
tavus_builder_chat(builder_id=b["builder_id"], message="A hotel concierge PAL that speaks English and Mandarin and never books rooms itself.")

• builder_id (string) — required: Session from tavus_builder_create.
• message (string) — required: Your instruction or feedback.

Publish Builder

Publishes the PAL drafted in a builder session.

tavus_builder_publish(builder_id="b7d2")

• builder_id (string) — required: Session to publish.

Chat Start

Starts a text-only conversation with a PAL for testing, without video.

tavus_chat_start(pal_id="p7e0a9", custom_greeting="Testing, go ahead.")

• pal_id (string) — required: PAL under test.
• custom_greeting (string): Opening line override.
• conversation_name (string): Label.

Chat Turn

Sends one typed user turn and waits for the PAL's reply.

tavus_chat_turn(conversation_id="c9a7e3", text="I want a refund for order 4471.", timeout_s=20.0)

• conversation_id (string) — required: Chat conversation.
• text (string) — required: User message.
• timeout_s (number): Seconds to wait for the reply.

PAL Preview

Starts a full audio-video preview conversation against a PAL and returns the join details.

tavus_pal_preview(pal_id="p2b55c")

• pal_id (string) — required: PAL to preview.
• face_id (string): Render a different face for the preview.
• conversation_name (string): Preview label.

Build and Verify

Builds a PAL from one creator prompt, answers builder follow-ups, publishes it and verifies it over several rounds.

tavus_pal_build_and_verify(prompt="A warm front-desk PAL for a dental clinic that books, reschedules and answers insurance questions.", max_rounds=4)

• prompt (string) — required: Creator prompt.
• face_id (string): Face to use.
• max_rounds (number): Build-test iterations.
• answers (object): Pre-supplied answers to builder questions.

List Resources

Lists account resources of one kind: guardrails, objectives, documents, voices, skills or tools.

tavus_resource_list(resource="voices", limit=25)

• resource (string) — required: Resource kind.
• limit (number): Items per page.

How to Invoke

Hosted MCP server at https://mcp.tavus.io/mcp (browser OAuth; registered in Claude Code as a user-scope HTTP server or in Codex with codex mcp add) exposing 78 tools in 19 groups; the REST API at https://tavusapi.com/v2 with an x-api-key header; the Tavus CLI; and MCP connectors a PAL calls during a conversation.

Pricing

Developer plans are a monthly access fee plus pay-as-you-go (tavus.io/pricing, read 11 October 2026). Free: $0, whitelabeled APIs, 25 minutes of conversational video and 5 minutes of video generation a month, 25 stock faces, 1 concurrent stream. Starter: $59 a month, 100 conversational minutes and 10 generation minutes, 3 custom face trainings, 3 concurrent streams, overage $0.37 a minute for conversation, $1 a minute for generation, $65 per extra face. Growth: $397 a month, 1,250 conversational minutes and 100 generation minutes, 7 trainings, 100-plus stock faces, recordings at $0.03 a minute, 10 concurrent streams, overage $0.32 and $0.90 a minute, $40 per extra face. Enterprise: custom concurrency, scaling discounts, security and compliance. Conversational minutes round to six seconds with a 30-second minimum per conversation. Consumer plans ($0, $20 and $50 a month for 15, 150 and 500 call minutes) carry MCP early access for talking to a PAL, not for building one.

Strengths

• Agent tooling is unusually complete: an MCP tools reference, a CLI, llms.txt and a documented build-and-verify loop.
• test_mode creates a conversation without the PAL joining, so creation flows can be exercised at no cost.
• Per-user keys minted during OAuth keep Tavus credentials out of every MCP client config.

Weaknesses

• Every conversation carries a half-minute minimum charge and minutes round to six seconds, so many short test calls add up.
• Concurrency is capped at 1, 3 and 10 streams below Enterprise, which limits load testing on self-serve plans.
• Custom face training beyond the monthly quota is a flat per-face fee, and recordings are metered on top of minutes.

View the official Tavus skill page