Protoface Runway Gen-4 Turbo · Image to Video

Image-to-video is the one video job where a still does most of the directing. You already made the frame you like - in Flux, in Qwen, in this same pack - and this node takes that frame and moves it. Runway Gen-4 Turbo is the fast option: short clips, prompt-guided motion, no keyframes to manage, and a meter that reads 28 credits per second of output. A five-second clip is about 140 credits. Five attempts at a five-second clip is about 700. Plan for that.

How it works

It's a remote job wrapped in a ComfyUI node. The pack builds a request from the schema Runway publishes, checks it against that schema before anything is uploaded or charged, uploads the still, submits, polls with a progress bar, and downloads the finished clip into the local media cache. The clip arrives on a native VIDEO socket, which is a real ComfyUI type in this generation of the API - you can preview it, save it, or feed it to another Protoface node for a second pass.

The still goes up as an asset. Two things follow from that. First, if the image was produced by another node in this graph, you should route it through Protoface Reuse Result Asset and pick References mode instead of re-uploading the bytes - fewer uploads, one asset, faster queue. Second, the identity of that asset is part of the request identity: swap the still and you've bought a new job, even if every other control is identical.

The identity machinery is the part worth trusting. The extension journals a digest of account, node scope, generation_id, model, schema and payload before submission and reuses its idempotency key on ambiguous failures. So a browser disconnect mid-job doesn't mean a second charge when you requeue - and a polling timeout leaves you a recoverable job rather than a duplicate submission.

The inputs that matter

image (required) is the first frame. Mode dropdown: Image for a native ComfyUI image, References for a reuse handle, or an asset id/public URL. This is the input that decides whether the result is worth the money - a clean, well-lit, unambiguous subject animates beautifully; a busy composition with three focal points gives the model nothing to commit to.

prompt (required) describes the motion, not the picture. The still already says what's in frame. "Slow push in, hair moving in the wind, dust motes, camera handheld" is the right register. Re-describing the scene wastes the tokens and often fights the frame you gave it.

duration is an INT from 5 to 10 seconds, defaulting to 5. This is your cost dial, and it's linear: 5s ≈ 140 credits, 10s ≈ 280. Short is usually better anyway - Gen-4 Turbo holds motion for a short beat far more convincingly than it holds it for ten seconds.

aspect_ratio is genuinely optional at the API level: it's a Default/Set dropdown, and Default means the parameter is omitted rather than guessed. Leave it alone unless you have a specific frame to hit; setting it to something that doesn't match your still is a good way to spend credits on a crop.

Then generation_id - the paid-job identity. Keep it fixed to reuse or resume a job; increment it to buy a fresh one. It has nothing to do with any model seed. And request_scope, the non-secret per-node scope the frontend assigns and headless clients have to supply themselves.

Outputs

video (a VIDEO list), files (the original download - the pack keeps every asset, including non-media artifacts, and the actual container format is authoritative, so a downstream node that only accepts MP4 may need a conversion), and run id.

That run id is worth more here than anywhere else in the pack. At 28 credits a second, "queue again and hope" is an expensive instinct; Protoface Resume Run takes the id and retrieves the finished job with no submission at all.

Install

cd ComfyUI/custom_nodes
git clone --branch v0.1.0 --depth 1 https://github.com/protoface-ai/protoface-comfyui.git protoface
python -m pip install -r protoface/requirements.txt

Restart ComfyUI, reload the browser, then click Protoface in the lower-right corner for the key dialog. Headless or persistent setups use PROTOFACE_API_KEY or PROTOFACE_API_KEY_FILE. Requires ComfyUI 0.41.0+ and Python 3.10+; requirements.txt pulls httpx, jsonschema, Pillow and av, and av is what makes native video sockets work - if the clip output looks broken, check that dependency landed in ComfyUI's interpreter.

Where people get burned

Duration creep. Ten seconds feels safer than five and costs double. Cut it to the shortest clip that proves the shot.

Reusing generation_id across different stills. Change the image and the request changes; if you also left the id fixed, you're burning a queue cycle on something the journal may hand straight back. Increment when you actually want a new generation.

Rotating the API key and then wondering where the job went. Credentials namespace the cache, so an existing job after a key rotation comes back through Protoface Resume Run, not through requeueing the node.

Expecting a refund on interrupt. Interrupting requests cancellation, and cancellation is best effort. Check the run in your Protoface account rather than assuming.