Overview - Reactor

SANA-Streaming is a real-time video editing model. Feed it a video clip or a live webcam feed and describe a change in plain text. The model outputs an edited video stream alongside the source footage. The edit lands where you aim it; everything you don’t mention carries through from the source untouched. SANA-Streaming edits the video you bring rather than generating one from scratch. The prompt describes a change to apply, not a world to create, and the model’s job is to make that change and preserve everything else. The SANA-Streaming reference is split across four pages: this overview, the complete command and message schema, the prompt guide for writing surgical edit prompts, and an end-to-end tutorial. Build on SANA-Streaming with the typed @reactor-models/sana-streaming SDK: a <SanaStreamingProvider> and hooks for React, a SanaStreamingModel class for plain JavaScript, with every command, message, and track checked at compile time. It wraps the same base wire protocol every Reactor model speaks, so you can also drive it from the base Reactor client by command name (the path for Python). SANA-Streaming’s surface adds commands for setting the source video and applying edit prompts.

At a glance

Spec	Value
Model name	`sana-streaming`
Pricing
Resolution	1280 × 704

The model name is sana-streaming. The typed SDK bakes it in (new SanaStreamingModel(), <SanaStreamingProvider>); with the base class you pass it yourself (new Reactor({ modelName: "sana-streaming" })). See Pricing & Billing for how billing works.

Key features

Surgical edits

Change the one thing you name and nothing else.

Real-time responsiveness

Send a new edit mid-stream and watch it land about a second later, not after a re-render.

Live webcam input

Restyle yourself, your room, or your product demo as it streams.

Quick start

The fastest path to a working SANA-Streaming app is the create-reactor-app CLI, which scaffolds a runnable project for you. You can also clone the open-source reference frontend directly, or follow the tutorial for a guided walkthrough.

npm
pnpm

npx create-reactor-app my-sana-app --model=sana-streaming

pnpm create reactor-app my-sana-app --model=sana-streaming

A minimal connect-and-edit flow in React wraps your app in <SanaStreamingProvider> and drives the edit from a child component with useSanaStreaming():

Live webcam
Uploaded video

import {
  SanaStreamingProvider,
  useSanaStreaming,
  SanaStreamingMainVideoView,
} from "@reactor-models/sana-streaming";
import { useEffect } from "react";

function Editor() {
  const { status, publish, setPrompt, setMode, start } = useSanaStreaming();

  useEffect(() => {
    if (status !== "ready") return;
    void (async () => {
      // Publish your camera as the live source. Pin the resolution first:
      // a mid-chunk resolution change crashes the session.
      const cam = await navigator.mediaDevices.getUserMedia({ video: true });
      const track = cam.getVideoTracks()[0];
      track.contentHint = "detail";
      await publish("camera", track);

      // Describe the edit, then start.
      await setPrompt({
        prompt:
          "Replace the subject's t-shirt with a vintage dark brown leather aviator jacket with a cream shearling collar.",
      });
      await setMode({ mode: "live" });
      await start();
    })();
  }, [status]);

  // Render the edited stream as frames arrive.
  return <SanaStreamingMainVideoView className="w-full aspect-video" />;
}

export default function App() {
  // getToken() mints a short-lived JWT on your server (see Authentication).
  return (
    <SanaStreamingProvider getJwt={getToken} connectOptions={{ autoConnect: true }}>
      <Editor />
    </SanaStreamingProvider>
  );
}

import {
  SanaStreamingProvider,
  useSanaStreaming,
  SanaStreamingMainVideoView,
} from "@reactor-models/sana-streaming";

function Editor({ file }: { file: File }) {
  const { status, uploadFile, setVideo, setPrompt, setMode, start } = useSanaStreaming();

  // Call once status === "ready", e.g. from a button.
  async function edit() {
    // Upload a clip (at least 33 frames) and set it as the source...
    const ref = await uploadFile(file); // a video File or Blob
    await setVideo({ video: ref });

    // ...describe the edit, then start.
    await setPrompt({
      prompt:
        "Replace the background with a rain-streaked window at dusk, city lights glowing through the wet glass.",
    });
    await setMode({ mode: "file" });
    await start();
  }

  return (
    <>
      <button disabled={status !== "ready"} onClick={edit}>
        Apply edit
      </button>
      {/* Render the edited stream as frames arrive. */}
      <SanaStreamingMainVideoView className="w-full aspect-video" />
    </>
  );
}

export default function App() {
  // getToken() mints a short-lived JWT on your server (see Authentication).
  return (
    <SanaStreamingProvider getJwt={getToken} connectOptions={{ autoConnect: true }}>
      {/* Render <Editor file={...} /> once the user picks a clip. */}
    </SanaStreamingProvider>
  );
}

publish and uploadFile come from the base SDK and work the same on every model; useSanaStreaming() exposes them next to the typed commands (see Tracks and File Uploads). To change the edit mid-stream, call setPrompt again: the new edit lands at the next chunk boundary, about a second later. Prefer plain JavaScript? new SanaStreamingModel() carries the same typed methods; see the schema’s complete example.

How it works

On connect the model is live but idle. Give it a source (your camera or an uploaded clip) and call start; the edited stream begins on main_video. A prompt is optional: with none the model streams a near-reconstruction of the source, and setting one steers the edit. From there you direct it in real time: send a new prompt and the change lands at the next chunk boundary, so successive edits feel like adjustments to a live feed rather than separate render jobs. The architecture comes from the paper SANA-Streaming: Real-time Streaming Video Editing with Hybrid Diffusion Transformer (Zhao et al., 2026), research led by NVIDIA with collaborators at MIT, THU, NUS, and HKU. See the schema for every command and message, and the prompt guide for how to write edit prompts that land where you aim them.

​At a glance

​Key features