Xmax X2.0 is a real-time video transformation and interactive generation model from Xmax that operates on a live camera or uploaded video stream over WebRTC — transforming it frame by frame as it plays, instead of rendering a finished clip from a text prompt and making you wait.
Xmax X2.0 is a real-time video transformation and interactive generation model built by Xmax. Instead of generating a video clip from a text prompt and waiting for it to render, X2.0 operates on a live video stream — from a browser camera or an uploaded video — and transforms it as it plays, with output delivered over WebRTC to a standard video element. That real-time, streaming design is what separates X2.0 from most video generation models, which are batch-based and produce a finished file after a processing delay.
X2.0 is accessed through Xmax's developer platform at platform.xmax.ai, where teams integrate it via API and SDK to build their own real-time video experiences. This page is an independent, factual explainer of the model and is not official Xmax documentation.
X2.0 isn't six different models — it's one underlying model exposed through six modes, each a preset combination of prompt and reference image tuned for a specific transformation:
Because all six run on the same X2.0 model, switching modes is a matter of changing which prompt and reference-image preset is sent — not switching infrastructure. Each mode carries a preset prompt and a reference-image expectation: CharX, ClothX, VibeX, and DimX each take a single reference image (a character, an outfit, a style, or a creature), while MoX needs no reference at all.
If you have seen these capabilities under consumer-facing names, they map directly to LiveGen's product modes: CharX is real-time face swap, ClothX is AI outfit swap, VibeX is style morph, MoX is bring photos to life, DimX is summon, and Free is freestyle prompting.
X2.0's pipeline is built around low-latency streaming rather than file upload and download:
getUserMedia, or a video file converted into a publishable stream<video> elementWith the JavaScript SDK, the flow is compact. You create the client, select the realtime model, request media, then call connect() to establish the session, join RTC, publish the input stream, and bind the output element. Generation begins only when you call set() with a prompt, a reference image, or both, and you close the session with disconnect(). A typical camera session looks like this:
x2.0 model.getUserMedia.connect() with the stream, the model, the output element, and an optional size.set() with your prompt and/or reference image to start generation.disconnect() when you're done to release the session and media.This is why X2.0 is described as an interactive generation model rather than a video generator: the transformation happens continuously on a live signal, not as a one-shot render.
Understanding what X2.0 is means understanding what it is not. Most tools people call a "real-time video generation model" are actually batch generators: you submit a prompt, a job runs on a server, and minutes later you download a finished clip. X2.0 inverts that. There is no render queue and no output file to wait for — the model consumes a live stream and returns a transformed live stream, so what you see updates as you move. That makes X2.0 suited to interactive experiences (filters, virtual characters, live avatars) rather than to producing a polished, edited film from a script. If you need a fully synthetic clip authored from text alone, X2.0 is the wrong tool; if you need a live feed transformed as it happens, that is exactly what it does.
Beyond transforming appearance, X2.0 supports live interaction. When an output element is bound, the SDK creates an interactive drag surface so a user can direct motion by dragging on the video — useful in MoX for steering an animated subject. Developers can also send control points manually with sendTracks(), passing coordinates based on the session's content resolution rather than the element's displayed size. Single-touch and multi-touch inputs are both supported, which is what lets the model respond to gestures in modes like DimX. This gesture-and-trajectory layer is the "interactive" half of "interactive generation" and is a key reason the real-time interactive video label fits X2.0.
Most modes need a reference image — the character to become, the outfit to wear, the style to adopt. The SDK uploads images directly to Tencent COS and returns a public URL you pass into a session as the reference. The helper checks the file type as it uploads (an image-only path rejects a video), fetches temporary storage credentials for you automatically, and hands back a url you drop straight into set(). That URL is reusable, so a product can let a user pick a reference once and apply it across sessions.
X2.0 uses a two-tier key model designed for browser and mobile safety. A permanent key lives on your backend and is never exposed in client-side code. Your server calls Xmax's temporary-API-key endpoint with that permanent key to mint a short-lived token, then returns only the token to the frontend, which uses it to open the realtime session.
Each temporary token carries two limits you set when you create it: an expireSeconds time-to-live, after which it stops working, and a pointsLimit usage quota. A temporary token cannot mint another temporary token, which prevents quota nesting and runaway delegation. In practice this means the credential your browser holds is always scoped, expiring, and revocable — the sensitive permanent key never leaves the server.
X2.0 bills by generation time: one credit equals one second of generation. New accounts receive free credits for evaluation, so teams can prototype before committing. Because the two token limits map cleanly onto duration and quota, billing is straightforward to reason about — you cap how long a session can run and how many points it can spend. For current rates, verify Xmax's current pricing rather than relying on any figure quoted elsewhere; see xmax pricing for how those credits translate into plans.
X2.0 is a developer-facing model. Using it means writing code: installing Xmax's JavaScript browser SDK (@xmaxai/sdk-global), handling authentication (a permanent key held server-side, plus short-lived tokens issued to the browser), and wiring up the WebRTC session yourself. Python and native mobile SDKs are listed by Xmax as in development, so today's integration path is the browser.
That's a reasonable bar for a product team shipping a custom feature. It's a high bar for anyone who just wants to try real-time face swap, outfit swap, or style transfer without writing a line of code. For a full walkthrough of the integration, see how to use Xmax and the Xmax X2.0 API guide.
LiveGen (livegen.ai) is a consumer web app built on Xmax's X2.0 model. It exposes the same real-time transformation capabilities — face swap, outfit swap, style morph, motion, and AR-style character summon — as a point-and-click browser experience. There's no SDK to install, no key to manage, and no WebRTC session to configure. You open LiveGen, allow camera access or upload a video, pick a mode, and watch the transformation happen live.
If you've read this page because you're evaluating what the X2.0 model does before deciding whether to integrate it, LiveGen is a fast way to see the capabilities in practice before you commit engineering time. LiveGen is an independent product and is not affiliated with Xmax.
Xmax is the company; X2.0 is the specific real-time video model it offers through its developer platform.
No. X2.0 transforms an existing video signal — live camera or uploaded footage — rather than generating video purely from a text prompt.
The official X2.0 API and SDK are developer tools that require integration work. LiveGen provides a no-code browser interface built on X2.0 for people who want to use the capabilities directly.
CharX (face swap), ClothX (outfit swap), VibeX (style transfer), MoX (motion/animation), DimX (AR character summon), and Free (custom prompts and reference images).
The current SDK is JavaScript for browsers. Native mobile SDKs are listed as in development by Xmax.
WebRTC is a low-latency streaming protocol, the same kind used for video calls. It lets X2.0 receive a live feed and return a transformed feed continuously, which a request-and-download upload API can't do.
The permanent key stays on your backend and never reaches client code. Your server mints a short-lived token with a time limit and a points quota, and only that scoped, expiring token is sent to the browser.
By generation time — one credit equals one second. New accounts get free credits to evaluate the model; verify current pricing for exact rates.
Not in the sense of a fully generative interactive world. X2.0 transforms a real incoming video signal in real time; it does not simulate a synthetic environment from scratch. See real-time generative video for how the terms differ.
Open your camera and become anyone — free to start, no sign-up for your first try.
Start generating free