Protoface Runway Gen-4 Image · Text to Image Turbo

Here's the thing nobody tells you about paid image nodes: the expensive part isn't the good result, it's finding it. Twelve attempts to land a composition is twelve bills. That's the case for the turbo operation - same model, same controls, four credits instead of six, built for the queue-it-again phase of the work.

Runway Gen-4 Image Turbo is text-to-image through your Protoface account, with the same prompt/resolution/aspect-ratio/reference-images contract as the full node sitting next to it in the menu. If you're choosing between them for a final asset, take the other one. If you're exploring, you're in the right place.

What it actually is

No weights, no local inference, no VRAM math. The Protoface pack generates this node from Runway's published request schema, and when you hit Queue it builds a JSON payload, validates it against that schema, uploads whatever media you attached, submits a job, polls it, and downloads the result into the local cache. What lands on the image socket is an ordinary IMAGE tensor, so every downstream node you already own - masking, upscaling, ControlNet - keeps working.

The KB's closed-model doc is the right frame for the trade: you're paying per call to borrow a model you were never allowed to download, and in exchange you accept that your prompts and reference images leave the machine and pass a filter you can't patch. For a draft stage specifically, that trade is easy - a throwaway composition is exactly the kind of thing you don't mind sending.

How it works, mechanically

Two details are worth understanding because they explain most of the "why did it do that" moments.

The first is request identity. Before submitting, the extension journals a digest of the account, the node's scope, the generation_id, the model, the schema fingerprint and the payload. Requeue an unchanged graph and it reuses the recorded job instead of buying another one - the effect is a cache, but it's a journal on disk, not ComfyUI's execution cache, so it survives a restart. Change the prompt and the digest changes, which is how it knows to submit a new request.

The second is validation before spend. Schema errors get raised before upload and before submission. The useful consequence: a malformed payload costs you nothing but a red node.

The controls

prompt - the positive prompt. One text box, multiline, art-direction friendly.

resolution - 1080p or 720p, default 1080p. Drafting, I'd leave it. The per-image saving from stepping down is already baked into turbo's price, and you want to judge composition at the resolution you'll deliver.

aspect_ratio - 1:1, 16:9, 9:16, 4:3, 3:4, default 4:3. This is your framing decision and it's easier to make here than to fix by cropping later.

reference_images - Default omits it entirely (plain text-to-image); Image sends native ComfyUI images; References sends a Protoface Reuse Result Asset handle from an earlier Protoface node, which avoids re-uploading media you already sent. Runway's contract allows three references, and a batch counts each image in it, so a single Load Image feeding a batch of four is already over budget and will error before you're charged. This is how you get a consistent character or product across a dozen drafts without a LoRA.

seed - Set-mode and optional. Default omits it; pin one when you want to hold the noise while you change a single word of prompt.

And the two housekeeping fields: generation_id (fixed = reuse the recorded job, increment = new paid generation - it is not a model seed) and request_scope (advanced, non-secret, assigned by the frontend; headless callers must set their own stable value).

Outputs

image, mask, files, run id. The mask is the alpha channel as a native ComfyUI mask - flip it, use it for compositing, feed it to an inpainting round. files has the untouched originals; send it to Protoface Save File to get them into output/ under a predictable prefix. run id goes in a note, or into Protoface Resume Run if the poll times out and you'd rather not pay twice.

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

or Manager → search Protoface → protoface-nodes → restart → reload the browser. ComfyUI 0.41.0+, Python 3.10+, dependencies installed with ComfyUI's own interpreter (httpx, jsonschema, Pillow, av). Then paste a key into the Protoface panel, lower right; on a server use PROTOFACE_API_KEY or PROTOFACE_API_KEY_FILE so it survives restarts.

Traps

Re-entering the key after every restart is the one that catches everyone. Interrupting is a best-effort cancel and not a refund. And if you're switching from the full node to this one mid-session, remember they're separate operations - your existing generation_id means nothing here, so the first queue on this node is a new paid request. Which is fine; that's the whole point of a four-credit draft.