IPAdapter (IP-Adapter) transfers the look of a reference image, face, or style, into your generations to keep a character consistent across renders. It guides rather than copies: it nudges the model toward the reference’s features instead of pasting a face. FaceID variants use face embeddings for stronger identity. Tune the weight between roughly 0.5 and 0.9, and combine it with a LoRA or ControlNet for the strongest consistency.
What IPAdapter actually does
IPAdapter is an image-prompt adapter. Instead of describing a character in words, you hand the model a picture and say “make it look like this.” Under the hood it encodes the reference image into embeddings using a CLIP vision model, then injects those embeddings into the cross-attention layers alongside your text prompt. The result is generation steered toward the reference’s visual characteristics: facial features, style, color palette, or overall vibe, depending on which IPAdapter model you use.
The single most important thing to understand is that IPAdapter guides, it does not swap. It is not a face-swap tool like deepfake software that pastes one face onto another. It biases the diffusion process toward the reference so the output resembles it, but every generation is still freshly created. That means you get natural variation in angle, expression, and lighting while keeping a recognizable identity, which is exactly what you want for a consistent character across many scenes. It also means the resemblance is approximate, not pixel-perfect, and setting expectations correctly here saves a lot of frustration.
For character consistency specifically, IPAdapter is one of three main tools alongside LoRA training and prompt-based methods. Our character consistency techniques guide compares all of them; this article goes deep on IPAdapter. If you want to test character prompts quickly before setting up the local stack, our free NSFW AI image generator is a browser sandbox, though IPAdapter itself runs locally.
IPAdapter versus FaceID versus FaceID Plus
There are several IPAdapter models, and picking the right one is most of the battle:
ip-adapter_sd15 / ip-adapter_sdxl -> general image/style transfer
ip-adapter-plus -> stronger, more detailed transfer
ip-adapter-faceid -> face identity via InsightFace embeddings
ip-adapter-faceid-plus / plusv2 -> face identity + finer facial detail
ip-adapter-faceid_sdxl -> FaceID for SDXL checkpointsStandard IPAdapter transfers overall look: composition, style, color, and general appearance. Great for matching an art style or a vibe, weaker at locking a specific face.
FaceID uses InsightFace to extract a face embedding (the same kind of identity vector face-recognition systems use) and conditions on that. It is far better at preserving who the person is across poses and expressions, because it focuses on identity rather than the whole image. FaceID requires the insightface package installed alongside the adapter.
FaceID Plus and Plus v2 combine the face embedding with additional CLIP image features for finer facial detail, giving the strongest single-image identity preservation. Plus v2 adds a weight control specifically for how much the face structure dominates. For a recurring NSFW character from one reference, FaceID Plus v2 is usually the best choice.
Match the model to your base: ip-adapter-faceid_sdxl for SDXL, Pony, and Illustrious checkpoints; the SD1.5 FaceID variants for SD1.5. Mixing architectures fails the same way ControlNet does.
Weight tuning
IPAdapter weight controls how strongly the reference pulls the generation. This is the dial you will touch most:
0.3 to 0.5 -> subtle influence, prompt dominates, loose resemblance
0.5 to 0.7 -> balanced, recognizable but flexible (good default)
0.7 to 0.9 -> strong identity lock, less prompt freedom
1.0+ -> often over-baked, washed-out or rigid resultsStart around 0.6 to 0.7 for FaceID. Too low and the character drifts; too high and every image looks like a near-copy of the reference with no scene variation, and skin and lighting can go flat. FaceID Plus v2 also exposes a separate face-structure weight you can push higher than the overall weight when you want the bone structure to stay fixed while letting style flex.
If identity is slipping at a reasonable weight, the fix is usually a better reference image (clear, front-facing, well-lit, single subject) rather than cranking the weight. Garbage reference in, garbage identity out. Multiple reference images, where the adapter supports them, also stabilize identity by averaging across several angles.
A1111 and ControlNet integration
In A1111 and Forge, IPAdapter ships as part of the ControlNet extension. You use it like any other ControlNet unit:
- Open a ControlNet unit, enable it, and drop your reference image in.
- Set the Control Type to IP-Adapter.
- Choose the preprocessor (ip-adapter_clip_sdxl, or the insightface preprocessor for FaceID) and the matching IPAdapter model.
- Set control weight (this is your IPAdapter weight) around 0.6 to 0.7.
- Generate with your normal prompt describing the scene.
The prompt still drives the scene, pose, and setting; IPAdapter supplies the character. Because it lives in a ControlNet unit, you can run it alongside other units: OpenPose in unit 0 for the pose, IPAdapter FaceID in unit 1 for the face. That stack (pose plus identity) is the workhorse for putting a consistent character into arbitrary poses. Our ControlNet NSFW guide and OpenPose guide cover the other units.
ComfyUI nodes
ComfyUI has the most flexible IPAdapter implementation through the IPAdapter Plus node pack. A minimal FaceID graph looks like:
Load Checkpoint
Load Image (reference) -> IPAdapter Unified Loader (FaceID)
-> IPAdapter FaceID node (weight 0.7)
-> applies to MODEL
CLIP Text Encode (prompt + negative)
KSampler -> VAE Decode -> Save ImageThe IPAdapter Unified Loader handles fetching the right adapter and CLIP vision model, and the FaceID node takes the reference image, the InsightFace embedding, and the weight. You can chain multiple IPAdapter nodes to blend several references, mask the influence to part of the frame, or feed an image batch for multi-reference identity averaging. This flexibility is why serious character work tends to live in ComfyUI. Our ComfyUI for NSFW guide covers installing node packs and building graphs.
Settings reference
Use this as a starting grid and adjust from your reference quality and how much scene freedom you need.
| Goal | Model | Weight | Notes |
|---|---|---|---|
| Match an art style | ip-adapter / ip-adapter-plus | 0.5 to 0.7 | Transfers look and palette, not identity |
| Consistent face, one reference | ip-adapter-faceid-plusv2 | 0.6 to 0.8 | Best single-image identity option |
| SDXL / Pony / Illustrious face | ip-adapter-faceid_sdxl | 0.6 to 0.8 | Must use the SDXL FaceID build |
| Strong lock for close-ups | faceid-plusv2 + higher face weight | 0.8 | Push face-structure weight, keep overall lower |
| Multi-angle stability | faceid + image batch | 0.6 to 0.7 | Average several clean references |
These pair naturally with checkpoint choice; see our best NSFW checkpoints roundup for models that take FaceID well.
Combining IPAdapter with LoRA and ControlNet
IPAdapter is strong on its own but strongest in combination. The two pairings that matter:
IPAdapter plus a character LoRA. A LoRA trained on your character bakes the identity into the weights for the most reliable consistency; IPAdapter then reinforces it from a reference image and can correct drift on hard angles. If you have enough images to train a LoRA, that is the gold standard for a recurring character, and IPAdapter becomes a top-up rather than the primary mechanism. Our LoRA training guide walks through dataset prep and training. When you only have a single reference and cannot train, IPAdapter FaceID alone is your best option.
IPAdapter plus ControlNet OpenPose. This is the everyday combination. OpenPose fixes the body into the pose you want; IPAdapter FaceID keeps the face consistent across those poses. Run them as separate ControlNet units (or separate nodes in ComfyUI) and they cooperate cleanly because they control different things, geometry versus identity. Add a Depth unit if limb overlap gets confusing.
The order of reliability for a recurring character is: trained LoRA first, FaceID second, prompt-only last. IPAdapter sits in the middle as the no-training option and the LoRA reinforcement layer.
Choosing and preparing a reference image
The reference image quality determines almost everything about how well IPAdapter holds a character, and it is the part most people neglect. FaceID extracts an identity embedding from the face in your reference, so anything that obscures or distorts that face weakens the result. A reference that is blurry, lit from a hard side angle, partly turned away, cropped at the chin, or busy with multiple people gives the adapter an ambiguous identity to work from, and ambiguity becomes drift across your set.
The ideal reference is a clear, front-facing, evenly lit portrait of a single subject, with the face occupying a meaningful portion of the frame. Neutral expression works best as a base because it leaves the model free to generate other expressions without fighting a baked-in smile or frown. If you only have a flawed reference, it is often worth running it through an upscale and a light face cleanup first, so the embedding is extracted from a sharp face rather than a soft one.
Where the adapter supports multiple references, supplying three or four clean shots from slightly different angles stabilizes identity considerably. The adapter averages across them, which smooths out the quirks of any single photo and gives a more robust sense of the face from different viewpoints. This multi-reference approach is the closest IPAdapter gets to the stability of a trained LoRA without actually training one, and it is worth the small extra setup when consistency across many poses matters.
When IPAdapter is the right tool, and when it is not
IPAdapter earns its place when you need a recognizable, consistent character but do not have the dataset or time to train a LoRA. From a single good reference it gives you a face that holds across dozens of scenes, which is exactly what a one-off character set or a quick consistency job needs. It is also the right tool for style transfer, where standard IPAdapter can lock an entire art direction onto otherwise unrelated generations.
It is the wrong tool when you need exact, repeatable likeness at production scale, when body consistency matters as much as the face, or when you are building a character you will reuse for months. In all of those cases the time spent training a LoRA pays back many times over, and IPAdapter shifts from primary mechanism to a reinforcement layer that corrects the occasional bad angle. Knowing which situation you are in before you start saves you from forcing IPAdapter to do a LoRA’s job and being disappointed when the body or the fine details drift. Used for the job it is good at, a recognizable face from a single reference, it is fast, flexible, and genuinely reliable.
Realistic expectations and common failures
Be honest with yourself about what IPAdapter can do. It is not a face-swap and will not reproduce a face with forensic accuracy. It produces a recognizable, consistent character, which is the right goal for most work, but if you need an exact likeness, IPAdapter plus a trained LoRA plus a final inpaint pass on the face is the realistic path, not IPAdapter alone.
Identity drifts across renders. Reference too low-quality or weight too low. Use a clean, front-facing, well-lit single-subject reference and raise weight toward 0.8 for FaceID.
Output looks like a flat copy of the reference. Weight too high. Drop it toward 0.6 so the scene can breathe.
FaceID throws an error or does nothing. InsightFace not installed, or an architecture mismatch (SD1.5 FaceID on an SDXL checkpoint). Install insightface and confirm the model matches your base.
Face is consistent but the body is not. IPAdapter FaceID conditions on the face. Body consistency needs a LoRA or careful, repeated prompt description; FaceID alone will not lock body type.
Skin tone or lighting goes off. Standard IPAdapter transfers palette aggressively. Switch to FaceID (identity-focused) or lower the weight so your prompt controls lighting.
Faces still slightly soft. Finish with a dedicated face pass. Our ADetailer faces guide and inpainting guide cover the cleanup that takes a consistent-but-soft face to a sharp one.
The practical recipe is: clean reference, FaceID Plus v2 at weight 0.6 to 0.8, paired with OpenPose for the pose, optionally reinforced with a character LoRA, finished with a face inpaint. You can rough out scene ideas in the browser generator before committing to the local stack, but consistent character work is fundamentally a local-tools job. Set expectations at “recognizable and consistent” rather than “identical,” build the stack in that order, and you will get a character that holds together across an entire set of images.
A repeatable consistency workflow
To make character work predictable, run the same sequence each time:
- Prepare a clean, front-facing, single-subject reference, upscaled if it is soft.
- Load FaceID Plus v2 matched to your checkpoint architecture, weight 0.7.
- Add OpenPose in a second unit for the pose you want.
- Generate a small batch on varied seeds and check that the face reads as the same person across all of them.
- If it drifts, raise the FaceID weight or improve the reference; if it looks pasted-on, lower the weight.
- Once identity holds, run a face inpaint or ADetailer pass to sharpen, then upscale.
Follow that order and you sidestep the usual thrashing of changing five things at once. The characters that look genuinely consistent across a full set almost always came from a clean reference, a sensible FaceID weight, and a dedicated finishing pass, in that order, rather than from any single magic setting. Change one variable at a time, keep notes on the weights that worked for a given reference, and you will quickly build an intuition for where the sweet spot sits for your particular checkpoint and subject. That repeatability is what separates a one-off lucky render from a character you can actually deploy across a whole project.
Frequently asked questions
Is IPAdapter a face-swap tool?
No. IPAdapter guides the diffusion process toward a reference image rather than pasting a face onto an output. It injects the reference’s encoded features into the model’s cross-attention so the result resembles the reference, but every image is freshly generated. This gives natural variation in angle, expression, and lighting while keeping a recognizable identity. For forensic-accuracy likeness you need IPAdapter plus a trained LoRA plus a face inpaint pass.
What is the difference between IPAdapter and FaceID?
Standard IPAdapter transfers overall look, including style, composition, and color palette, but is weaker at locking a specific face. FaceID uses InsightFace to extract a face identity embedding and conditions on that, making it far better at preserving who the person is across poses and expressions. FaceID Plus v2 adds CLIP image features for finer facial detail and is the best single-image identity option for a recurring character.
What weight should I use for IPAdapter FaceID?
Start around 0.6 to 0.7. Below 0.5 the character drifts and the prompt dominates; above 0.9 every image becomes a near-copy of the reference with flat skin and no scene variation. If identity slips at a reasonable weight, improve the reference image rather than cranking the weight higher. FaceID Plus v2 also exposes a separate face-structure weight you can push higher to keep bone structure fixed.
Does IPAdapter work in A1111?
Yes, it ships inside the ControlNet extension. Open a ControlNet unit, enable it, drop in your reference, set the Control Type to IP-Adapter, choose the matching preprocessor and model, and set control weight around 0.6 to 0.7. Because it lives in a ControlNet unit, you can stack it with other units, such as OpenPose in one unit for the pose and IPAdapter FaceID in another for the face.
Should I use IPAdapter or train a LoRA for character consistency?
If you have enough quality images to train a character LoRA, that is the gold standard because it bakes identity into the weights for the most reliable consistency. IPAdapter FaceID is the best no-training option when you only have one reference, and it also reinforces a LoRA and corrects drift on hard angles. The reliability order is trained LoRA first, FaceID second, prompt-only last.
Why does FaceID throw an error or do nothing?
The two usual causes are a missing InsightFace installation, which FaceID requires to extract face embeddings, and an architecture mismatch, such as running an SD1.5 FaceID model on an SDXL checkpoint. Install the insightface package, confirm the FaceID model matches your base architecture (use ip-adapter-faceid_sdxl for SDXL, Pony, and Illustrious), and verify the correct preprocessor is selected in the ControlNet unit.
Can I keep both the face and body of a character consistent?
IPAdapter FaceID conditions on the face, so it reliably keeps the face consistent but does not lock body type. For consistent body proportions you need a trained LoRA, which can learn both face and body, or careful repeated prompt description of the body across renders. The common production setup is FaceID for the face, OpenPose for the pose, and a LoRA when body consistency also matters.
How do I combine IPAdapter with OpenPose?
Run them as separate ControlNet units in A1111 or separate nodes in ComfyUI, since they control different things. OpenPose in one unit fixes the body into your chosen pose; IPAdapter FaceID in another keeps the face consistent across those poses. They cooperate cleanly because geometry and identity do not conflict. Add a Depth unit if limb overlap gets confusing, keeping the Depth weight below the OpenPose weight.
