FAL Image2Image

FAL Image2Image is the pack's editing node, and it exists for one specific reason: Kontext Pro is API-only, and even Kontext Dev - which you can download - is a 12B model that wants a serious chunk of VRAM to run well. This node takes an image already sitting in your ComfyUI graph, sends it to fal.ai, and gets an edit back. Change the clothing, swap the background, make the watermark vanish: one sentence, no local weights.

It's the natural partner to FAL Text2Image. Run your first pass locally (or via the T2I node), then bounce the result through here for edits with a model you never have to fit in memory.

How it works

Same queue-polling machinery as the T2I node: build a payload, POST to queue.fal.run, poll every ~0.8s, retry on transient errors, download and convert the result back to a ComfyUI IMAGE. The difference is the input. Your init_image tensor gets converted to a base64 PNG data URI and shipped inside the JSON request as image_url. That means the whole image rides in the payload, so keep source images reasonable - a giant 2048² input makes for a chunky request.

Kontext is an in-context editor rather than an adapter-based one, which is why it holds a subject's identity across a chain of edits instead of drifting. The strength input is your denoise dial: the pack's own verification notes that 0.2-0.4 preserves core features while higher values let the model reimagine more. Default is 0.75, which is a fairly aggressive edit.

The inputs that matter

• init_image - any IMAGE tensor in your graph (Load Image, a prior T2I output, whatever).
• model_id - from FAL Model Select. Pick a Kontext tier for real editing.
• strength - 0-1, default 0.75. Low = subtle, high = remix.
• prompt - the instruction. "Change the jacket to leather" beats vague prompts here.
• seed / steps / guidance - steps default 30, guidance 3.5. Kontext is guidance-distilled, so treat guidance as a flavor knob, not CFG.
• safety_mode, timeout_sec, retries - same story as the T2I node.

One trap: if you pick flux-schnell-redux, you're not doing img2img at all. Redux is a variation model - it takes your image and produces variations of it, and this node drops strength because that endpoint doesn't accept it. People have burned credits expecting to control how far the output drifts.

It also has an optional context_id input, meant to carry identity from a prior Text2Image run into a Kontext edit. Worth one honest caveat: in the shipped code that value is accepted but not actually injected into the fal payload yet, so the graph wiring is ready and the request plumbing isn't. Don't assume it's doing anything until you confirm otherwise.

Outputs are image (→ Save Image), image_url, and safety_applied.

Install

It ships in the ComfyUI_fal_image pack alongside the other FAL nodes - install once and you get all four:

cd ComfyUI/custom_nodes
git clone https://github.com/Paddel87/ComfyUI_fal_image.git
pip install -r ComfyUI_fal_image/requirements.txt
export FAL_KEY="fal-..."

Restart ComfyUI and the nodes appear under fal.ai/Image. ComfyUI Manager works too (search "ComfyUI_fal_image"). On the Windows portable build, use python_embeded/python.exe -m pip install ....

Common issues

• Output barely changed - your strength is too low. Low is good for identity, useless for actual edits.
• Output is a mess - strength too high, or you're using a Kontext model on a full-body shot, where anatomy is Kontext's known weak spot.
• Timeouts - Kontext Pro can run slow; raise timeout_sec before giving up.
• safety_applied = forced_by_model - the endpoint overrode your safety setting and regenerated with the filter on. Kontext is heavily censored at the model level, so this is common; plan prompts accordingly.

It's a small solo-authored pack, so treat it as a convenience wrapper. But for Kontext editing from inside ComfyUI without renting VRAM, it does exactly what it says.