ComfyUI Face Consistency: InstantID vs FaceID vs ReActor

You have a frontal photo of an authorized model and want to generate the same person in several settings. Or you already have a finished poster and only need to replace its face with that of an original virtual character. These are different workflows: the first injects identity during generation, while the second swaps a face during post-processing.

Three common ComfyUI options are InstantID, IPAdapter FaceID, and ReActor. Their names sound similar, but their roles are not. The current ComfyUI InstantID node targets SDXL and has the most dependencies. FaceID can cover SD1.5 and SDXL, but its model and LoRA must match. ReActor performs a post-processing face swap and does not participate in generation.

Start by deciding whether the task happens during generation or after the image exists. Then check model dependencies, tuning directions, common failures, and licensing boundaries.

1. The Three Routes: Generation-Time Identity vs Post-Processing

First decide whether you want to generate several new images of the same person or replace the face in an existing image. That choice determines the route.

Route	Role	Best for	Input	Model limits	Dependency complexity
InstantID	Generation-time identity preservation	Generating several new images of the same face	One face reference	The current ComfyUI_InstantID node targets SDXL	High (InsightFace + onnxruntime + antelopev2 + ControlNet + main InstantID model)
IPAdapter FaceID	Generation-time identity preservation	Generating several new images of the same face	One or more face references	SD1.5 + SDXL	Medium (InsightFace + FaceID model + matching LoRA)
ReActor	Post-processing face swap	Replacing only the face in an existing image	Target image + source face	Independent of the generation base model	Version-dependent (the 0.7 alpha core no longer mandates InsightFace, but models and licenses still need review)

Selection Rules

• Generate several new images of the same person -> InstantID or FaceID
• Replace only the face in a finished image -> ReActor
• Work from a single face reference -> all three can handle it, but InstantID and FaceID fit generation-time control
• Preserve the pose and composition of an existing image while changing the face -> ReActor is more direct

Put Licensing Boundaries First

InstantID and FaceID commonly rely on InsightFace to extract facial features. InsightFace code uses the MIT License, but its training data and models trained on that data are available by default for non-commercial research. The FaceID model card also limits those models to research use. ReActor describes itself as SFW-friendly and includes a nudity detector; its README likewise requires responsible use.

Before commercial or public release, review likeness authorization, model-weight licenses, and platform rules separately. The workflows here are limited to authorized or owned material, original characters, and internal testing.

2. InstantID: Generation-Time Identity for SDXL

2.1 Installation and Model Paths

InstantID has more dependencies than FaceID or ReActor. After installing the node, incorrect model paths are the most common setup failure.

Installation:

# 1. Clone the node
cd ComfyUI/custom_nodes
git clone https://github.com/cubiq/ComfyUI_InstantID.git

# 2. Install dependencies
pip install insightface onnxruntime onnxruntime-gpu

The default InsightFace 1.0 Python package no longer builds the optional C++/Cython face3d extension, which reduces local compiler requirements. If an older environment or tutorial still causes a build error, confirm the actual version and use an isolated environment before assuming that current releases require Visual Studio C++ Build Tools.

Model	Target path	Source
antelopev2	ComfyUI/models/insightface/models/antelopev2	InsightFace model
Main InstantID model	ComfyUI/models/instantid	InstantX on Hugging Face
InstantID ControlNet	ComfyUI/models/controlnet	InstantX on Hugging Face

The current ComfyUI_InstantID README says that the node is only for SDXL. Use FaceID instead when the workflow is based on SD1.5.

The ComfyUI_InstantID repository has been in maintenance-only mode since April 14, 2025. Critical fixes may still be merged, but the maintainer does not promise ongoing development, so check the current README before installation.

2.2 Workflow and Tuning

Basic workflow:

1. Load an SDXL checkpoint
2. Connect Apply InstantID and provide a frontal face reference
3. Feed the InstantID model and ControlNet conditions into the sampling chain
4. Generate the image

Reference quality directly affects likeness. A frontal, sharp, unobstructed, evenly lit image is usually more reliable. A profile, tiny face, blurry image, or heavy occlusion can cause detection failures or weak likeness.

Symptom	Adjustment
Likeness is too weak	Increase the InstantID model or ControlNet weight gradually
Image looks burned or prompt control weakens	Lower the InstantID model weight first, then compare with the baseline
CFG is too high	Follow the node README and lower it to about 4-5, or use RescaleCFG

The primary upstream InstantID path does not support multiple face references and uses the largest face for landmarks. ComfyUI_InstantID includes a more complex and slower Multi-ID example, but it should not be treated as a simple, stable multi-person baseline.

Advanced node features:

• Advanced InstantID: adjust the InstantID model and ControlNet weights separately
• Noise injection: reduce the burned look and fine-tune likeness
• image_kps input: use keypoints from another image to change the pose and reduce pose transfer from the identity reference

For tighter pose control, combine the workflow with ControlNet OpenPose.

3. IPAdapter FaceID: Generation-Time Identity for SD1.5 and SDXL

FaceID is the face-specific branch of IPAdapter. It uses a face-recognition embedding instead of a regular CLIP image embedding and can add a LoRA to improve identity consistency.

3.1 Installation and Model Pairing

Install the dependency in ComfyUI’s Python environment:

pip install insightface

Place FaceID models in ComfyUI/models/ipadapter and matching LoRAs in ComfyUI/models/loras. Unified Loader FaceID relies on the official filenames for automatic pairing, so renamed files can prevent automatic loading.

FaceID model	Matching LoRA	Paths
ip-adapter-faceid_sd15.bin	ip-adapter-faceid_sd15_lora.safetensors	models/ipadapter + models/loras
ip-adapter-faceid-plusv2_sd15.bin	ip-adapter-faceid-plusv2_sd15_lora.safetensors	Same
ip-adapter-faceid_sdxl.bin	ip-adapter-faceid_sdxl_lora.safetensors	Same
ip-adapter-faceid-plusv2_sdxl.bin	ip-adapter-faceid-plusv2_sdxl_lora.safetensors	Same

The model list and filenames can change with node updates. Before installation, check the ComfyUI_IPAdapter_plus README and pair every model and LoRA by base model and version. A missing or mismatched LoRA can noticeably reduce identity consistency.

Version differences:

• PlusV2: combines a face ID embedding with a controllable CLIP image embedding, allowing adjustment of face-structure weight
• Portrait: targets portrait generation, does not require a LoRA or ControlNet, and can accept several face images to improve likeness
• SDXL FaceID and PlusV2-SDXL: the model card labels them experimental, so do not present them as unconditionally stable

The ComfyUI_IPAdapter_plus repository has also been in maintenance-only mode since April 14, 2025.

3.2 Workflow and Tuning

FaceID does not have to start at a weight of 1.0. Excessive identity weight can make the result follow the reference more closely while weakening text-prompt control.

Tuning directions:

• Start around 0.8 to establish a baseline, then raise the weight gradually if likeness is weak
• To follow the prompt more closely, adjust weight type in IPAdapter Advanced or lower the weight
• PlusV2 also exposes a separate face-structure-related weight

FaceID and InstantID both add identity conditions during generation. FaceID covers SD1.5 and SDXL, while the current ComfyUI_InstantID node targets SDXL. Memory use varies with the base model, resolution, GPU, and node version, so one fixed number would be misleading.

4. ReActor: An SFW Post-Processing Face Swap

ReActor serves a different stage from the first two routes. It does not participate in diffusion generation; it swaps a face in an image that already exists.

4.1 Installation and Dependency Changes

The new ReActor 0.7.0 alpha core says that InsightFace and C++ Build Tools are no longer required. However, the current README model table and license section still list models such as buffalo_l and inswapper_128.onnx. Verify the current version before deciding either installation steps or usage rights.

Model	Current README path
buffalo_l	ComfyUI/models/insightface/models/buffalo_l
inswapper_128	ComfyUI/models/insightface
reswapper	ComfyUI/models/reswapper
hyperswap	ComfyUI/models/hyperswap
Face Restore models	ComfyUI/models/facerestore_models

Older tutorials often treat InsightFace and C++ Build Tools as fixed prerequisites. When instructions conflict, identify your ReActor version and follow that version’s README instead of mixing legacy dependency steps.

ReActor includes a nudity detector. Its README says that use of a real face should have the person’s consent and that public posts should clearly disclose their synthetic nature. Commercial rights for models such as buffalo_l and inswapper_128 must still be checked separately.

4.2 Workflow

Basic face-swap workflow:

1. Connect the image to process to input_image, and connect the authorized reference face to source_image
2. Start with a conservative strength in ReActorSetWeight
3. Optional: use Face Similarity to inspect likeness after the swap
4. Optional: use Face Restoration to repair edges and detail
5. Optional: save a face model and later load the same face embedding directly

Feature	Purpose
ReActorSetWeight	Adjust swap strength from 0% to 100% in the node’s increments; excessive strength can create a plastic look or unnatural edges
Face Similarity	Check likeness after the swap
Face Restoration	Repair edges and details after swapping; excessive strength can also create a plastic look
Face Model	Save or load a face embedding to reuse the same face

ReActor does not regenerate the composition, clothing, or pose. When the goal is to preserve the finished image and process only the face region, it is more direct than InstantID or FaceID.

5. Reference Quality and Common Troubleshooting

5.1 Reference-Image Checklist

Reference quality often matters more than adding more weight. A frontal, sharp, unobstructed, evenly lit image is usually easier to match. A profile, blurred face, tiny face, or heavy occlusion is difficult to recover even with higher weights.

Priority order:

1. Frontal > profile or angled face
2. Sharp > blurry
3. Unobstructed > glasses, mask, or hair covering the face
4. Even lighting > hard shadow or backlighting

The same principles apply to InstantID, FaceID, and ReActor references. If detection fails, crop the face or replace the reference before pushing every weight to its maximum.

5.2 Common Failure Table

Problem	Likely cause	What to do
Model not found (antelopev2 / buffalo_l / main InstantID model)	Wrong path or missing model	Check models/insightface/models, models/instantid, and other paths against the current README for the node
Detection fails (no face detected)	Profile, small face, blur, or occlusion	Use a frontal, sharp, unobstructed reference and crop the face if needed
Face matches, but pose or expression drifts	The face condition also carries some structural features	Use ControlNet for pose or switch to ReActor for an existing finished image
Likeness is weak	Missing FaceID LoRA, unsuitable weight, or poor reference	Check model and LoRA pairing, establish a baseline around 0.8, then change one variable at a time
Edges look unnatural or the face looks plastic	Face-swap or Face Restoration strength is too high	Lower swap and restoration strength; check target-face size, angle, and lighting
Dependency installation fails	Legacy tutorials, old nodes, and the current Python environment were mixed	Confirm node and InsightFace versions, then install from the current README in an isolated environment

Use this order:

• Detection fails -> inspect reference quality first
• Likeness is weak -> check models, LoRA pairing, and paths first
• Pose drifts -> decide whether the job needs generation-time identity, post-processing, or an added ControlNet

6. Combining ControlNet, Kontext, and LoRA

Keeping the same face does not lock the pose, body, clothing, or composition. When InstantID or FaceID supplies an identity condition, the reference pose, expression, or hairstyle may still influence the result.

Recommended combinations:

• InstantID or FaceID + ControlNet OpenPose -> the face condition handles identity while ControlNet handles the body and pose
• FaceID + regular IPAdapter -> FaceID anchors the face and regular IPAdapter controls style or composition; start both routes with conservative weights
• ReActor + upscaling and repair -> generate the target first, swap the face, then use face restoration or local inpainting if needed
• Kontext -> useful for changing the background, clothing, or scene in the same input image, but it is not a dedicated face-identity lock
• LoRA -> better suited to an original character or virtual brand persona that must be reused over time and has a training dataset

When pose must be precise, provide the target pose through ControlNet OpenPose. InstantID or FaceID can then handle the face while ControlNet handles the body and pose. If you only want to preserve the finished composition and replace the face, ReActor is more direct.

Related reading:

• Control Composition and Pose with ComfyUI ControlNet
• Reuse ComfyUI Workflows and Fix Missing Nodes or Models
• Load, Weight, and Combine LoRAs in ComfyUI

7. Compliance and Licensing Boundaries

Licenses and source-material rights are hard boundaries. A technically working workflow does not mean the material, model, and publication method are all authorized.

Separate InsightFace Code and Model Licenses

InsightFace code uses the MIT License and permits academic and commercial use. Its training data and pretrained models derived from that data are available by default only for non-commercial research. The current InsightFace README also provides separate licensing contacts for the inswapper series and open-source face-recognition models.

The FaceID model card likewise states that IP-Adapter-FaceID is for research use because it relies on InsightFace pretrained models. Do not treat a node’s code license as permission to use every model weight commercially.

ReActor Responsibility and Disclosure

The current ReActor release describes itself as SFW-friendly and includes a nudity detector. Its README requires users to follow local law, obtain consent when using a real face, and disclose face replacement or AI synthesis in public posts.

Source-Material Limits

The workflows here cover only:

• Model photos with explicit likeness and usage authorization
• Personal material that you own and have the right to process
• Original virtual characters that do not represent a real person
• Compliant internal tests that are not published

Before commercial or public release, verify likeness authorization, model-license scope, and platform rules separately. If any of these is unclear, do not publish or commercialize the result.

Summary and Next Steps

The decision is straightforward:

• Generation-time identity -> InstantID (the current ComfyUI node targets SDXL) or FaceID (SD1.5 + SDXL)
• Post-processing face swap -> ReActor
• Check reference quality, model paths, and version pairing before blindly raising weights
• A code license does not make every pretrained model commercially usable, and real faces also require likeness authorization

InstantID fits SDXL workflows and has more dependencies, but it separates identity and keypoint-related controls. FaceID supports more base models, but its model and LoRA must match. ReActor does not participate in diffusion generation and is suited to processing the face in an existing image.

Continue with:

• Pose drift or strict composition -> ComfyUI ControlNet in Practice
• Long-term reuse of an original character -> ComfyUI LoRA in Practice
• Upscaling or local repair after a face swap -> ComfyUI Upscaling and Inpainting
• Repeated node or model-path failures -> ComfyUI Workflow Reuse Guide