OpenPose ControlNet locks the pose of an AI-generated figure by feeding the model a stick-figure skeleton of body, hand, and face keypoints. You get a pose from a reference photo (via the preprocessor), a pose library, or by editing one in sd-webui-openpose-editor, then control how strictly it is enforced with control weight and ending step. SD1.5 and SDXL need different OpenPose models.
What the OpenPose skeleton actually encodes
OpenPose is a pose-estimation system that represents a human body as a graph of keypoints connected by colored limbs. The standard body model marks 18 points: head, neck, shoulders, elbows, wrists, hips, knees, ankles, and facial anchors like eyes and ears. Extended versions add hand keypoints (21 per hand) and a dense set of face keypoints for expression and head orientation.
In ControlNet, that skeleton becomes a control image. The model is conditioned to place a body so its joints line up with the stick figure. Crucially, OpenPose encodes position and orientation only. It says nothing about body type, clothing, gender presentation, or what the figure is doing beyond the geometry of the limbs. That separation is the whole point: you control the pose with the skeleton and everything else with your prompt and checkpoint.
This is why OpenPose is so useful for NSFW work. You can specify an exact pose (kneeling, arched back, arms raised, a specific contact position) and let the prompt handle body and scene. Two skeletons in one control image give you a posed couple. The skeleton is agnostic to content, so the same pose works across any checkpoint you point it at. If you want to experiment with prompts before setting up ControlNet locally, our free NSFW AI image generator is a quick browser sandbox, though pose control itself requires a local install.
The three OpenPose variants
The ControlNet OpenPose preprocessor comes in flavors, and choosing the right one matters:
openpose -> body only (18 keypoints)
openpose_face -> body + detailed face keypoints
openpose_hand -> body + 21 hand keypoints per hand
openpose_full -> body + face + hands (everything)
dw_openpose_full -> DWPose detector, most accurate full skeletonBody-only is the most forgiving and the right default when you only care about the overall stance. The moment you enable face or hand keypoints, you are asking the model to honor much finer geometry, which raises the chance of conflict if the prompt wants something the skeleton cannot accommodate. Dw_openpose_full (the DWPose preprocessor) is the most accurate detector available and is worth using when you need clean hands and face from a reference, though it costs a little more processing time.
For NSFW poses, body-only or hands-included is usually enough. Face keypoints can over-constrain head tilt and expression; leave them off unless head orientation is the specific thing you are trying to control.
Getting a pose: three sources
From a reference image (preprocessor). Drop any photo with a clear human pose into ControlNet, set the preprocessor to an openpose variant, and it extracts the skeleton automatically. This is the fastest route when you have a reference. The detector works best on clear, unobstructed full-body shots; heavy occlusion or unusual camera angles produce broken skeletons.
From a pose library. Collections of pre-made OpenPose skeleton PNGs exist for common stances. You load the skeleton image directly and set the preprocessor to “none” (since it is already a skeleton, not a photo to analyze). Civitai hosts many pose packs; our Civitai NSFW guide covers finding and using them.
By editing in sd-webui-openpose-editor. This extension gives you a draggable skeleton you can pose by hand, joint by joint, then send straight to ControlNet. It is the best option for a pose that does not exist as a reference photo and is not in any library. You can also load a detected skeleton, fix the parts the detector got wrong (a flipped wrist, a missing limb), and re-feed the corrected version. For posed couples, you can add a second figure in the editor and arrange both.
Control weight and ending step: loose versus strict
Two parameters decide how hard ControlNet pushes the pose:
Control weight scales the strength of the conditioning. At 1.0 the model tries hard to match the skeleton exactly. Lower it toward 0.5 or 0.6 and the pose becomes a strong suggestion the model can deviate from for better anatomy. Higher than 1.0 (up to about 1.5) forces rigid adherence but risks stiff, unnatural results and artifacts where the prompt and skeleton disagree.
Ending step (Ending Control Step) sets how far into the denoising process ControlNet keeps applying. At 1.0 it guides every step. Dropping it to around 0.6 to 0.8 means the skeleton establishes the pose early, then releases control for the final steps so the model can refine anatomy and detail freely. This is the single most useful trick for natural-looking posed figures: lock the pose early, let go late.
Loose, natural pose:
Control Weight: 0.6
Starting Control Step: 0.0
Ending Control Step: 0.7
Strict, exact pose:
Control Weight: 1.0
Starting Control Step: 0.0
Ending Control Step: 1.0Start loose and tighten only if the model ignores the pose. Over-constraining is the most common reason posed figures look like mannequins.
OpenPose settings reference
The table summarizes the model and preprocessor choices for the two main architectures and gives sensible defaults.
| Architecture | OpenPose model | Preprocessor | Typical weight | Notes |
|---|---|---|---|---|
| SD1.5 | control_v11p_sd15_openpose | dw_openpose_full | 0.6 to 1.0 | Mature, reliable, lots of pose packs |
| SDXL | thibaud / xinsir SDXL openpose | dw_openpose_full | 0.6 to 1.0 | Use an SDXL-trained ControlNet, not the SD1.5 one |
| Pony / Illustrious | xinsir SDXL openpose (union) | dw_openpose_full | 0.5 to 0.9 | SDXL-based, lower weight often cleaner |
The critical rule: a ControlNet model must match your base model’s architecture. Control_v11p_sd15_openpose only works with SD1.5 checkpoints. SDXL, Pony, and Illustrious all need an SDXL-trained OpenPose ControlNet (the xinsir and thibaud releases are the common ones). Mixing them produces noise or no effect at all.
SDXL versus SD1.5 OpenPose in practice
SD1.5 has the most mature OpenPose ecosystem: the control_v11p_sd15_openpose model is rock solid, pose packs are everywhere, and the lower native resolution makes it fast to iterate. The trade-off is that SD1.5 anatomy is weaker, so poses with complex limb overlap need more cleanup.
SDXL-based models (including Pony and Illustrious) have better baseline anatomy and benefit from the xinsir SDXL ControlNet, which is genuinely good. The catch is that SDXL OpenPose can be slightly less precise at honoring fine keypoints, and you often get the best results at a marginally lower control weight (around 0.5 to 0.8) with an early ending step, letting SDXL’s stronger anatomy prior finish the job. For checkpoint selection, see our guides on Illustrious models and the best NSFW checkpoints.
Stacking OpenPose with the broader ControlNet toolkit is where it gets powerful, which our ControlNet NSFW guide covers end to end.
Stacking OpenPose with Depth
OpenPose controls the skeleton but not volume or how the body sits in 3D space. Stacking a second ControlNet unit with a Depth model adds that missing dimension. OpenPose says where the joints are; Depth says how the body occupies space, which limbs are closer to the camera, and how forms overlap.
The combination shines for poses with significant foreshortening or limb overlap, where OpenPose alone can flatten the figure or confuse which arm is in front. Set up two ControlNet units:
Unit 0: OpenPose
model: SDXL/SD1.5 openpose
weight: 0.7, ending step: 0.7
Unit 1: Depth
preprocessor: depth_anything or midas
weight: 0.4 to 0.6, ending step: 0.6Keep the Depth weight lower than the OpenPose weight so it informs volume without fighting the pose. If you do not have a depth reference, you can derive one from the same source image you used for the pose, or from a 3D-posed dummy. For couples and contact poses, Depth dramatically reduces the “whose limb is this” confusion that plagues OpenPose-only generations.
Editing skeletons by hand: the practical workflow
The openpose editor is worth learning properly because it removes your dependence on finding the perfect reference photo. When you open it, you get a default skeleton on a blank canvas sized to your output dimensions. Each joint is a draggable point, and the limbs redraw as you move them. The workflow that saves the most time is to start from a detected skeleton rather than from scratch: run the preprocessor on a roughly similar reference, send that skeleton to the editor, then nudge the joints that are wrong.
A few habits make hand-editing reliable. Keep the skeleton proportions human; a common beginner mistake is dragging a wrist far from the elbow, which produces a stretched arm in the render because the model tries to honor an impossible limb length. Match the canvas size to your generation resolution so the skeleton is not squashed or stretched when ControlNet reads it. And when you build a couple, give each figure a clearly separated skeleton so the detector and the model do not merge them; overlapping skeletons in the editor frequently produce a single confused figure with extra limbs.
Save skeletons you use often. A small personal library of hand-built poses (your go-to stances) means you never rebuild the same pose twice. You can drop a saved skeleton PNG straight into ControlNet with the preprocessor set to none, exactly like a downloaded pose pack. Over time this becomes faster than hunting for reference photos, and the poses are precisely what you want rather than an approximation.
How OpenPose interacts with the prompt and checkpoint
It helps to be clear about the division of labor, because most pose failures come from expecting OpenPose to do something it cannot. The skeleton supplies geometry. The prompt supplies identity, body type, clothing or lack of it, lighting, and scene. The checkpoint supplies the knowledge of how a body of that description actually looks in that geometry. When all three agree, you get a clean result. When they disagree, something gives.
A frequent conflict is asking for a pose the checkpoint barely understands. If the model has rarely seen a particular contortion, even a perfect skeleton at full weight will produce broken anatomy, because the model has no internal reference for how limbs connect in that configuration. The fix is not more control weight; it is choosing a checkpoint that knows the pose, or simplifying the pose toward something the model has seen. Raising weight on a confused model just makes the breakage more rigid.
The prompt should describe the figure as if the pose did not exist, then let the skeleton impose the pose. Do not try to describe the pose in words and enforce it with the skeleton at the same time; conflicting instructions (a prompt saying “standing” against a kneeling skeleton) confuse the generation. Let the skeleton own the pose and the prompt own everything else. This clean separation, more than any single setting, is what makes OpenPose dependable.
Why poses fail and how to fix them
The model ignores the skeleton. Almost always an architecture mismatch (SD1.5 ControlNet on an SDXL checkpoint or vice versa) or control weight set too low. Confirm the model matches your base, and raise weight toward 1.0.
The pose is honored but anatomy is broken. Control weight or ending step too high, forcing the model to contort. Lower the ending step to 0.6 to 0.7 so it can refine freely at the end.
Limbs in the wrong depth order. OpenPose cannot encode depth. Add a Depth ControlNet unit as above.
Broken skeleton from the preprocessor. The reference was occluded, low-contrast, or at an odd angle. Switch to dw_openpose_full for a more accurate detection, or fix the skeleton by hand in the openpose editor.
Hands mangled even with hand keypoints. Hand keypoints guide placement, not perfect rendering. Hands almost always need a dedicated cleanup pass regardless of OpenPose; see our fix hands guide and the ADetailer faces guide for the finishing passes.
Pose too extreme for the checkpoint. Some checkpoints simply have not seen certain poses and will fail no matter what. Try a different checkpoint, simplify the pose, or generate the figure in a more standard stance and adjust via img2img.
The reliable workflow is: pick a matching OpenPose model, start at weight 0.6 to 0.7 with ending step around 0.7, add Depth only when limb overlap demands it, then send the result through hand and face cleanup. You can sketch out prompts in the browser generator first, but the precise pose control lives in your local ControlNet stack. Build the pose, verify the skeleton matches what you intend, and treat the first generation as a draft you will finish, not a final image. Pose control is the foundation; the polish comes from the passes that follow.
A repeatable OpenPose checklist
To make this routine rather than guesswork, run through the same short checklist every time you set up a posed generation:
- Confirm the ControlNet model matches your checkpoint architecture. SD1.5 model for SD1.5, SDXL model for SDXL, Pony, and Illustrious. This single check prevents the most common total failure.
- Choose the preprocessor. Use dw_openpose_full for detection from a reference, or set it to none when loading a pre-made or hand-built skeleton.
- Decide how much of the skeleton you actually need. Body-only unless head orientation or hand placement is the specific thing you are controlling.
- Set a starting point of control weight 0.7 and ending step 0.7. Generate and judge whether the pose is honored.
- If ignored, raise weight toward 1.0. If stiff or anatomically broken, lower the ending step toward 0.6.
- If limbs overlap or the figure looks flat, add a Depth unit at weight 0.4 to 0.6.
- Once the pose holds, lock the seed and generate variations, then move to finishing.
Following the same order each time turns pose control from a frustrating trial-and-error loop into a predictable two-or-three-attempt process. The figures that look effortlessly and naturally posed almost always came from a loose-then-tighten approach with a clean architecture match underneath, followed by dedicated face and hand passes. OpenPose gets the body where you want it; the rest of the pipeline makes it convincing.
Frequently asked questions
What is the difference between control weight and ending step in OpenPose?
Control weight scales how strongly ControlNet enforces the skeleton; 1.0 demands an exact match while 0.6 makes the pose a strong suggestion. Ending step sets how far into denoising ControlNet keeps applying; at 0.7 the skeleton establishes the pose early then releases control so the model refines anatomy freely. Lowering the ending step is the best trick for natural, non-stiff posed figures.
Which OpenPose model do I use for SDXL versus SD1.5?
They are not interchangeable. SD1.5 uses control_v11p_sd15_openpose, which is mature and reliable. SDXL, Pony, and Illustrious need an SDXL-trained OpenPose ControlNet such as the xinsir or thibaud releases. The ControlNet architecture must match your base checkpoint, or you get noise or no effect. Use dw_openpose_full as the preprocessor on either architecture for the most accurate skeleton detection.
How do I get an OpenPose skeleton for a pose I want?
Three ways. Feed a clear reference photo to the openpose preprocessor and it extracts the skeleton automatically. Load a pre-made skeleton PNG from a pose library with the preprocessor set to none. Or build and adjust one by hand in sd-webui-openpose-editor, dragging each joint, which is best for poses that have no reference photo and for adding a second figure for couples.
Why does the model ignore my OpenPose skeleton entirely?
The most common cause is an architecture mismatch: using an SD1.5 ControlNet on an SDXL checkpoint or vice versa, which produces no effect. Confirm the OpenPose model matches your base model. The second cause is control weight set too low; raise it toward 1.0. Also verify ControlNet is actually enabled and the correct preprocessor or none is set for a pre-made skeleton.
What does stacking Depth with OpenPose accomplish?
OpenPose encodes joint positions but not volume or depth, so it can flatten figures or confuse which limb is in front. A second ControlNet unit running a Depth model adds that 3D information. Keep the Depth weight lower than the OpenPose weight, around 0.4 to 0.6, so it informs volume without fighting the pose. This is especially valuable for foreshortened poses and couples with overlapping limbs.
Do face and hand keypoints improve results?
They help when head orientation or hand placement is exactly what you need to control, but they over-constrain otherwise. Face keypoints can lock head tilt and expression too rigidly, and hand keypoints guide placement without guaranteeing clean rendering. For most NSFW poses, body-only or hands-included is enough. Hands almost always need a dedicated cleanup pass regardless, so enabling hand keypoints is no substitute for finishing work.
Why does my pose look stiff like a mannequin?
You are over-constraining. Control weight at or above 1.0 combined with an ending step of 1.0 forces the model to match the skeleton through every denoising step, leaving no room to add natural weight shift and anatomy. Drop the ending step to 0.6 to 0.7 so the pose is locked early and refined freely at the end, and lower control weight toward 0.6 if stiffness persists.
What preprocessor gives the most accurate skeleton?
dw_openpose_full, which uses the DWPose detector, is the most accurate OpenPose preprocessor available and handles hands and face cleanly. It costs slightly more processing time than the older openpose detectors but produces far fewer broken skeletons from difficult reference images. Use it whenever detection quality matters, and fall back to fixing the skeleton by hand in the openpose editor if even DWPose struggles with an occluded reference.
