IPAdapter FaceID for Consistent NSFW Characters

ComfyUI IPAdapter FaceID is the most reliable answer to the hardest problem in AI character work, which is keeping the same face across separate generations. The single hardest problem in AI character generation is keeping the same face across multiple images. Your model produces a stunning portrait. You change one prompt token. The face shifts. Different cheekbones, different nose, different jawline. You can no longer convince yourself or your audience that this is the same person. For NSFW work this is the difference between a believable character and a generic AI-generated body, and the difference shows up immediately in engagement metrics on platforms like Fanvue or paid Patreon tiers. IPAdapter FaceID was the first credible answer to this problem, and despite being two years old it is still the default worth starting from.

Quick Answer: IPAdapter FaceID extracts facial embeddings from a reference image using InsightFace, then conditions Stable Diffusion to generate matching faces. For NSFW character consistency, use IPAdapter FaceID Plus V2 with weight 0.85, combine with a character LoRA, and feed it a clean front-facing reference at 512 squared or higher. PuLID gives better recognition accuracy but lower expression flexibility, FaceID gives the most flexible output with slightly lower accuracy.

Why Character Consistency Breaks

Here is the thing nobody tells you when you start generating AI characters. The model has no concept of "the same person." It has a probability distribution over faces, and every generation samples from that distribution. Two consecutive generations with identical prompts produce statistically similar faces, but never literally identical faces. As you change prompts to put your character in different scenes, the face drifts proportional to how much the surrounding context changes.

This is why prompt-only consistency fails no matter how much effort goes into it. Detailed physical descriptions, named features, weighted tokens: all of it constrains the distribution without pinning a single sample from it. Faces stay roughly similar within a seed family and drift the moment context changes, and even a modest drift rate means a meaningful share of what you publish looks like a different person.

The real problem is that prompts describe categories of features, not specific features. "Blue eyes, blonde hair, sharp jaw" describes thousands of possible faces. The model picks one each generation, and which one it picks depends on subtle interactions with every other token in the prompt. Change the lighting tag and the jaw shape shifts. Change the pose and the eye color saturation drifts. Prompt-only consistency is structurally impossible to scale.

IPAdapter FaceID was built specifically to bypass this. Instead of describing the face in tokens, it injects facial embeddings directly into the cross-attention layers. The model now has actual feature data to work from, not a probabilistic description.

Method Comparison

Method	VRAM	Note
IPAdapter FaceID Plus V2	7.8 GB	weight 0.85, not the 0.7 default
InstantID	8.5 GB	~28 s per generation, balances quality and speed
Heavier stack	10.2 GB	highest fidelity, slowest

Setup	Weight
IPAdapter standalone	0.85
IPAdapter plus character LoRA	0.7 to 0.75
Character LoRA strength	0.7 to 0.8

Leaving the weight at the 0.7 default is the single most common mistake here.

How Does IPAdapter FaceID Compare to PuLID and InstantID?

There are three credible character consistency tools in 2026: IPAdapter FaceID, PuLID, and InstantID. They all solve the same problem with different mechanisms, and the trade-offs are real but not always in the direction you would expect.

IPAdapter FaceID Plus V2 injects a face embedding and leaves expression and angle largely free. That flexibility is its selling point and also where identity drift shows up on extreme poses. It is the lightest of the three on VRAM.

PuLID locks identity harder. Faces come out more reliably recognisable and more rigid with it, and it wants noticeably more VRAM and time per image.

InstantID sits between the two on both axes, flexibility and lock.

Here is the hot take that goes against most of the comparison content out there. PuLID has the highest accuracy, but for NSFW character work, FaceID is often the better choice. The reason is expression flexibility. NSFW content requires a wide range of facial expressions, angles, and emotional states. PuLID locks the face so tight that you get a series of images that all look like the reference photo with a body attached. That is great for portrait work and terrible for diverse content.

InstantID sits in the middle and is the best balanced option for most users. The reason FaceID still tends to win is its integration with the broader IPAdapter ecosystem. The same node graph that runs FaceID also lets you stack style references, pose references, and depth references using the modular IPAdapter pipeline. Building on top of PuLID is harder because it does not share the same plumbing.

If you want to compare the three without rebuilding three separate ComfyUI workflows, lewdly.ai runs them side by side, which is a fast way to see how each behaves on your own reference before committing to one.

Setting Up IPAdapter FaceID in ComfyUI

The setup process has improved significantly since 2024 thanks to ComfyUI Manager. What used to be a manual model dance is now mostly a few clicks. Here is the current 2026 setup.

Install the IPAdapter Plus custom nodes:

Open ComfyUI Manager, search for "ComfyUI_IPAdapter_plus" by cubiq, install, restart ComfyUI. This is the canonical IPAdapter implementation in 2026 and most other ComfyUI workflows assume you have this installed.

Download the model weights:

The IPAdapter Plus repo expects models in specific subfolders. Get these four files at minimum:

• ip-adapter-faceid-plusv2_sd15.bin for SD 1.5 base models
• ip-adapter-faceid-plusv2_sdxl.bin for SDXL base models including Pony, Illustrious, Lustify
• ip-adapter-faceid-plusv2_sd15_lora.safetensors (the matching LoRA file)
• ip-adapter-faceid-plusv2_sdxl_lora.safetensors (matching LoRA for SDXL)

These go in ComfyUI/models/ipadapter/ (create the folder if missing). The matching LoRA files go in ComfyUI/models/loras/.

Install InsightFace:

IPAdapter FaceID uses InsightFace for the facial embedding extraction. ComfyUI Manager handles this automatically on newer versions, but if you run into "InsightFace not found" errors you need to manually pip install insightface into your ComfyUI Python environment. The buffalo_l model file goes in ComfyUI/models/insightface/models/buffalo_l/.

Build the workflow:

The minimum viable workflow has these nodes in this order:

1. Load Checkpoint (your base model)
2. Load Image (reference face image)
3. IPAdapter Unified Loader (set type to FaceID)
4. IPAdapter FaceID (connect reference image and model)
5. CLIP Text Encode for positive and negative prompts
6. KSampler
7. VAE Decode
8. Save Image

The IPAdapter FaceID node has the critical settings. Weight (start at 0.85, not the default 0.7), weight type (linear works for most cases), start_at and end_at (leave at 0 and 1 for full coverage).

The most common mistake here is leaving the weight at the default 0.7. Bumping to 0.85 produces noticeably more consistent faces. Above 0.95 starts looking like a face-swap onto an unrelated body, which is not what you want.

Reference Face Best Practices

Reference quality drives output quality more than any single setting. The best IPAdapter setup with a bad reference produces worse output than a mediocre setup with a great one, because everything downstream is built from that embedding. Here is what makes a reference work.

Resolution requirements:

The reference should be at least 512 squared, ideally 768 squared or higher. InsightFace processes the face at 112x112 internally, but the cropping pass needs enough source resolution to produce a clean 112x112 face. Below 512 the embeddings get noisy.

Framing requirements:

Front-facing or slight three-quarter angle. Profile shots do not produce usable embeddings because InsightFace cannot extract reliable landmark positions. The face should occupy at least 30% of the frame area.

Lighting requirements:

Even, neutral lighting. Heavy shadows on one side of the face cause the embedding to encode the lighting as part of the identity, which then bleeds into all your output. Studio lighting or natural diffuse daylight works best.

Expression requirements:

Neutral expression with slight smile or relaxed mouth. Extreme expressions get baked into the embedding and the model will fight against generating any other expression. The face you reference is the face you get, including the expression.

Resolution and quality:

If you want to generate a high-quality reference from a base checkpoint instead of using a real photo, generate at 1024 squared with ADetailer face cleanup enabled, then use that as your IPAdapter reference. The face quality jump from a clean AI-generated reference versus a casual webcam photo is significant.

The reason a clean AI-generated reference tends to beat a casual photo is that it has already been through a detailing pass, so the embedding is built from sharp, evenly lit, front-facing features rather than from compression artifacts and shadow. Garbage into the encoder is garbage across every downstream generation, and a reference is the one input you only prepare once.

Combining With a Character LoRA

IPAdapter alone gets you to about 85% consistency. The path to 95%+ runs through stacking a character LoRA on top of the FaceID conditioning. This is the production setup for serious character work and the part that most tutorials skip.

Training a matching character LoRA:

Use 15 to 30 images of your character generated with IPAdapter FaceID as the training set. The IPAdapter has already locked the face features. Now you train a LoRA that reinforces those features in the model's weights directly. The combination is multiplicative, not additive.

LoRA training for character LoRAs is a deep topic. For the full process, see the LoRA training guide for consistent AI influencer characters, which walks through dataset prep, captioning, and Kohya configuration.

Stack settings:

• Character LoRA strength: 0.7 to 0.8
• IPAdapter FaceID weight: 0.7 to 0.75 (lower than standalone because the LoRA is doing some of the work)
• CFG: 6.5 to 7.5
• Use ADetailer face cleanup as a final pass

The reason this combination works so well is that each tool covers a different consistency layer. The character LoRA reinforces overall identity features in the model weights. IPAdapter FaceID handles fine-grained facial geometry per-generation. ADetailer fixes the inevitable face-region resolution issue. Three layers of consistency, each catching what the others miss.

Which Setup Holds a Face Best

The tools sit in a predictable order, and the reason is in how each one injects identity rather than in any one person's results.

No consistency tool. The face comes entirely from the prompt and the checkpoint's own priors. Two generations from the same prompt are siblings, not the same person, because nothing carries identity between them.

IPAdapter FaceID Plus V2 alone. Identity is injected as a face embedding, so bone structure and feature placement carry across generations. Expression and angle stay free, which is what you want, but that freedom is also where drift shows up on extreme poses.

PuLID alone. Tighter identity lock than FaceID, at the cost of flexibility. Expressions come out more fixed, which reads as consistency in a grid and as stiffness in a set meant to look candid.

InstantID alone. Sits between the two. Less rigid than PuLID, less loose than FaceID.

IPAdapter FaceID Plus V2 plus a character LoRA. The strongest of these, because the two work on different layers: the embedding pins the face while the LoRA carries body, styling and the details a face embedding never sees. Short of explicit face-swapping, this is the production stack for shipping many images of one character.

Weights interact with your checkpoint, so treat the numbers in this guide as starting points and adjust against your own outputs rather than assuming they transfer.

When PuLID Wins

PuLID deserves a fair hearing rather than a dismissal. It is the right tool for specific use cases.

PuLID wins for:

• Portrait-heavy content where expression flexibility matters less
• Photoreal output where the 91% accuracy bump shows visibly
• One-off high-quality character shots rather than batch production
• Scenarios where you have a high-quality reference and want maximum fidelity

FaceID wins for:

• Batch production where you need 50+ images per week of the same character
• Mixed-style output (photoreal sometimes, anime sometimes, stylized sometimes)
• NSFW content with diverse poses and expressions
• VRAM-constrained setups where 2.4GB matters
• Workflows that need to stack with other IPAdapter modules

InstantID wins for:

• Users who want a balanced default and do not want to tune
• ID-card-style references where you have a clean front-facing photo
• Scenarios where you need both consistency and reasonable expression range

The right answer depends on your specific production constraints. For most NSFW character work, FaceID plus a character LoRA plus ADetailer is the stack that holds up best.

Production Tips and Workflow Download

A few things that took me a while to figure out and would have saved hours.

Use Unified Loader nodes: The IPAdapter Plus repo provides Unified Loader nodes that handle model loading automatically based on type. Use these instead of manually loading IPAdapter models. The newer nodes prevent the "wrong model for this checkpoint" mistakes that plagued the older manual setup.

Watch your reference batch: If you change reference images between generations, the IPAdapter cache invalidates and adds 2 to 3 seconds per generation for re-encoding. Keep your reference fixed for batch work and only change it when you want a different character.

Test reference images cheap first: Generate 5 test images at 512 squared with 15 steps to confirm the reference produces good output before committing to high-resolution batches. Bad references waste hours if you only catch the problem after generating 50 final images.

Combine with face detailer post-processing: The IPAdapter conditioning gets you 85% of the way. The face detailer pass at the end cleans up any remaining inconsistency artifacts and produces the final 5% that separates amateur output from production work.

If you want to skip the workflow building, lewdly.ai has IPAdapter FaceID Plus V2 plus character LoRA stacking pre-built with the production settings described above. You upload a reference, the platform handles the node graph, and the output uses the full stack including ADetailer post-processing. Worth a look if you do not want to maintain the ComfyUI workflow yourself.

Workflow downloads for ComfyUI are at the IPAdapter Plus GitHub repository under examples. The "faceid_plusv2.json" workflow is the right starting point. Drop it into ComfyUI, replace the reference image, and you have a working FaceID generation in about two minutes.

Frequently Asked Questions

What Is the Difference Between FaceID and FaceID Plus V2?

FaceID was the original. FaceID Plus added higher quality output. Plus V2 added improvements for SDXL and reduced color shift. Always use Plus V2 unless you are working with a legacy workflow that requires the original.

Can I Use Multiple Reference Faces?

Yes, but the IPAdapter Plus repo handles this through the IPAdapter Batch node. Stack 2 to 3 reference images of the same person from different angles and the encoder averages the embeddings. Useful for getting cleaner identity when you have multiple reference photos.

Does IPAdapter FaceID Work With Flux?

Partially. The FaceID Plus V2 models are SD1.5 and SDXL only. Flux requires the Flux-specific IPAdapter implementations which are less mature. PuLID has better Flux support if Flux is your target.

How Much VRAM Do I Need?

About 7.8GB for IPAdapter FaceID at SDXL resolutions. Add 1GB for the matching character LoRA. Add 2 to 3GB for the ADetailer pass. Total production stack runs around 11 to 12GB. Workable on 16GB cards, tight on 12GB cards, needs optimization on 8GB.

What Reference Image Resolution Is Optimal?

768 squared minimum, 1024 squared ideal. The InsightFace embedder needs enough source pixels to produce clean embeddings. Higher than 1024 does not help because the embedding network resamples down internally.

Should I Disable the Matching LoRA File?

No. The "ip-adapter-faceid-plusv2_*_lora.safetensors" file is part of the FaceID Plus V2 system and must load alongside the main model. The Unified Loader handles this automatically. If you load IPAdapter manually, make sure both files are wired.

How Do I Test If My Reference Is Good Enough?

Run a 5-image test batch at standard settings. If 4 out of 5 outputs look like the same person, your reference is fine. If they look like different people, your reference has issues (lighting, framing, resolution) and needs to be replaced before scaling up.

Can I Use This for Multiple Characters in One Image?

Yes, using the regional IPAdapter approach. Split the image into regions, apply different IPAdapter conditioning to each region, generate. Higher VRAM cost and more complex node graph but doable for two-character scenes.

Conclusion

Character consistency is the highest-leverage problem in AI generation. Solving it unlocks every other use case from AI influencer content to comic book production to NSFW character work. IPAdapter FaceID is the cheapest, most flexible solution that has stayed credible for two years and continues to improve.

The production stack is IPAdapter FaceID Plus V2 at weight 0.85, plus a character LoRA trained on FaceID-generated images at strength 0.7, plus ADetailer face cleanup at denoise 0.4. Short of explicit face-swapping, that combination is the most consistent setup available, because each layer pins something the others cannot.

PuLID is a credible alternative if expression range matters less to your use case. InstantID is the balanced middle ground. The right tool depends on what you are building. For NSFW character work specifically, FaceID plus a character LoRA remains the production default and the right recipe to start from.

Get the reference image right. Bump the weight to 0.85. Stack a character LoRA. Run ADetailer at the end. That is the recipe that gets you out of the consistency-is-broken hole and into actually shipping characters that your audience recognizes.

Related Reading

• ComfyUI LoRA Stacking Guide for NSFW Generations

Part of our complete guide to running NSFW AI locally.