Talking Avatar API: Integration Guide, Pricing & Code

Choose a talking-avatar API by the input you have: a portrait, an existing video, or a live audio/text stream. That choice determines the request fields, delivery path, and billing unit. This guide compares those three routes, lists the Modellix endpoints that are live, and shows a documented async request. Modellix has a commercial interest in its listed routes; prices and availability are dated, not a claim that the aggregator is cheapest.

What a talking avatar API actually takes as input

The input contract is the fastest way to classify any talking avatar API, because it tells you what you must already have before you call it. Three families cover almost everything in this space:

Photo-to-video animates a portrait; Synthesia's personal avatars and D-ID's API are examples. Lip-sync retimes existing footage; Modellix currently lists PixVerse and Vidu routes for it. Real-time streaming runs a live session; Microsoft's avatar service supports interactive and batch synthesis. These inputs and delivery models are not interchangeable.

The three talking avatar API families defined by input contract: photo-to-video, video lip-sync, and real-time streaming. Illustrative Modellix artwork for this guide; the request shapes in this article follow the vendors' official API references.

Talking avatar API pricing, with units matched

Pricing is where talking avatar API comparisons go wrong, because platforms use different billing units. These figures were checked on September 24, 2026:

Sources: PixVerse Platform pricing, Kling Avatar, PixVerse Lip Sync, and Vidu Lip Sync, checked September 24, 2026.

The units still need to match before you compare. PixVerse Platform bills Lip Sync in credits, while the Modellix routes above show dollars per second. At the listed Modellix rates, a 10-second job is about $0.20 on vidu/lip-sync or $0.40 on pixverse/lipsync; a Kling Avatar clip has a displayed range because its settings change the rate. PixVerse Platform currently lists Lip Sync at 4 credits per rounded-up second, or 4 credits per 15 UTF-8 bytes of TTS text. Convert credits using the price of the plan you would actually buy, not an assumed exchange rate.

PixVerse Platform's current pricing page lists Image Avatar at 5, 10, 15, or 20 credits per second at 360p, 540p, 720p, or 1080p. Its pricing guide explains how the credit units differ from Modellix's dollar-per-second prices.

A working talking avatar API call

The photo-to-video family is the most common starting point, so here is a minimal working flow against Modellix's kling/kling-avatar route, whose documented input is a portrait image plus exactly one audio source (an audio file URL, or an audio_id from a TTS API). The snippet follows the model page's documented request shape; it has not been executed against a live account.

# Create a talking avatar video from a portrait + audio
curl -X POST "https://api.modellix.ai/api/v1/kling/kling-avatar" \
  -H "Authorization: Bearer $MODELLIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "image": "https://your-cdn.example.com/presenter.jpg",
      "sound_file": "https://your-cdn.example.com/voiceover.mp3",
      "prompt": "The presenter speaks naturally to camera with a calm expression"
    }
  }'
# → task_id; poll GET /api/v1/tasks/{task_id} until it completes

The video lip-sync family differs in one decisive way: it requires a source video, not an image. On Modellix's pixverse/lipsync route the documented contract is an existing talking-video URL plus either an audio_url or a speaker_id + tts_content pair (max 140 characters) — never both, never neither. PixVerse Platform's official Speech (LipSync) documentation expresses the same choice as audio_media_id vs lip_sync_tts_speaker_id + lip_sync_tts_content, with video up to 60 seconds and TTS scripts up to 200 characters. The sibling PixVerse lip sync API guide walks that contract field by field, including the upload limits and the exact endpoint.

# Python skeleton for a pixverse/lipsync-style request (illustrative)
import requests

r = requests.post(
    "https://api.modellix.ai/api/v1/pixverse/lipsync",
    headers={"Authorization": "Bearer <YOUR_KEY>"},
    json={
        "input": {
            "video": "https://your-cdn.example.com/speaker_clip.mp4",
            "audio_url": "https://your-cdn.example.com/voiceover.mp3",
        },
    },
)
task_id = r.json()["task_id"]   # then poll GET /api/v1/tasks/{task_id}

Every talking avatar API in this space follows the same submit-then-poll lifecycle: create a task, poll its status, fetch the result when it reaches the terminal state. The PixVerse API overview walks the full request lifecycle and authentication surface. For real-time families the request pattern is different — Azure's text to speech avatar documents a batch synthesis API and a real-time synthesis path rather than a single generate-and-poll task, so confirm the lifecycle before you build your queue around it.

Status codes and the failure modes that cost money

Asynchronous video generation fails in two financially distinct ways. Using PixVerse's official status contract as the reference (1 = success, 5 = generating, 7 = content moderation failure, 8 = generation failed): the platform's FAQ documents automatic credit refunds for generation failure, for generations that exceed two hours, and for content moderation rejection — so a status 7 rejection costs time, not credits, and a status 8 failure is also documented as refundable under the current FAQ. Refund terms change, so confirm the current policy before assuming any failed job is billable or refundable.

The input-contract errors are where most integrations waste their first day:

One more gotcha is documented repeatedly across this space: reusing the same request trace ID. PixVerse's official troubleshooting notes a reused Ai-Trace-Id as the most common cause of jobs stuck in "Generating" — generate a unique trace ID per request. Vendor docs are the reference for their own codes; Akool's Talking Avatar API documentation, for example, documents a callback-or-poll pattern with resource links valid for 7 days, which matters if you queue long-running jobs.

What Modellix's talking avatar routes are — and are not

Modellix is an API aggregator: one key and one billing account across image and video models from multiple providers. The live talking-avatar routes covered here are Kling Avatar for photo-to-video, plus PixVerse and Vidu for video lip-sync. The former Skywork avatar and lip-sync schemas return 404 on Modellix and are excluded from the comparison. Use the official SkyReels API if your integration specifically requires Skywork's video models.

It is not several things that look similar in search results:

• Not PixVerse Image Avatar. PixVerse Platform's Image Avatar API creates a talking video from a still portrait plus a voice source, billed at 5/10/15/20 credits per second by resolution. Modellix does not carry that endpoint; its pixverse/lipsync route requires existing footage. Kling Avatar is the photo-to-video route compared here.
• Not arbitrary voice cloning. PixVerse Platform lets you upload a short sample and create a custom speaker_id. Modellix's pixverse/lipsync accepts preset speaker codes for TTS — no clone upload.
• Not audio generation. Talking avatar APIs consume audio as input (a track or a TTS script); neither the vendors nor this article claim audio-generation capability.
• Not Growth Studio. PixVerse's marketing-video workspace is a separate PixVerse product, not an aggregator capability.

None of this asserts that Modellix is the cheapest talking avatar route — the unit mismatch alone makes that claim easy to fake and hard to make real. The honest framing is narrower: official vendors give you the newest model surface and their own billing; an aggregator gives you several of these routes behind one key, billed in dollars per second, alongside the rest of an image-and-video API catalog. That is a workflow argument, not a price argument.

How to choose a talking avatar API

Start with the input you can actually produce at scale, then match the family:

• You have portraits, not footage → photo-to-video. Start with the live Kling Avatar route, then compare its input limits and price at your target settings with provider platforms such as Synthesia or D-ID.
• You have recorded talking video and want to re-voice or localize it → video lip-sync. Modellix currently lists vidu/lip-sync at $0.0200 per second and pixverse/lipsync at $0.0400 per second. PixVerse also accepts a TTS path. Our PixVerse alternatives guide compares the surrounding video-API ecosystem.
• You need a live conversational avatar → real-time streaming. This is a different architecture (HeyGen's live avatar line and Azure's real-time synthesis); evaluate latency and session billing, not per-second video pricing.
• You want several of these behind one integration → an aggregator route makes sense as a workflow choice: one key, one bill, consistent submit-poll semantics. It is not automatically cheaper per unit — verify the specific model and output spec.

Before automating, test one representative clip on the exact route. Check its required inputs, output quality, limits, and live price, then set a cost ceiling for retries.

Frequently Asked Questions

What is a talking avatar API?

A talking avatar API turns a voice source into video of a person speaking: it can animate a portrait photo (photo-to-video), re-sync the lips of an existing video to new audio (video lip-sync), or drive a live conversational avatar in real time. The three families have different input fields, limits, and billing units.

What is the difference between a talking avatar API and lip-sync?

Lip-sync is one of the three families. A talking avatar API is the general category; photo-to-video APIs create new talking videos from images, while video lip-sync APIs only re-time the mouth of footage you already have. Choosing the wrong one means supplying the wrong input (an image instead of a video, or vice versa).

How much does a talking avatar API cost?

The Modellix routes listed here show $0.0200/sec for Vidu Lip Sync, $0.0400/sec for PixVerse Lip Sync, and $0.0448–$0.0896/sec for Kling Avatar. PixVerse Platform quotes credits instead: 4 credits per rounded-up second for Lip Sync and 5–20 credits per second for Image Avatar, depending on resolution. Convert credits using the plan you would buy before comparing dollar cost.

What inputs do I need for a photo-to-video talking avatar API?

A portrait image plus exactly one voice source, either an audio file or a TTS script with a selected voice. Kling Avatar accepts a 2–300-second audio source; see its live schema for image formats and size limits.

Can I use a talking avatar API with just text?

Yes — through the TTS path. Both photo-to-video and lip-sync families accept a script plus a speaker ID and synthesize the speech before animating. Modellix's pixverse/lipsync caps the script at 140 characters; PixVerse Platform's Speech (LipSync) documents 200. If you need arbitrary voice cloning rather than preset voices, that is a separate capability on the vendor platform.

Which talking avatar API is the cheapest?

Among the live Modellix lip-sync routes compared here, Vidu currently has the lower listed price at $0.0200 per second; PixVerse lists $0.0400. That price comparison does not measure output quality or retry rate, so test the same clip and audio on the route you plan to ship.

Does Modellix support PixVerse Image Avatar or voice cloning?

No. Modellix's pixverse/lipsync requires an existing talking video plus audio_url or speaker_id+tts_content; it does not generate a talking video from a photo (that is PixVerse Platform's Image Avatar API) and does not accept arbitrary voice-clone uploads.