☁️BizyAir Load InsightFace (PuLID Flux)

Before PuLID can inject an identity into a generation, something has to look at your reference photo and turn the face in it into a vector - a compact numerical description of who that person is, distinct from what background or lighting they're standing in. That's InsightFace's job, and it's the same job it does underneath nearly every no-training face tool in this ecosystem: IP-Adapter FaceID, InstantID, ReActor, PuLID. They're all different front ends wrapped around the same recognition backbone. Detect the face, align it, run it through ArcFace, get an embedding back. This loader node is where PuLID's pipeline picks up that backbone.

Note this is the classic (non-Nunchaku) PuLID path in this pack - it feeds a regular Flux model, not a quantized one. BizyAir ships a separate, parallel set of Nunchaku-branded PuLID nodes for the quantized pipeline; the two aren't interchangeable, so make sure this loader is feeding the right kind of model further down your chain.

The input that matters (there's exactly one)

• provider - currently only offers CUDA as a choice. This mirrors a setting from InsightFace's original design, where you'd pick which execution backend (CPU, CUDA, etc.) runs the face-detection model. Since this node executes on BizyAir's cloud servers rather than your machine, there's effectively nothing to decide here - you're not choosing your own hardware, just acknowledging a field that exists because the underlying node it's modeled on has it.

Output: face_analysis (BIZYAIR_FACEANALYSIS), which feeds into the next node in PuLID's chain - the model loader or apply step that actually uses this face analysis to extract and inject identity.

Worth knowing about what's underneath

InsightFace's code is MIT-licensed, but the pretrained ArcFace model weights it depends on are released for non-commercial research use only - a split that catches a lot of people who read "MIT" and stop reading. Every tool built on this backbone inherits that restriction from the weights, not from its own license, and switching between InsightFace-dependent tools doesn't change your position: PuLID, ReActor, and InstantID all sit on the same underlying dependency, so trading one for another buys you neither a better license nor a resolution ceiling you didn't have before. Running this through BizyAir doesn't remove that fact, it just moves the question from "what am I installing" to "what does BizyAir's service agreement say" - worth checking if you're building anything commercial on top of this.

Installing it

ComfyUI Manager: search BizyAir, install, restart. Or:

cd ComfyUI/custom_nodes
git clone https://github.com/siliconflow/BizyAir.git

Set your BizyAir API key on first use - without it this loader, like every other node in the pack, fails at execution rather than at startup.

Where people get burned

The main trap is architectural, not this node specifically: mixing the classic PuLID pipeline with the Nunchaku one. If your model came from a Nunchaku loader upstream, this classic InsightFace loader's output isn't built to feed into that chain - use the parallel NunchakuPulidLoader instead. And because this node's output type is BIZYAIR_FACEANALYSIS, not a stock ComfyUI type, it only connects to other BizyAir PuLID nodes - there's no local InsightFace node you can substitute mid-chain even if you have one installed separately.