Save Image (fal)

Save Image (fal) sits where ComfyUI's ordinary Save Image node does - at the end of the graph, taking the finished picture - but it does a different job. If you landed here wondering why a "fal" version of the save node showed up in your workflow: it belongs to the ComfyUI-fal-Connector, a bridge that runs your workflow on fal.ai's GPUs and returns the result over an API. SaveImage_fal marks which image the API should return.

Why you'd reach for it

A ComfyUI workflow is just a JSON graph - great for sharing, but it runs on your machine, tied to your GPU. The moment you want an app, a website, or a script to call your workflow and get images back, you have to turn that graph into a hosted service. That's the problem the fal connector solves, and SaveImage_fal is its exit door. fal, for context, is the GPU-cloud company behind a lot of hosted endpoints - they scaled up AuraFlow, they serve the only public IC-Light V2 - so this connector is their on-ramp for people who'd rather express a pipeline as a Comfy graph than hand-write an API call. Reach for it when your goal shifts from "make an image" to "let something else make images through my workflow." Generating only locally? The stock Save Image is all you need.

How it works

With the connector installed you build your workflow normally, then export it to "fal format" and POST that to fal's comfy-server endpoint. fal spins up a GPU, runs your exact graph, and collects the outputs. A normal Save Image writes a PNG into an output folder that an API caller can't see. SaveImage_fal instead registers the image as a named result of the run, so it comes back inside the JSON response fal returns. It's a terminal output node: nothing wires out of it, and its whole job is to tag "return this one."

The inputs that matter

From the node's real schema, three inputs, and only two you'll actually touch:

• images (IMAGE): the picture to return. Wire your VAE Decode (or your upscaler / final-image node) straight in, exactly like the stock save node.
• output_name (STRING, default output_input): the key your image appears under in the API response. Set it to something meaningful, and give each node a distinct name if you return more than one image.
• filename_prefix (STRING, default ComfyUI): the filename prefix, same as the standard node. Least important here.

There are no graph outputs. Downstream, the "connection" is the fal response payload, not another node.

Installing it

The honest install is not "just add the node." The readme's supported path clones an umbrella repo that vendors the connector plus the runtime patches it needs:

git clone --recursive https://github.com/badayvedat/ComfyUI-fal.git
cd ComfyUI-fal
pip install -r requirements.txt

The --recursive matters: without it the submodules (the actual runtime) never come down and you get a broken install. Then create a fal-config.ini and mind the readme's warning: it lives in ComfyUI-fal/custom_nodes/ComfyUI-fal-Connector, not the repo root. Put a fal API key from your fal dashboard in it (a Hugging Face token is optional, for gated models). Start main.py and the connector is live.

ComfyUI Manager can drop the connector node into an existing install if you search the pack title, but that won't set up your credentials or the runtime - treat Manager as the quick way to see the node and the umbrella clone as the way to actually run on fal. The node downloads no model files itself; the one hard requirement is a fal.ai account and API key.

Where people get burned

The failure you'll hit most is the node showing up but nothing coming back - almost always missing or misplaced credentials, because that config file sits in a deliberately non-obvious subdirectory (which is why the readme flags it). A close second is forgetting --recursive on the clone, which leaves a partial, broken install; re-clone with the flag. Remember too that the collect-and-return behavior only fires when the workflow runs through fal's comfy-server - run the same graph in a plain local ComfyUI and there's no API response, because locally it's just a save. Wire up two SaveImage_fal nodes and they need different output_name values or they'll collide. And worth saying out loud: this is paid remote compute - fal bills for the GPU seconds, so a run that's free-but-slow on your own card now costs a little each time.

Keep the usual custom-node habits on top of that: these are arbitrary Python installing into your shared environment, they can clash with other packs' dependencies, and you restart ComfyUI after installing. Install from a source you trust - this one is fal's own repo, about as safe as third-party nodes get.