Search for “pixverse lip sync” and you get the official API manual at the top, then a wall of product pages and aggregator model cards. What none of them say together is the part that decides your integration: the API takes a video plus exactly one audio source, the audio source is a choice between an uploaded track and a text-to-speech script, and that choice changes the field names, the limits, and the billing rule. Get that contract wrong and you spend a debugging cycle on error 400017 before your first synced clip.
This guide walks the complete PixVerse lip sync API integration: what the endpoint accepts, the audio_url vs speaker_id+tts_content decision, credits-based pricing with units matched, a working request, and the failure modes that cost credits. All contract and pricing facts were read from PixVerse’s official platform documentation on August 3, 2026. Modellix is an API aggregator with a commercial interest in this topic; the official PixVerse Platform path is described as the neutral baseline, and the Modellix route is shown as one of several integration options — not as a claim that the aggregator is cheaper.
What the PixVerse lip sync API takes as input
PixVerse’s lip sync capability is exposed as a Speech (LipSync) task: the model analyzes the audio and the speaker’s mouth movements in the input video and re-renders the lips so they match the audio precisely. The official endpoint is https://app-api.pixverse.ai/openapi/v2/video/lip_sync/generate, and the official Speech (Lip Sync) documentation is the authoritative contract used in this article.
Two inputs are required, with documented limits (per the Speech (LipSync) guide):
| Input | Accepted forms | Official limits (as of August 3, 2026) |
|---|---|---|
| Video | A video_id previously generated through the PixVerse API, or an uploaded video (mp4, mov, webm) |
Max resolution 1920, max file size 100 MB, max duration 60 seconds |
| Audio | An uploaded audio file, or a TTS script with a built-in/custom voice | Audio file mp3/wav/m4a/aac, max 100 MB, max 60 seconds; TTS script up to 200 characters |
Note: the separate Upload Video/Audio reference page lists larger per-feature limits for its upload endpoint (up to 250 MB / 300 seconds for lip sync in its feature table). The Speech (LipSync) guide’s 100 MB / 60 second contract is used throughout this article because it is the authoritative reference for the generation request; if you hit the upload limits, confirm which contract your account’s endpoint enforces.
The API reference is at SpeechLipsync Generation, and media uploads (video or audio) go through the Upload Video/Audio operation, which returns a media_id. Authentication needs a valid API key plus a unique Ai-Trace-Id per request; the official docs call a reused trace ID the most common cause of jobs stuck in “Generating” status. For the wider PixVerse endpoint and authentication surface, our PixVerse API overview walks the full request lifecycle.
That is the whole surface: one endpoint, two inputs, one of them with two variants. The part integrations get wrong is the second input — an audio track and a TTS script are not interchangeable fields, even though both live inside the same request.
audio_url vs speaker_id + tts_content: the two audio paths
PixVerse’s own documentation expresses the choice as audio_media_id (a finished audio file you uploaded) or lip_sync_tts_speaker_id + lip_sync_tts_content (a TTS script). Aggregator routes expose the same decision under their own field names — Modellix’s route uses audio_url vs speaker_id + tts_content. Either way, the rule is the same: use exactly one of the two, never both and never neither.
| Path | Fields | What happens | When to use it |
|---|---|---|---|
| Uploaded audio | audio_url (Modellix) / audio_media_id (official) |
The model drives lip movement against your finished track; no TTS is performed | You already have the exact voiceover, voice actor, or licensed track |
| TTS script | speaker_id + tts_content (Modellix) / lip_sync_tts_speaker_id + lip_sync_tts_content (official) |
The API synthesizes speech from your script using the selected voice, then syncs the lips | You have a script and want generated speech without an external TTS pipeline |
The official docs state the constraint explicitly: if neither audio field is provided the endpoint returns a missing-voice-source error; if both are provided it returns a conflict error. On Modellix’s pixverse/lipsync model page the same rule appears in the parameter descriptions — audio_url is “mutually exclusive with speaker_id/tts_content”, and speaker_id is “mutually exclusive with audio_url”.
A related gotcha lives in the official custom-voice flow. POST /openapi/v2/video/tts_speaker creates a custom voice by passing a sample audio’s media_id as audio_media_id — but in the generation request, audio_media_id means the finished track that drives lip movement. Same field name, different meaning per endpoint. The official docs warn against passing the sample media ID into the Avatar/lip-sync generation request as if it were the finished audio.
PixVerse lip sync API pricing, with units matched
Pricing is the place where search results actively mislead, because every page quotes a different unit. PixVerse Platform bills lip sync in credits; aggregators bill in dollars per second or per credit. Here is each source with its unit made explicit, all read on August 3, 2026:
| Route | Stated price | Unit | Source |
|---|---|---|---|
| PixVerse Platform — lip sync | 4 credits | per second of audio (round up), or per 15 bytes of TTS text after UTF-8 encoding | Official pricing page |
| PixVerse Platform — Image Avatar (separate capability) | 3 / 6 / 9 / 12 credits | per second at 360p / 540p / 720p / 1080p (external audio or per 15 bytes of TTS text) | Same official pricing page |
Replicate pixverse/lipsync |
$0.04 | per second of output video | Replicate model page |
| Eachlabs PixVerse lip sync (v4.5 route) | $0.00627 | per credit | Eachlabs model page |
Modellix pixverse/lipsync |
$0.0460 | per second | Modellix model page |
PixVerse Platform’s official pricing page, captured August 3, 2026. The Lip sync rows show 4 credits per second of audio and 4 credits per 15 bytes of TTS text; the Avatar rows show 3/6/9/12 credits per second at 360p/540p/720p/1080p.
These numbers are not directly comparable, for two reasons. First, the units differ: credits are a package currency whose dollar value depends on the credit pack you bought (the official pricing page illustrates “$1 = 5 videos (v6, 720p, 5s, no audio, with Starter pack)” — a pack-dependent figure, not a flat per-second dollar rate). Second, the routes are not the same model surface: Eachlabs labels its route as PixVerse v4.5, Replicate’s card is version-agnostic, and the official docs describe the current Speech (LipSync) service. A v4.5 route and the current platform service are different things to price. Our PixVerse pricing guide keeps these unit distinctions explicit across the full API.
What you can do safely is price a concrete job on one route at a time: a 10-second talking clip on the official route consumes 10 × 4 = 40 credits under the per-second rule, and on Modellix’s route costs 10 × $0.0460 = $0.46 per second-billed output as displayed. Compare those only after converting both to the same output spec and the same billing conditions — a like-for-like comparison, not a headline.
A working PixVerse lip sync API call
The official flow has four valid input combinations; pick the one that matches your pipeline. The two most common are video_media_id + audio_media_id (you upload both) and source_video_id + lip_sync_tts_speaker_id + lip_sync_tts_content (you reuse a PixVerse-generated video and synthesize speech).
1 | # Step 1 — upload your talking-head video (mp4/mov/webm, ≤60s, ≤100MB) |
For the TTS path, replace the body’s audio field with the script and speaker:
1 | curl -X POST "https://app-api.pixverse.ai/openapi/v2/video/lip_sync/generate" \ |
The snippets above are written against the official API reference and the documented request shapes; they have not been executed against a live account. Field names and response keys follow the SpeechLipsync Generation reference.
The three stages of a PixVerse lip sync task — prepare inputs, generate, poll to completion. Illustrative workflow created for this guide; the request shapes shown above follow the official API reference.
The same decision surface exists on aggregator routes. On Modellix’s pixverse/lipsync route (linked in the pricing table above), the model takes a publicly accessible talking-video URL plus either audio_url or speaker_id + tts_content (up to 140 characters; speaker codes include emily, james, isabella, liam, chloe, adrian, harper, ava, sophia, julia, mason, jack, oliver, ethan, or auto), billed per second of output. Check the live model page for the current field list and price before integrating.
Status codes, errors, and the two failure modes that cost credits
After submission you poll the Get Video Generation Status API with the returned video_id. The official status contract: 1 = generation succeeded (the url field holds the video), 5 = waiting for generation, 7 = content moderation failure, 8 = generation failed. Poll while status is 5; stop and handle 7 and 8 instead of polling forever.
Two failure modes matter financially:
- Status 7 (content moderation failure) — the official docs say credits used for filtered videos are automatically refunded, so a moderation rejection costs time, not money. Fix the input (content, or the speaker/TTS material) and resubmit.
- Status 8 (generation failed) — the job failed; diagnose via the error surface below and fix the input before resubmitting. The official docs only promise automatic credit refunds for status 7, so treat failed generations as billable unless the platform states otherwise.
Common error codes from the official documentation:
| Code / message | Meaning | Fix |
|---|---|---|
| 400013 | Invalid binding request: incorrect parameter type or value | Check field names and types against the API reference |
| 400017 | Invalid parameter — “Either audio_media_id or lip_sync_tts_speaker_id + lip_sync_tts_content must be provided” |
You sent both audio paths or neither; pick exactly one |
| “TTS text must be within 200 characters” | TTS script exceeds the limit | Shorten the script (note: Modellix’s route documents a 140-character tts_content limit — verify per route) |
| “couldn’t find a matching video/audio media_id” | The media ID is wrong or expired | Re-upload the media and use the fresh ID |
| “Invalid media_type: not a video/audio resource” | You passed a video ID into an audio field or vice versa | Match media_type to the field |
| 500044 | Reached the limit for concurrent generations | Back off and queue; concurrency is capped |
The single most common cause of a job stuck in “Generating”, per the official troubleshooting section, is reusing the same Ai-Trace-Id across requests. Generate a unique trace ID for every API call — it is the cheapest bug to prevent in this whole integration.
Lip sync API alternatives: where PixVerse sits
If you are evaluating lip sync as a feature rather than committing to PixVerse, the relevant alternatives split into three groups:
- Direct vendor APIs. PixVerse’s Speech (LipSync) and Image Avatar paths are one option; HeyGen’s avatar and lip-sync tooling is the other name that comes up most in talking-video comparisons. Runway’s strength is creative video generation rather than lip-sync precision, so it is a weaker fit when the job is strictly re-timing speech. These are consumer-grade studios with API tiers — evaluate on your integration depth, not their landing pages.
- Model-host aggregators. Replicate hosts
pixverse/lipsyncplus community lip-sync models such askwaivgi/kling-lip-sync; Eachlabs, Runware, and Segmind also list PixVerse lip sync variants (fal.ai is a further aggregator that carries PixVerse models generally). You get a consistent HTTP surface across models in exchange for per-second or per-credit markup and version lag (Eachlabs still labels its route v4.5). - Open-source retiming (Wav2Lip family). The research lineage behind lip retiming is open source. Self-hosting gives you full control and zero per-second cost but requires GPU capacity and your own quality tuning; it only makes sense at sustained volume.
The “which one” question is mostly a pipeline question: if you already hold finished audio, any route works; if you need generated speech, the TTS path with preset speakers matters; if you need arbitrary voice cloning, that is a different capability entirely (see below). For a full side-by-side of PixVerse against the surrounding video-API ecosystem, our PixVerse alternatives guide compares the trade-offs in more depth.
What Modellix’s pixverse/lipsync is — and is not
Modellix is an API aggregator: one key, one billing account, and a REST interface over models from multiple providers, with PixVerse among them. Its pixverse/lipsync route is lip re-synchronization on an existing talking video: you supply the video plus one audio source, and the model re-times the subject’s lips to match. That is the capability this article covers, and the only PixVerse lip-sync capability Modellix exposes.
It is not several things that look similar in search results:
- Not Image Avatar. PixVerse Platform’s Image Avatar API generates a talking video from a still portrait (
img_id) plus a voice source — a photo-to-digital-human pipeline. Modellix does not carry an image-avatar route; its lipsync requires an existing video. If your use case is “turn a headshot into a presenter,” the official Avatar API is the documented path, not Modellix. - Not custom voice cloning. PixVerse Platform lets you upload a sample (under 30 seconds) and create a
speaker_idfor a cloned voice viaPOST /openapi/v2/video/tts_speaker. Modellix’s lipsync accepts a preset speaker list (emily,james, …auto) for TTS — no arbitrary clone upload. Treat voice cloning as a PixVerse Platform capability, not a Modellix one. - Not audio generation. Lip sync consumes audio as an input (a track or a TTS script); it does not generate standalone audio, and neither Modellix nor this guide claims audio-generation capability.
None of this is a claim that Modellix is the cheapest lip-sync route, or that it reproduces every PixVerse Platform feature. The honest framing: official PixVerse gives you the newest model surface, custom voices, and credit pricing; Modellix gives you the same lipsync concept behind one key alongside many other image and video models, billed per second. Which trade suits you depends on whether you need the platform extras or the unified workflow. To see the full set of PixVerse routes Modellix carries — lipsync among them — check the PixVerse provider hub.
Frequently Asked Questions
What is the PixVerse lip sync API?
It is the Speech (LipSync) service at https://app-api.pixverse.ai/openapi/v2/video/lip_sync/generate. It takes a talking-head video plus one audio source — an uploaded track or a TTS script — and re-renders the speaker’s lips to match the audio, returning a new video.
What is the difference between audio_url and speaker_id + tts_content?
audio_url (official: audio_media_id) drives lip movement from a finished audio file you supply. speaker_id + tts_content (official: lip_sync_tts_speaker_id + lip_sync_tts_content) makes the API synthesize speech from your script with a selected voice before syncing. The two are mutually exclusive — sending both or neither returns an error.
What are the PixVerse lip sync video and audio limits?
As of August 3, 2026, the official docs list: video mp4/mov/webm, max resolution 1920, max 100 MB, max 60 seconds; audio mp3/wav/m4a/aac, max 100 MB, max 60 seconds. TTS scripts must stay within 200 characters on the Speech (LipSync) endpoint (the Image Avatar documentation specifies 30–200 characters for its lip_sync_tts_content; Modellix’s route documents 140 characters for its tts_content — verify per route).
How much does PixVerse lip sync cost?
The official pricing page bills lip sync at 4 credits per second of audio (round up), or 4 credits per 15 bytes of TTS text after UTF-8 encoding; Image Avatar is 3/6/9/12 credits per second at 360p/540p/720p/1080p. Aggregators bill differently — Replicate shows $0.04/second, Modellix shows $0.0460/second as of August 3, 2026. Units do not convert directly; price a concrete job on one route at a time.
What do PixVerse lip sync status codes mean?
1 = generation succeeded, 5 = waiting for generation, 7 = content moderation failure (credits are auto-refunded), 8 = generation failed. Poll while status is 5, then stop on 7 or 8 and handle the input.
Why is my lip sync video stuck in “Generating”?
Per the official troubleshooting docs, the most common cause is reusing the same Ai-trace-id across requests. Generate a unique trace ID for every API call. If it still hangs, check the concurrency cap (error 500044).
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 (Image Avatar) and does not accept arbitrary voice-clone uploads. Those are PixVerse Platform capabilities documented on the official Avatar API page.
Can I use PixVerse lip sync through Replicate or other aggregators?
Yes — Replicate hosts pixverse/lipsync ($0.04/second as of August 3, 2026), and Eachlabs, Runware, and Segmind list PixVerse lip sync variants with their own billing units (fal.ai is another aggregator that carries PixVerse models generally). Check each route’s model version and current price; aggregator cards can lag the official model generation (for example, Eachlabs still labels its route v4.5).
PixVerse capability and pricing details reflect official documentation and model pages accessed August 3, 2026 and change frequently. Validate against the live provider documentation and billing pages before committing volume or budget. Modellix is an API aggregator for image and video models, not the PixVerse vendor; this guide is not a claim that the aggregator route is cheaper or that it accepts every official parameter.
Cover image: illustrative Modellix artwork; it is not a PixVerse product screenshot or source evidence.
